feat(capabilities): trait architecture http draft

Author: Aaalibaba42

Cargo.lock

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

Cargo.toml

@@ -0,0 +1,17 @@
+# Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+name = "libdd-capabilities"
+version = "0.1.0"
+edition = "2021"
+description = "Portable capability traits for cross-platform libdatadog"
+homepage = "https://github.com/DataDog/libdatadog"
+repository = "https://github.com/DataDog/libdatadog"
+license = "Apache-2.0"
+
+[lib]
+crate-type = ["lib"]
+
+[dependencies]
+

libdd-capabilities/Cargo.toml

@@ -0,0 +1,176 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! HTTP capability trait and types.
+
+use crate::maybe_send::MaybeSend;
+use core::fmt;
+use core::future::Future;
+
+#[derive(Debug, Clone)]
+pub struct HttpResponse {
+    pub status: u16,
+    pub body: Vec<u8>,
+}
+
+#[derive(Debug, Clone)]
+pub enum HttpError {
+    Network(String),
+    Timeout,
+    InvalidRequest(String),
+    Other(String),
+}
+
+impl fmt::Display for HttpError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            HttpError::Network(msg) => write!(f, "Network error: {}", msg),
+            HttpError::Timeout => write!(f, "Request timed out"),
+            HttpError::InvalidRequest(msg) => write!(f, "Invalid request: {}", msg),
+            HttpError::Other(msg) => write!(f, "HTTP error: {}", msg),
+        }
+    }
+}
+
+impl std::error::Error for HttpError {}
+
+/// Request without body (GET, HEAD, DELETE, OPTIONS).
+#[derive(Debug, Clone, Default)]
+pub struct RequestHead {
+    pub url: String,
+    pub headers: Vec<(String, String)>,
+}
+
+impl RequestHead {
+    pub fn new(url: impl Into<String>) -> Self {
+        Self {
+            url: url.into(),
+            headers: Vec::new(),
+        }
+    }
+
+    pub fn with_header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
+        self.headers.push((name.into(), value.into()));
+        self
+    }
+}
+
+/// Request with body (POST, PUT, PATCH).
+#[derive(Debug, Clone)]
+pub struct RequestWithBody {
+    pub head: RequestHead,
+    pub body: Vec<u8>,
+}
+
+impl RequestWithBody {
+    pub fn new(url: impl Into<String>, body: Vec<u8>) -> Self {
+        Self {
+            head: RequestHead::new(url),
+            body,
+        }
+    }
+
+    pub fn with_header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
+        self.head = self.head.with_header(name, value);
+        self
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum HttpRequest {
+    Get(RequestHead),
+    Head(RequestHead),
+    Delete(RequestHead),
+    Options(RequestHead),
+    Post(RequestWithBody),
+    Put(RequestWithBody),
+    Patch(RequestWithBody),
+}
+
+impl HttpRequest {
+    pub fn get(url: impl Into<String>) -> Self {
+        Self::Get(RequestHead::new(url))
+    }
+
+    pub fn head(url: impl Into<String>) -> Self {
+        Self::Head(RequestHead::new(url))
+    }
+
+    pub fn delete(url: impl Into<String>) -> Self {
+        Self::Delete(RequestHead::new(url))
+    }
+
+    pub fn options(url: impl Into<String>) -> Self {
+        Self::Options(RequestHead::new(url))
+    }
+
+    pub fn post(url: impl Into<String>, body: Vec<u8>) -> Self {
+        Self::Post(RequestWithBody::new(url, body))
+    }
+
+    pub fn put(url: impl Into<String>, body: Vec<u8>) -> Self {
+        Self::Put(RequestWithBody::new(url, body))
+    }
+
+    pub fn patch(url: impl Into<String>, body: Vec<u8>) -> Self {
+        Self::Patch(RequestWithBody::new(url, body))
+    }
+
+    pub fn with_header(self, name: impl Into<String>, value: impl Into<String>) -> Self {
+        match self {
+            Self::Get(head) => Self::Get(head.with_header(name, value)),
+            Self::Head(head) => Self::Head(head.with_header(name, value)),
+            Self::Delete(head) => Self::Delete(head.with_header(name, value)),
+            Self::Options(head) => Self::Options(head.with_header(name, value)),
+            Self::Post(req) => Self::Post(req.with_header(name, value)),
+            Self::Put(req) => Self::Put(req.with_header(name, value)),
+            Self::Patch(req) => Self::Patch(req.with_header(name, value)),
+        }
+    }
+
+    pub fn url(&self) -> &str {
+        match self {
+            Self::Get(h) | Self::Head(h) | Self::Delete(h) | Self::Options(h) => &h.url,
+            Self::Post(r) | Self::Put(r) | Self::Patch(r) => &r.head.url,
+        }
+    }
+
+    pub fn headers(&self) -> &[(String, String)] {
+        match self {
+            Self::Get(h) | Self::Head(h) | Self::Delete(h) | Self::Options(h) => &h.headers,
+            Self::Post(r) | Self::Put(r) | Self::Patch(r) => &r.head.headers,
+        }
+    }
+
+    pub fn body(&self) -> &[u8] {
+        match self {
+            Self::Get(_) | Self::Head(_) | Self::Delete(_) | Self::Options(_) => &[],
+            Self::Post(r) | Self::Put(r) | Self::Patch(r) => &r.body,
+        }
+    }
+
+    pub fn into_body(self) -> Vec<u8> {
+        match self {
+            Self::Get(_) | Self::Head(_) | Self::Delete(_) | Self::Options(_) => Vec::new(),
+            Self::Post(r) | Self::Put(r) | Self::Patch(r) => r.body,
+        }
+    }
+
+    pub fn method_str(&self) -> &'static str {
+        match self {
+            Self::Get(_) => "GET",
+            Self::Head(_) => "HEAD",
+            Self::Delete(_) => "DELETE",
+            Self::Options(_) => "OPTIONS",
+            Self::Post(_) => "POST",
+            Self::Put(_) => "PUT",
+            Self::Patch(_) => "PATCH",
+        }
+    }
+}
+
+pub trait HttpClientTrait {
+    fn request(
+        req: HttpRequest,
+    ) -> impl Future<Output = Result<HttpResponse, HttpError>> + MaybeSend;
+}

