cleaner support for protocols

Author: danielsn

libdd-profiling/src/exporter/file_exporter.rs

@@ -14,13 +14,28 @@
 //! This module exists as a workaround and will hopefully be replaced once reqwest adds
 //! native support for file output: <https://github.com/seanmonstar/reqwest/issues/2883>
 
-#[cfg(any(unix, windows))]
 use std::path::PathBuf;
 
 /// HTTP 200 OK response with no body
-#[cfg(any(unix, windows))]
 const HTTP_200_RESPONSE: &[u8] = b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n";
 
+/// Spawns a dump server and configures the ClientBuilder with the appropriate transport
+pub(crate) fn spawn_dump_server_with_builder(
+    builder: reqwest::ClientBuilder,
+    output_path: PathBuf,
+) -> anyhow::Result<reqwest::ClientBuilder> {
+    let server_path = spawn_dump_server(output_path)?;
+
+    #[cfg(unix)]
+    {
+        Ok(builder.unix_socket(server_path))
+    }
+    #[cfg(windows)]
+    {
+        Ok(builder.windows_named_pipe(server_path.to_string_lossy().to_string()))
+    }
+}
+
 /// Async server loop for Unix sockets
 #[cfg(unix)]
 async fn run_dump_server_unix(
@@ -147,15 +162,13 @@ pub(crate) fn spawn_dump_server(output_path: PathBuf) -> anyhow::Result<PathBuf>
 }
 
 /// Helper function to find a subsequence in a byte slice
-#[cfg(any(unix, windows))]
 fn find_subsequence(haystack: &[u8], needle: &[u8]) -> Option<usize> {
     haystack
         .windows(needle.len())
         .position(|window| window == needle)
 }
 
 /// Parse Content-Length from HTTP headers
-#[cfg(any(unix, windows))]
 fn parse_content_length(headers_data: &[u8]) -> Option<usize> {
     if let Ok(headers_str) = std::str::from_utf8(headers_data) {
         for line in headers_str.lines() {
@@ -170,7 +183,6 @@ fn parse_content_length(headers_data: &[u8]) -> Option<usize> {
 }
 
 /// Check if we have received a complete HTTP request
-#[cfg(any(unix, windows))]
 fn is_request_complete(
     request_data: &[u8],
     headers_end_pos: Option<usize>,
@@ -186,7 +198,6 @@ fn is_request_complete(
 }
 
 /// Read complete HTTP request from an async stream
-#[cfg(any(unix, windows))]
 async fn read_http_request_async<R: tokio::io::AsyncReadExt + Unpin>(stream: &mut R) -> Vec<u8> {
     let mut request_data = Vec::new();
     let mut buffer = [0u8; 8192];
@@ -223,7 +234,6 @@ async fn read_http_request_async<R: tokio::io::AsyncReadExt + Unpin>(stream: &mu
 }
 
 /// Write request data to file if non-empty (async version)
-#[cfg(any(unix, windows))]
 async fn write_request_to_file_async(output_path: &PathBuf, request_data: &[u8]) {
     if !request_data.is_empty() {
         if let Err(e) = tokio::fs::write(output_path, request_data).await {
@@ -236,7 +246,6 @@ async fn write_request_to_file_async(output_path: &PathBuf, request_data: &[u8])
 }
 
 /// Handle a connection: read HTTP request, write to file, send response
-#[cfg(any(unix, windows))]
 async fn handle_connection_async<S>(mut stream: S, output_path: PathBuf)
 where
     S: tokio::io::AsyncReadExt + tokio::io::AsyncWriteExt + Unpin,

libdd-profiling/src/exporter/profile_exporter.rs

@@ -24,7 +24,7 @@
 //! The dumped files contain the complete HTTP request including headers and body,
 //! which can be useful for debugging or replaying requests.
 
-use super::file_exporter::spawn_dump_server;
+use super::file_exporter::spawn_dump_server_with_builder;
 use anyhow::Context;
 use libdd_common::tag::Tag;
 use libdd_common::{azure_app_services, tag, Endpoint};
@@ -64,29 +64,19 @@ impl ProfileExporter {
         mut tags: Vec<Tag>,
         endpoint: Endpoint,
     ) -> anyhow::Result<Self> {
-        #[cfg(not(any(unix, windows)))]
-        compile_error!("ProfileExporter requires either Unix or Windows platform");
-
         let mut builder = reqwest::Client::builder()
             .use_rustls_tls()
             .timeout(std::time::Duration::from_millis(endpoint.timeout_ms));
 
         let request_url = match endpoint.url.scheme_str() {
-            // File dump endpoint (debugging)
-            #[cfg(unix)]
-            Some("file") => {
-                let output_path = libdd_common::decode_uri_path_in_authority(&endpoint.url)
-                    .context("Failed to decode file path from URI")?;
-                let socket_path = spawn_dump_server(output_path)?;
-                builder = builder.unix_socket(socket_path);
-                "http://localhost/v1/input".to_string()
-            }
-            #[cfg(windows)]
+            // HTTP/HTTPS endpoints
+            Some("http") | Some("https") => endpoint.url.to_string(),
+
+            // File dump endpoint (debugging) - uses platform-specific local transport
             Some("file") => {
                 let output_path = libdd_common::decode_uri_path_in_authority(&endpoint.url)
                     .context("Failed to decode file path from URI")?;
-                let pipe_path = spawn_dump_server(output_path)?;
-                builder = builder.windows_named_pipe(pipe_path.to_string_lossy().to_string());
+                builder = spawn_dump_server_with_builder(builder, output_path)?;
                 "http://localhost/v1/input".to_string()
             }
 
@@ -98,10 +88,6 @@ impl ProfileExporter {
                 builder = builder.unix_socket(socket_path);
                 format!("http://localhost{}", endpoint.url.path())
             }
-            #[cfg(windows)]
-            Some("unix") => {
-                anyhow::bail!("unix:// endpoints are only supported on Unix platforms")
-            }
 
             // Windows named pipes
             #[cfg(windows)]
@@ -111,13 +97,9 @@ impl ProfileExporter {
                 builder = builder.windows_named_pipe(pipe_path.to_string_lossy().to_string());
                 format!("http://localhost{}", endpoint.url.path())
             }
-            #[cfg(unix)]
-            Some("windows") => {
-                anyhow::bail!("windows:// endpoints are only supported on Windows platforms")
-            }
 
-            // HTTP/HTTPS endpoints
-            _ => endpoint.url.to_string(),
+            // Unsupported schemes
+            scheme => anyhow::bail!("Unsupported endpoint scheme: {:?}", scheme),
         };
 
         // Pre-build all static headers