fix: adapt bottlecap to libdatadog HttpClientTrait architecture

libdatadog #1555 replaced raw hyper-client APIs with a HttpClientTrait
abstraction. SendData::send and send_with_retry now require
H: HttpClientTrait, and stats_utils::send_stats_payload_with_client
was removed in favor of a generic that constructs its own client
internally.

- Wrap the proxy/TLS-aware hyper client in a struct that implements
  libdd_capabilities::HttpClientTrait so it can be passed to libdd
  trace senders without losing custom proxy / CA / skip-SSL config.
- Inline the stats POST in stats_flusher to keep using the configured
  HttpClient (preserves Lambda's pool_max_idle_per_host(0) tuning that
  avoids stale connections after freeze/resume).
- Update obfuscation_config::ObfuscationConfig construction for the
  new nested HttpConfig/MemcachedConfig/RedisConfig layout.

Author: duncanista

bottlecap/src/bin/bottlecap/main.rs

@@ -1148,11 +1148,11 @@ fn start_trace_agent(
 
     let obfuscation_config = obfuscation_config::ObfuscationConfig {
         tag_replace_rules: config.apm_replace_tags.clone(),
-        http_remove_path_digits: config.apm_config_obfuscation_http_remove_paths_with_digits,
-        http_remove_query_string: config.apm_config_obfuscation_http_remove_query_string,
-        obfuscate_memcached: false,
-        obfuscation_redis_enabled: false,
-        obfuscation_redis_remove_all_args: false,
+        http: obfuscation_config::HttpConfig {
+            remove_paths_with_digits: config.apm_config_obfuscation_http_remove_paths_with_digits,
+            remove_query_string: config.apm_config_obfuscation_http_remove_query_string,
+        },
+        ..Default::default()
     };
 
     let trace_processor = Arc::new(trace_processor::ServerlessTraceProcessor {

bottlecap/src/traces/http_client.rs

@@ -6,23 +6,79 @@
 //! This module provides the HTTP client type required by `libdd_trace_utils`
 //! for sending traces and stats to Datadog intake endpoints.
 
+use http_body_util::BodyExt;
 use hyper_http_proxy;
 use hyper_rustls::HttpsConnectorBuilder;
-use libdd_common::{GenericHttpClient, http_common};
+use libdd_capabilities::{
+    MaybeSend,
+    http::{HttpClientTrait, HttpError},
+};
+use libdd_common::http_common::{self, Body, GenericHttpClient};
 use rustls::RootCertStore;
 use rustls_pki_types::CertificateDer;
 use std::error::Error;
 use std::fs::File;
+use std::future::Future;
 use std::io::BufReader;
 use std::sync::{Arc, LazyLock};
 use tracing::debug;
 
-/// Type alias for the HTTP client used by trace and stats flushers.
-///
-/// This is the client type expected by `libdd_trace_utils::SendData::send()`.
-pub type HttpClient =
+type InnerClient =
     GenericHttpClient<hyper_http_proxy::ProxyConnector<libdd_common::connector::Connector>>;
 
+/// HTTP client used by trace and stats flushers.
+///
+/// Wraps a hyper client preconfigured with optional proxy and TLS settings, and
+/// implements [`HttpClientTrait`] so it can be passed to `libdd_trace_utils`
+/// senders such as `SendData::send`.
+#[derive(Clone, Debug)]
+pub struct HttpClient {
+    inner: InnerClient,
+}
+
+impl HttpClient {
+    fn new(inner: InnerClient) -> Self {
+        Self { inner }
+    }
+}
+
+impl HttpClientTrait for HttpClient {
+    fn new_client() -> Self {
+        // Used by libdd APIs that construct a default client when no
+        // pre-configured one is supplied. Bottlecap's production code paths
+        // build the client via `create_client` so this fallback only matches
+        // libdatadog's `new_default_client` shape.
+        let connector = libdd_common::connector::Connector::default();
+        let proxy_connector = hyper_http_proxy::ProxyConnector::new(connector)
+            .expect("failed to build default proxy connector");
+        let inner = http_common::client_builder()
+            .pool_max_idle_per_host(0)
+            .build(proxy_connector);
+        HttpClient { inner }
+    }
+
+    fn request(
+        &self,
+        req: http::Request<bytes::Bytes>,
+    ) -> impl Future<Output = Result<http::Response<bytes::Bytes>, HttpError>> + MaybeSend {
+        let client = self.inner.clone();
+        async move {
+            let hyper_req = req.map(Body::from_bytes);
+            let response = client
+                .request(hyper_req)
+                .await
+                .map_err(|e| HttpError::Network(e.into()))?;
+            let (parts, body) = response.into_parts();
+            let collected = body
+                .collect()
+                .await
+                .map_err(|e| HttpError::ResponseBody(e.into()))?
+                .to_bytes();
+            Ok(http::Response::from_parts(parts, collected))
+        }
+    }
+}
+
 /// Initialize the crypto provider needed for setting custom root certificates.
 fn ensure_crypto_provider_initialized() {
     static INIT_CRYPTO_PROVIDER: LazyLock<()> = LazyLock::new(|| {
@@ -185,13 +241,15 @@ pub fn create_client(
             "HTTP_CLIENT | Proxy connector created with proxy: {:?}",
             proxy_https
         );
-        Ok(client)
+        Ok(HttpClient::new(client))
     } else {
         let proxy_connector = hyper_http_proxy::ProxyConnector::new(connector)?;
         // Disable connection pooling to avoid stale connections after Lambda freeze/resume.
         // See comment above for detailed explanation.
-        Ok(http_common::client_builder()
-            .pool_max_idle_per_host(0)
-            .build(proxy_connector))
+        Ok(HttpClient::new(
+            http_common::client_builder()
+                .pool_max_idle_per_host(0)
+                .build(proxy_connector),
+        ))
     }
 }

bottlecap/src/traces/stats_flusher.rs

@@ -11,7 +11,9 @@ use crate::config;
 use crate::lifecycle::invocation::processor::S_TO_MS;
 use crate::traces::http_client::HttpClient;
 use crate::traces::stats_aggregator::StatsAggregator;
+use bytes::Bytes;
 use dogstatsd::api_key::ApiKeyFactory;
+use libdd_capabilities::http::HttpClientTrait;
 use libdd_common::Endpoint;
 use libdd_trace_protobuf::pb;
 use libdd_trace_utils::{config_utils::trace_stats_url, stats_utils};
@@ -96,11 +98,11 @@ impl StatsFlusher {
 
         for attempt in 1..=FLUSH_RETRY_COUNT {
             let start = std::time::Instant::now();
-            let resp = stats_utils::send_stats_payload_with_client(
-                serialized_stats_payload.clone(),
+            let resp = send_stats_payload(
+                &self.http_client,
                 endpoint,
                 api_key.as_str(),
-                Some(&self.http_client),
+                serialized_stats_payload.clone(),
             )
             .await;
             let elapsed = start.elapsed();
@@ -167,3 +169,33 @@ impl StatsFlusher {
         }
     }
 }
+
+/// Posts a serialized stats payload using the supplied client.
+///
+/// Equivalent to libdatadog's `stats_utils::send_stats_payload`, but uses the
+/// caller-provided client so bottlecap's proxy/TLS configuration is preserved.
+async fn send_stats_payload(
+    client: &HttpClient,
+    target: &Endpoint,
+    api_key: &str,
+    data: Vec<u8>,
+) -> anyhow::Result<()> {
+    let req = http::Request::builder()
+        .method(http::Method::POST)
+        .uri(target.url.clone())
+        .header("Content-Type", "application/msgpack")
+        .header("Content-Encoding", "gzip")
+        .header("DD-API-KEY", api_key)
+        .body(Bytes::from(data))?;
+
+    let response = client
+        .request(req)
+        .await
+        .map_err(|e| anyhow::anyhow!("Failed to send trace stats: {e}"))?;
+
+    if response.status() != http::StatusCode::ACCEPTED {
+        let response_body = String::from_utf8(response.into_body().to_vec()).unwrap_or_default();
+        anyhow::bail!("Server did not accept trace stats: {response_body}");
+    }
+    Ok(())
+}