libdd-capabilities/src/http.rs

@@ -0,0 +1,12 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Portable capability traits for cross-platform libdatadog.
+
+pub mod http;
+pub mod maybe_send;
+
+pub use http::{
+    HttpClientTrait, HttpError, HttpRequest, HttpResponse, RequestHead, RequestWithBody,
+};
+pub use maybe_send::MaybeSend;

libdd-capabilities/src/lib.rs

@@ -0,0 +1,45 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Conditional `Send` bound for cross-platform compatibility.
+//!
+//! On native targets, `MaybeSend` is equivalent to `Send`.
+//! On wasm32, `MaybeSend` is auto-implemented for all types.
+//!
+//! This allows traits to require `Send` on native (for multi-threaded runtimes)
+//! while remaining compatible with wasm's single-threaded execution model.
+//!
+//! # Why This Exists
+//!
+//! JavaScript interop types (like `JsFuture`, `JsValue`) are **not `Send`**
+//! because wasm is single-threaded. But on native, tokio's multi-threaded
+//! runtime requires `Send` futures. `MaybeSend` bridges this gap:
+//!
+//! ```rust,ignore
+//! // Instead of:
+//! fn request() -> impl Future<Output = Response> + Send;  // Won't compile on wasm!
+//!
+//! // Use:
+//! fn request() -> impl Future<Output = Response> + MaybeSend;  // Works everywhere!
+//! ```
+//!
+//! # Critical Rule
+//!
+//! **Never use `+ Send` directly in trait bounds for async functions in
+//! wasm-compatible code.** Always use `+ MaybeSend` instead.
+
+/// A trait that is `Send` on native targets, but auto-implemented on wasm.
+///
+/// Use this instead of `Send` in all capability trait bounds.
+#[cfg(not(target_arch = "wasm32"))]
+pub trait MaybeSend: Send {}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl<T: Send> MaybeSend for T {}
+
+/// On wasm, `MaybeSend` is implemented for all types (no `Send` requirement).
+#[cfg(target_arch = "wasm32")]
+pub trait MaybeSend {}
+
+#[cfg(target_arch = "wasm32")]
+impl<T> MaybeSend for T {}

libdd-capabilities/src/maybe_send.rs

