feat(capablities)!: sleep & spawn capabilities

datadog-sidecar/src/service/agent_info.rs

@@ -16,7 +16,7 @@ use datadog_ipc::platform::NamedShmHandle;
 use futures::future::Shared;
 use futures::FutureExt;
 use http::uri::PathAndQuery;
-use libdd_capabilities_impl::DefaultHttpClient;
+use libdd_capabilities_impl::NativeCapabilities;
 use libdd_common::{Endpoint, MutexExt};
 use libdd_data_pipeline::agent_info::schema::AgentInfoStruct;
 use libdd_data_pipeline::agent_info::{fetch_info_with_state, FetchInfoStatus};
@@ -103,7 +103,7 @@ impl AgentInfoFetcher {
             fetch_endpoint.url = http::Uri::from_parts(parts).unwrap();
             loop {
                 let fetched =
-                    fetch_info_with_state::<DefaultHttpClient>(&fetch_endpoint, state.as_deref())
+                    fetch_info_with_state::<NativeCapabilities>(&fetch_endpoint, state.as_deref())
                         .await;
                 let mut complete_fut = None;
                 {

datadog-sidecar/src/service/stats_flusher.rs

@@ -15,7 +15,7 @@ use datadog_ipc::shm_stats::{
     ShmSpanConcentrator, DEFAULT_SLOT_COUNT, DEFAULT_STRING_POOL_BYTES, RELOAD_FILL_RATIO,
 };
 use http::uri::PathAndQuery;
-use libdd_capabilities_impl::{HttpClientTrait, NativeCapabilities};
+use libdd_capabilities_impl::{HttpClientCapability, NativeCapabilities};
 use libdd_common::{Endpoint, MutexExt};
 use libdd_trace_stats::stats_exporter::{StatsExporter, StatsMetadata};
 use std::collections::HashMap;

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

@@ -5,8 +5,7 @@ use super::TraceSendData;
 use crate::agent_remote_config::AgentRemoteConfigWriter;
 use datadog_ipc::platform::NamedShmHandle;
 use futures::future::join_all;
-use libdd_capabilities::HttpClientTrait;
-use libdd_capabilities_impl::DefaultHttpClient;
+use libdd_capabilities_impl::{HttpClientCapability, NativeCapabilities};
 use libdd_common::{Endpoint, MutexExt};
 use libdd_trace_utils::trace_utils;
 use libdd_trace_utils::trace_utils::SendData;
@@ -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: DefaultHttpClient,
+    capabilities: NativeCapabilities,
 }
 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: DefaultHttpClient::new_client(),
+            capabilities: NativeCapabilities::new_client(),
         }
     }
 }
