feat(capabilities)!: trait architecture http (#1555)

# What does this PR do?

Add capability trait architecture, and few native implementations.

# Motivation

Ongoing effort to make libdatadog wasm compatible.

# Additional Notes

In the long run, several other parts of the codebase ought to use these capabilities via the provided public structure, so that it can automagically choose the correct underlying implementation when compiling or not to wasm.

# How to test the change?

I should add some tests...

Co-authored-by: dubloom <75956635+dubloom@users.noreply.github.com>
Co-authored-by: jules.wiriath <jules.wiriath@datadoghq.com>

Author: Aaalibaba42

.github/CODEOWNERS

@@ -39,6 +39,7 @@ docker-bake.hcl                      @DataDog/apm-common-components-core
 docs                                 @DataDog/libdatadog
 examples                             @DataDog/libdatadog
 libdd-alloc/                         @DataDog/libdatadog-profiling
+libdd-capabilities*/                 @DataDog/apm-common-components-core
 libdd-common*/                       @DataDog/libdatadog
 libdd-crashtracker*/                 @DataDog/libdatadog-profiling
 libdd-data-pipeline*/                @DataDog/libdatadog-apm

Cargo.lock

@@ -29,6 +29,8 @@ members = [
   "libdd-trace-utils",
   "libdd-trace-stats",
   "datadog-tracer-flare",
+  "libdd-capabilities",
+  "libdd-capabilities-impl",
   "libdd-common",
   "libdd-common-ffi",
   "libdd-telemetry",

Cargo.toml

@@ -1,4 +1,4 @@
-root_name: builder, build_common, tools, libdd-alloc, libdd-crashtracker, libdd-common, libdd-telemetry, libdd-ddsketch, libdd-libunwind-sys, libdd-crashtracker-ffi, libdd-common-ffi, datadog-ffe, datadog-ffe-ffi, datadog-ipc, datadog-ipc-macros, libdd-tinybytes, spawn_worker, cc_utils, libdd-library-config, libdd-trace-protobuf, libdd-library-config-ffi, datadog-live-debugger, libdd-data-pipeline, libdd-dogstatsd-client, libdd-trace-stats, libdd-trace-utils, libdd-trace-normalization, libdd-log, datadog-live-debugger-ffi, libdd-profiling, libdd-profiling-protobuf, libdd-profiling-ffi, libdd-data-pipeline-ffi, libdd-ddsketch-ffi, libdd-log-ffi, libdd-telemetry-ffi, symbolizer-ffi, datadog-profiling-replayer, datadog-remote-config, datadog-sidecar, datadog-sidecar-macros, datadog-sidecar-ffi, libdd-trace-obfuscation, datadog-tracer-flare, sidecar_mockgen, test_spawn_from_lib, bin_tests
+root_name: builder, build_common, tools, libdd-alloc, libdd-crashtracker, libdd-common, libdd-capabilities, libdd-telemetry, libdd-ddsketch, libdd-libunwind-sys, libdd-crashtracker-ffi, libdd-common-ffi, datadog-ffe, datadog-ffe-ffi, datadog-ipc, datadog-ipc-macros, libdd-tinybytes, spawn_worker, cc_utils, libdd-library-config, libdd-trace-protobuf, libdd-library-config-ffi, datadog-live-debugger, libdd-data-pipeline, libdd-dogstatsd-client, libdd-trace-stats, libdd-trace-utils, libdd-trace-normalization, libdd-capabilities-impl, libdd-log, datadog-live-debugger-ffi, libdd-profiling, libdd-profiling-protobuf, libdd-profiling-ffi, libdd-data-pipeline-ffi, libdd-ddsketch-ffi, libdd-log-ffi, libdd-telemetry-ffi, symbolizer-ffi, datadog-profiling-replayer, datadog-remote-config, datadog-sidecar, datadog-sidecar-macros, datadog-sidecar-ffi, libdd-trace-obfuscation, datadog-tracer-flare, sidecar_mockgen, test_spawn_from_lib, bin_tests
 third_party_libraries:
 - package_name: addr2line
   package_version: 0.24.2

LICENSE-3rdparty.yml

@@ -16,6 +16,7 @@ use datadog_ipc::platform::NamedShmHandle;
 use futures::future::Shared;
 use futures::FutureExt;
 use http::uri::PathAndQuery;
+use libdd_common::DefaultHttpClient;
 use libdd_common::{Endpoint, MutexExt};
 use libdd_data_pipeline::agent_info::schema::AgentInfoStruct;
 use libdd_data_pipeline::agent_info::{fetch_info_with_state, FetchInfoStatus};
@@ -101,7 +102,9 @@ impl AgentInfoFetcher {
             parts.path_and_query = Some(PathAndQuery::from_static("/info"));
             fetch_endpoint.url = http::Uri::from_parts(parts).unwrap();
             loop {
-                let fetched = fetch_info_with_state(&fetch_endpoint, state.as_deref()).await;
+                let fetched =
+                    fetch_info_with_state::<DefaultHttpClient>(&fetch_endpoint, state.as_deref())
+                        .await;
                 let mut complete_fut = None;
                 {
                     let mut infos_guard = agent_infos.0.lock_or_panic();

datadog-sidecar/src/service/agent_info.rs

@@ -5,9 +5,8 @@ use super::TraceSendData;
 use crate::agent_remote_config::AgentRemoteConfigWriter;
 use datadog_ipc::platform::NamedShmHandle;
 use futures::future::join_all;
-use http_body_util::BodyExt;
-use libdd_common::http_common::new_default_client;
-use libdd_common::{Endpoint, HttpClient, MutexExt};
+use libdd_common::capabilities::HttpClientTrait;
+use libdd_common::{DefaultHttpClient, Endpoint, MutexExt};
 use libdd_trace_utils::trace_utils;
 use libdd_trace_utils::trace_utils::SendData;
 use libdd_trace_utils::trace_utils::SendDataResult;
@@ -96,7 +95,7 @@ pub(crate) struct TraceFlusher {
     pub(crate) min_force_drop_size_bytes: AtomicU32, // put a limit on memory usage
     remote_config: Mutex<AgentRemoteConfigs>,
     pub metrics: Mutex<TraceFlusherMetrics>,
-    client: HttpClient,
+    client: DefaultHttpClient,
 }
 impl Default for TraceFlusher {
     fn default() -> Self {
@@ -107,7 +106,7 @@ impl Default for TraceFlusher {
             min_force_drop_size_bytes: AtomicU32::new(trace_utils::MAX_PAYLOAD_SIZE as u32),
             remote_config: Mutex::new(Default::default()),
             metrics: Mutex::new(Default::default()),
-            client: new_default_client(),
+            client: DefaultHttpClient::new_client(),
         }
     }
 }
@@ -255,12 +254,7 @@ impl TraceFlusher {
             Ok(response) => {
                 if endpoint.api_key.is_none() {
                     // not when intake
-                    match response.into_body().collect().await {
-                        Ok(body) => {
-                            self.write_remote_configs(endpoint.clone(), body.to_bytes().to_vec())
-                        }
-                        Err(e) => error!("Error receiving agent configuration: {e:?}"),
-                    }
+                    self.write_remote_configs(endpoint.clone(), response.into_body().to_vec());
                 }
                 info!("Successfully flushed traces to {endpoint:?}");
             }

datadog-sidecar/src/service/tracing/trace_flusher.rs

@@ -0,0 +1,22 @@
+# Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+name = "libdd-capabilities-impl"
+version = "0.1.0"
+description = "Native implementations of libdd-capabilities traits"
+homepage = "https://github.com/DataDog/libdatadog/tree/main/libdd-capabilities-impl"
+repository = "https://github.com/DataDog/libdatadog/tree/main/libdd-capabilities-impl"
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+
+[lib]
+crate-type = ["lib"]
+bench = false
+
+[dependencies]
+bytes = "1"
+http = "1"
+libdd-capabilities = { path = "../libdd-capabilities", version = "0.1.0" }
+libdd-common = { path = "../libdd-common", version = "3.0.2" }

libdd-capabilities-impl/Cargo.toml

@@ -0,0 +1,26 @@
+# libdd-capabilities-impl
+
+Native implementations of `libdd-capabilities` traits.
+
+## Overview
+
+`libdd-capabilities-impl` provides platform-native backends for the capability traits defined in `libdd-capabilities`. It is the concrete implementation used by native leaf crates (FFI bindings, benchmarks, tests) and should **not** be depended on by core library crates.
+
+## Capabilities
+
+- **`DefaultHttpClient`**: HTTP client backed by hyper and the `libdd-common` connector infrastructure (supports Unix sockets, HTTPS with rustls, Windows named pipes).
+
+## Types
+
+- **`NativeCapabilities`**: Bundle type alias that implements all capability traits using native backends. Currently delegates to `DefaultHttpClient`; as more capability traits are added (spawn, sleep, etc.), this type will implement all of them.
+
+## Usage
+
+Native leaf crates pin the concrete capability type:
+
+```rust
+use libdd_capabilities_impl::NativeCapabilities;
+use libdd_data_pipeline::TraceExporter;
+
+let exporter: TraceExporter<NativeCapabilities> = TraceExporterBuilder::new(/* ... */).build();
+```

libdd-capabilities-impl/README.md

@@ -0,0 +1,7 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Re-exports `DefaultHttpClient` from `libdd-common`, where it lives alongside
+//! the hyper infrastructure it wraps.
+
+pub use libdd_common::DefaultHttpClient;

libdd-capabilities-impl/src/http.rs

@@ -0,0 +1,48 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Native capability implementations for libdatadog.
+//!
+//! `NativeCapabilities` is the bundle struct that implements all capability
+//! traits using platform-native backends (hyper for HTTP, tokio for spawn,
+//! etc.). Leaf crates (FFI, benchmarks) pin this type as the generic parameter.
+
+mod http;
+
+use core::future::Future;
+
+pub use http::DefaultHttpClient;
+use libdd_capabilities::http::HttpError;
+pub use libdd_capabilities::HttpClientTrait;
+use libdd_capabilities::MaybeSend;
+
+/// Bundle struct for native platform capabilities.
+///
+/// Delegates to [`DefaultHttpClient`] for HTTP. As more capability traits are
+/// added (spawn, sleep, etc.), additional fields and impls are added here
+/// without changing the type identity — consumers see the same
+/// `NativeCapabilities` throughout.
+///
+/// Individual capability traits keep minimal per-function bounds (e.g.
+/// functions that only need HTTP require just `H: HttpClientTrait`, not the
+/// full bundle) so that native callers like the sidecar can use
+/// `DefaultHttpClient` directly without pulling in this bundle.
+#[derive(Clone, Debug)]
+pub struct NativeCapabilities {
+    http: DefaultHttpClient,
+}
+
+impl HttpClientTrait for NativeCapabilities {
+    fn new_client() -> Self {
+        Self {
+            http: DefaultHttpClient::new_client(),
+        }
+    }
+
+    fn request(
+        &self,
+        req: ::http::Request<bytes::Bytes>,
+    ) -> impl Future<Output = Result<::http::Response<bytes::Bytes>, HttpError>> + MaybeSend {
+        self.http.request(req)
+    }
+}