@@ -16,6 +16,7 @@ crate-type = ["lib"]
 bench = false
 
 [dependencies]
+libdd-capabilities = { path = "../libdd-capabilities" }
 anyhow = "1.0"
 futures = "0.3"
 futures-core = { version = "0.3.0", default-features = false }
@@ -37,7 +38,8 @@ regex = "1.5"
 reqwest = { version = "0.13", features = ["rustls"], default-features = false, optional = true }
 rustls-native-certs = { version = "0.8.1", optional = true }
 thiserror = "1.0"
-tokio = { version = "1.23", features = ["rt", "macros", "net", "io-util", "fs"] }
+tokio = { version = "1.23", features = ["rt", "rt-multi-thread", "macros", "net", "io-util", "fs", "time"] }
+bytes = "1"
 tokio-rustls = { version = "0.26", default-features = false, optional = true }
 serde = { version = "1.0", features = ["derive"] }
 static_assertions = "1.1.0"

libdd-common/Cargo.toml

@@ -0,0 +1,79 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! HTTP capability implementation using hyper.
+
+#[cfg(not(target_arch = "wasm32"))]
+mod hyper_client {
+    use crate::{connector::Connector, hyper_migration};
+    use http_body_util::BodyExt;
+    use libdd_capabilities::http::{HttpClientTrait, HttpError, HttpRequest, HttpResponse};
+    use libdd_capabilities::maybe_send::MaybeSend;
+    use std::sync::OnceLock;
+
+    static HTTP_CLIENT: OnceLock<hyper_migration::GenericHttpClient<Connector>> = OnceLock::new();
+
+    fn get_client() -> &'static hyper_migration::GenericHttpClient<Connector> {
+        HTTP_CLIENT.get_or_init(hyper_migration::new_default_client)
+    }
+
+    pub struct HyperHttpClient;
+
+    impl HttpClientTrait for HyperHttpClient {
+        #[allow(clippy::manual_async_fn)]
+        fn request(
+            req: HttpRequest,
+        ) -> impl std::future::Future<Output = Result<HttpResponse, HttpError>> + MaybeSend
+        {
+            async move {
+                let client = get_client();
+
+                let uri: hyper::Uri = req
+                    .url()
+                    .parse()
+                    .map_err(|e| HttpError::InvalidRequest(format!("Invalid URL: {}", e)))?;
+
+                let method = match &req {
+                    HttpRequest::Get(_) => hyper::Method::GET,
+                    HttpRequest::Head(_) => hyper::Method::HEAD,
+                    HttpRequest::Delete(_) => hyper::Method::DELETE,
+                    HttpRequest::Options(_) => hyper::Method::OPTIONS,
+                    HttpRequest::Post(_) => hyper::Method::POST,
+                    HttpRequest::Put(_) => hyper::Method::PUT,
+                    HttpRequest::Patch(_) => hyper::Method::PATCH,
+                };
+
+                let mut builder = hyper::Request::builder().method(method).uri(uri);
+
+                for (key, value) in req.headers() {
+                    builder = builder.header(key.as_str(), value.as_str());
+                }
+
+                let body = hyper_migration::Body::from(req.into_body());
+                let hyper_req = builder.body(body).map_err(|e| {
+                    HttpError::InvalidRequest(format!("Failed to build request: {}", e))
+                })?;
+
+                let response = client
+                    .request(hyper_req)
+                    .await
+                    .map_err(|e| HttpError::Network(format!("Request failed: {}", e)))?;
+
+                let status = response.status().as_u16();
+
+                let body_collected = response.into_body().collect().await.map_err(|e| {
+                    HttpError::Network(format!("Failed to read response body: {}", e))
+                })?;
+                let body_bytes = body_collected.to_bytes();
+
+                Ok(HttpResponse {
+                    status,
+                    body: body_bytes.to_vec(),
+                })
+            }
+        }
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub use hyper_client::HyperHttpClient;

libdd-common/src/capabilities/http.rs

@@ -0,0 +1,14 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+//! Capability trait implementations.
+
+#[cfg(not(target_arch = "wasm32"))]
+pub mod http;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub use http::HyperHttpClient;
+
+pub use libdd_capabilities::{
+    HttpClientTrait, HttpError, HttpRequest, HttpResponse, RequestHead, RequestWithBody,
+};