WIP ddcommon-net crate + profiling updated

Author: morrisonlevi

Diff for: Cargo.lock

@@ -37,7 +37,7 @@ members = [
   "data-pipeline-ffi",
   "ddsketch",
   "tinybytes",
-  "dogstatsd-client",
+  "dogstatsd-client", "ddcommon-net",
 ]
 
 # https://doc.rust-lang.org/cargo/reference/resolver.html#feature-resolver-version-2

Diff for: Cargo.toml

@@ -0,0 +1,22 @@
+# Copyright 2024-Present Datadog, Inc. https://www.datadoghq.com/
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+name = "ddcommon-net"
+rust-version.workspace = true
+edition.workspace = true
+version.workspace = true
+license.workspace = true
+
+[dependencies]
+ddcommon = { path = "../ddcommon" }
+hex = { version = "0.4" }
+http = { version = "1" }
+hyper = { version = "1", default-features = false }
+hyper-util = { version = "0.1", default-features = false, features = ["tokio"] }
+hyperlocal = { version = "0.9" }
+serde = { version = "1.0", features = ["derive"] }
+thiserror = { version = "2" }
+tokio = { version = "1.41" }
+tokio-rustls = { version = "0.26" }
+tokio-util = { version = "0.7" }

Diff for: ddcommon-net/Cargo.toml

@@ -0,0 +1,135 @@
+// Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use ddcommon::entity_id;
+use http::request::Builder as HttpRequestBuilder;
+use http::{HeaderValue, Uri};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::borrow::Cow;
+use std::ops::Deref;
+
+// todo: why do we need to serialize and deserialize endpoints?
+#[derive(Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize)]
+pub struct Endpoint {
+    #[serde(serialize_with = "serialize_uri", deserialize_with = "deserialize_uri")]
+    pub url: Uri,
+    pub api_key: Option<Cow<'static, str>>,
+    pub timeout_ms: u64,
+    /// Sets X-Datadog-Test-Session-Token header on any request
+    pub test_token: Option<Cow<'static, str>>,
+}
+
+#[derive(serde::Deserialize, serde::Serialize)]
+struct SerializedUri<'a> {
+    scheme: Option<Cow<'a, str>>,
+    authority: Option<Cow<'a, str>>,
+    path_and_query: Option<Cow<'a, str>>,
+}
+
+fn serialize_uri<S>(uri: &Uri, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let parts = uri.clone().into_parts();
+    let uri = SerializedUri {
+        scheme: parts.scheme.as_ref().map(|s| Cow::Borrowed(s.as_str())),
+        authority: parts.authority.as_ref().map(|s| Cow::Borrowed(s.as_str())),
+        path_and_query: parts
+            .path_and_query
+            .as_ref()
+            .map(|s| Cow::Borrowed(s.as_str())),
+    };
+    uri.serialize(serializer)
+}
+
+fn deserialize_uri<'de, D>(deserializer: D) -> Result<Uri, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let uri = SerializedUri::deserialize(deserializer)?;
+    let mut builder = hyper::Uri::builder();
+    if let Some(v) = uri.authority {
+        builder = builder.authority(v.deref());
+    }
+    if let Some(v) = uri.scheme {
+        builder = builder.scheme(v.deref());
+    }
+    if let Some(v) = uri.path_and_query {
+        builder = builder.path_and_query(v.deref());
+    }
+
+    builder.build().map_err(serde::de::Error::custom)
+}
+
+impl Endpoint {
+    /// Default value for the timeout field in milliseconds.
+    pub const DEFAULT_TIMEOUT: u64 = 3_000;
+
+    /// Return a request builder with the following headers:
+    /// - User agent
+    /// - Api key
+    /// - Container Id/Entity Id
+    pub fn into_request_builder(
+        &self,
+        user_agent: &str,
+    ) -> Result<HttpRequestBuilder, http::Error> {
+        let mut builder = hyper::Request::builder()
+            .uri(self.url.clone())
+            .header(hyper::header::USER_AGENT, user_agent);
+
+        // Add the Api key header if available
+        if let Some(api_key) = &self.api_key {
+            builder = builder.header(header::DATADOG_API_KEY, HeaderValue::from_str(api_key)?);
+        }
+
+        // Add the test session token if available
+        if let Some(token) = &self.test_token {
+            builder = builder.header(
+                header::X_DATADOG_TEST_SESSION_TOKEN,
+                HeaderValue::from_str(token)?,
+            );
+        }
+
+        // Add the Container Id header if available
+        if let Some(container_id) = entity_id::get_container_id() {
+            builder = builder.header(header::DATADOG_CONTAINER_ID, container_id);
+        }
+
+        // Add the Entity Id header if available
+        if let Some(entity_id) = entity_id::get_entity_id() {
+            builder = builder.header(header::DATADOG_ENTITY_ID, entity_id);
+        }
+
+        // Add the External Env header if available
+        if let Some(external_env) = entity_id::get_external_env() {
+            builder = builder.header(header::DATADOG_EXTERNAL_ENV, external_env);
+        }
+
+        Ok(builder)
+    }
+}
+
+impl From<Uri> for Endpoint {
+    fn from(uri: Uri) -> Self {
+        Self {
+            url: uri,
+            api_key: None,
+            timeout_ms: 0,
+            test_token: None,
+        }
+    }
+}
+
+pub mod header {
+    #![allow(clippy::declare_interior_mutable_const)]
+    use hyper::{header::HeaderName, http::HeaderValue};
+    pub const DATADOG_CONTAINER_ID: HeaderName = HeaderName::from_static("datadog-container-id");
+    pub const DATADOG_ENTITY_ID: HeaderName = HeaderName::from_static("datadog-entity-id");
+    pub const DATADOG_EXTERNAL_ENV: HeaderName = HeaderName::from_static("datadog-external-env");
+    pub const DATADOG_TRACE_COUNT: HeaderName = HeaderName::from_static("x-datadog-trace-count");
+    pub const DATADOG_API_KEY: HeaderName = HeaderName::from_static("dd-api-key");
+    pub const APPLICATION_JSON: HeaderValue = HeaderValue::from_static("application/json");
+    pub const APPLICATION_MSGPACK: HeaderValue = HeaderValue::from_static("application/msgpack");
+    pub const X_DATADOG_TEST_SESSION_TOKEN: HeaderName =
+        HeaderName::from_static("x-datadog-test-session-token");
+}