@@ -249,7 +248,7 @@ impl TraceFlusher {
 
     async fn send_and_handle_trace(&self, send_data: SendData) {
         let endpoint = send_data.get_target().clone();
-        let response = send_data.send(&self.client).await;
+        let response = send_data.send(&self.capabilities).await;
         self.metrics.lock_or_panic().update(&response);
         match response.last_result {
             Ok(response) => {

libdd-capabilities-impl/Cargo.toml

@@ -20,6 +20,7 @@ bytes = "1"
 http = "1"
 libdd-capabilities = { path = "../libdd-capabilities", version = "1.0.0" }
 libdd-common = { path = "../libdd-common", version = "4.0.0", default-features = false }
+tokio = { version = "1", features = ["time"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 http-body-util = "0.1"

libdd-capabilities-impl/README.md

@@ -8,11 +8,14 @@ Native implementations of `libdd-capabilities` traits.
 
 ## Capabilities
 
-- **`DefaultHttpClient`**: HTTP client backed by hyper and the `libdd-common` connector infrastructure (supports Unix sockets, HTTPS with rustls, Windows named pipes).
+- **`NativeHttpClient`**: HTTP client backed by hyper and the `libdd-common` connector infrastructure (supports Unix sockets, HTTPS with rustls, Windows named pipes).
+- **`NativeSleepCapability`**: Sleep backed by `tokio::time::sleep`.
+
+Task spawning is handled internally by `SharedRuntime` and is not exposed as a capability trait.
 
 ## 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.
+- **`NativeCapabilities`**: Bundle struct that implements HTTP and sleep capability traits using native backends. Delegates to `NativeHttpClient` and `NativeSleepCapability`.
 
 ## Usage
 

libdd-capabilities-impl/src/http.rs

@@ -4,28 +4,32 @@
 //! Native HTTP client implementation backed by hyper.
 
 mod native {
-    use libdd_capabilities::http::{HttpClientTrait, HttpError};
+    use std::sync::{Arc, OnceLock};
+
+    use libdd_capabilities::http::{HttpClientCapability, HttpError};
     use libdd_capabilities::maybe_send::MaybeSend;
     use libdd_common::connector::Connector;
     use libdd_common::http_common::{new_default_client, Body, GenericHttpClient};
 
     use http_body_util::BodyExt;
 
     #[derive(Clone)]
-    pub struct DefaultHttpClient {
-        client: GenericHttpClient<Connector>,
+    pub struct NativeHttpClient {
+        client: Arc<OnceLock<GenericHttpClient<Connector>>>,
     }
 
-    impl std::fmt::Debug for DefaultHttpClient {
+    impl std::fmt::Debug for NativeHttpClient {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            f.debug_struct("DefaultHttpClient").finish()
+            f.debug_struct("NativeHttpClient")
+                .field("initialized", &self.client.get().is_some())
+                .finish()
         }
     }
 
-    impl HttpClientTrait for DefaultHttpClient {
+    impl HttpClientCapability for NativeHttpClient {
         fn new_client() -> Self {
             Self {
-                client: new_default_client(),
+                client: Arc::new(OnceLock::new()),
             }
         }
 
@@ -35,7 +39,7 @@ mod native {
             req: http::Request<bytes::Bytes>,
         ) -> impl std::future::Future<Output = Result<http::Response<bytes::Bytes>, HttpError>> + MaybeSend
         {
-            let client = self.client.clone();
+            let client = self.client.get_or_init(new_default_client).clone();
             async move {
                 let hyper_req = req.map(Body::from_bytes);
 
@@ -57,4 +61,4 @@ mod native {
     }
 }
 
-pub use native::DefaultHttpClient;
+pub use native::NativeHttpClient;

libdd-capabilities-impl/src/lib.rs

@@ -4,58 +4,75 @@
 //! 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,
+//! traits using platform-native backends (hyper for HTTP, tokio for sleep,
 //! etc.). Leaf crates (FFI, benchmarks) pin this type as the generic parameter.
 
 mod http;
+pub mod sleep;
 
-pub use libdd_capabilities::HttpClientTrait;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub use http::DefaultHttpClient;
-
-#[cfg(not(target_arch = "wasm32"))]
-mod native {
-    use core::future::Future;
-
-    use libdd_capabilities::http::HttpError;
-    use libdd_capabilities::MaybeSend;
-
-    use super::DefaultHttpClient;
-    use super::HttpClientTrait;
-
-    /// 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,
+use core::future::Future;
+use std::time::Duration;
+
+pub use http::NativeHttpClient;
+use libdd_capabilities::{http::HttpError, MaybeSend};
+pub use libdd_capabilities::{HttpClientCapability, SleepCapability};
+pub use sleep::NativeSleepCapability;
+
+/// Bundle struct for native platform capabilities.
+///
+/// Delegates to [`NativeHttpClient`] for HTTP and [`NativeSleepCapability`] for
+/// sleep. Task spawning is handled internally by `SharedRuntime`.
+///
+/// Individual capability traits keep minimal per-function bounds (e.g.
+/// functions that only need HTTP require just `H: HttpClientCapability`, not the
+/// full bundle) so that native callers like the sidecar can use
+/// `NativeHttpClient` directly without pulling in this bundle.
+#[derive(Clone, Debug)]
+pub struct NativeCapabilities {
+    http: NativeHttpClient,
+    sleep: NativeSleepCapability,
+}
+
+impl Default for NativeCapabilities {
+    fn default() -> Self {
+        Self::new()
     }
+}
 
-    impl HttpClientTrait for NativeCapabilities {
-        fn new_client() -> Self {
-            Self {
-                http: DefaultHttpClient::new_client(),
-            }
+impl NativeCapabilities {
+    pub fn new() -> Self {
+        Self {
+            http: NativeHttpClient::new_client(),
+            sleep: NativeSleepCapability,
         }
+    }
+}
 
-        fn request(
-            &self,
-            req: ::http::Request<bytes::Bytes>,
-        ) -> impl Future<Output = Result<::http::Response<bytes::Bytes>, HttpError>> + MaybeSend
-        {
-            self.http.request(req)
+impl HttpClientCapability for NativeCapabilities {
+    fn new_client() -> Self {
+        Self {
+            http: NativeHttpClient::new_client(),
+            sleep: NativeSleepCapability,
         }
     }
+
+    fn request(
+        &self,
+        req: ::http::Request<bytes::Bytes>,
+    ) -> impl Future<Output = Result<::http::Response<bytes::Bytes>, HttpError>> + MaybeSend {
+        self.http.request(req)
+    }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-pub use native::NativeCapabilities;
+impl SleepCapability for NativeCapabilities {
+    fn new() -> Self {
+        Self {
+            http: NativeHttpClient::new_client(),
+            sleep: NativeSleepCapability,
+        }
+    }
+
+    fn sleep(&self, duration: Duration) -> impl Future<Output = ()> + MaybeSend {
+        self.sleep.sleep(duration)
+    }
+}

libdd-capabilities-impl/src/sleep.rs

@@ -0,0 +1,23 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Native sleep implementation backed by `tokio::time::sleep`.
+
+use core::future::Future;
+use std::time::Duration;
+
+use libdd_capabilities::maybe_send::MaybeSend;
+use libdd_capabilities::sleep::SleepCapability;
+
+#[derive(Clone, Debug)]
+pub struct NativeSleepCapability;
+
+impl SleepCapability for NativeSleepCapability {
+    fn new() -> Self {
+        Self
+    }
+
+    fn sleep(&self, duration: Duration) -> impl Future<Output = ()> + MaybeSend {
+        tokio::time::sleep(duration)
+    }
+}

libdd-capabilities/README.md

@@ -10,23 +10,23 @@ This crate has **zero platform dependencies**: it compiles on any target includi
 
 ## Traits
 
-- **`HttpClientTrait`**: Async HTTP request/response using `http::Request<Bytes>` / `http::Response<Bytes>`.
+- **`HttpClientCapability`**: Async HTTP request/response using `http::Request<Bytes>` / `http::Response<Bytes>`.
 - **`MaybeSend`**: Conditional `Send` bound: equivalent to `Send` on native, auto-implemented for all types on wasm. This bridges the gap between tokio's multi-threaded runtime (requires `Send` futures) and wasm's single-threaded model (where JS interop types are `!Send`).
 
 ## Architecture
 
 Three-layer design:
 
 1. **Trait definitions** (this crate): Pure traits, no platform deps.
-2. **Core crates** (`libdd-trace-utils`, `libdd-data-pipeline`): Generic over `C: HttpClientTrait`. Depend only on this crate for trait bounds.
+2. **Core crates** (`libdd-trace-utils`, `libdd-data-pipeline`): Generic over `C: HttpClientCapability`. Depend only on this crate for trait bounds.
 3. **Leaf crates** (FFI, wasm bindings): Pin a concrete type, `NativeCapabilities` from `libdd-capabilities-impl` on native, `WasmCapabilities` from the Node.js binding crate on wasm.
 
 ## Usage
 
 ```rust
-use libdd_capabilities::{HttpClientTrait, MaybeSend};
+use libdd_capabilities::{HttpClientCapability, MaybeSend};
 
-async fn fetch<C: HttpClientTrait>(client: &C, req: http::Request<bytes::Bytes>) {
+async fn fetch<C: HttpClientCapability>(client: &C, req: http::Request<bytes::Bytes>) {
     let response = client.request(req).await.unwrap();
     println!("status: {}", response.status());
 }

libdd-capabilities/src/http.rs

@@ -24,7 +24,7 @@ pub enum HttpError {
     Other(anyhow::Error),
 }
 
-pub trait HttpClientTrait: Clone + std::fmt::Debug {
+pub trait HttpClientCapability: Clone + std::fmt::Debug {
     fn new_client() -> Self;
 
     fn request(

libdd-capabilities/src/lib.rs

@@ -5,8 +5,12 @@
 
 pub mod http;
 pub mod maybe_send;
+pub mod sleep;
+pub mod spawn;
 
-pub use self::http::{HttpClientTrait, HttpError};
+pub use self::http::{HttpClientCapability, HttpError};
+pub use self::sleep::SleepCapability;
+pub use self::spawn::SpawnError;
 pub use ::http::{Request, Response};
 pub use bytes::Bytes;
 pub use maybe_send::MaybeSend;

libdd-capabilities/src/sleep.rs

@@ -0,0 +1,24 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Sleep capability trait.
+//!
+//! Abstracts async sleep so that native code can use `tokio::time::sleep`
+//! while wasm delegates to `setTimeout` via `JsFuture`.
+
+use crate::maybe_send::MaybeSend;
+use core::future::Future;
+use std::time::Duration;
+
+pub trait SleepCapability: Clone + std::fmt::Debug {
+    /// Construct a new sleeper.
+    ///
+    /// Stateless impls return a unit struct; stateful impls (mock clocks,
+    /// virtual time sources, etc.) should return a sensible default. Callers
+    /// that don't have an instance handy can use the static-style
+    /// `C::new().sleep(duration)` pattern, mirroring `HttpClientCapability`'s
+    /// `new_client()` + `request(&self)` shape.
+    fn new() -> Self;
+
+    fn sleep(&self, duration: Duration) -> impl Future<Output = ()> + MaybeSend;
+}