refactor(trace-utils)!: change header name type to accept dynamic values

libdd-common/src/lib.rs

@@ -86,10 +86,6 @@ pub mod header {
     #![allow(clippy::declare_interior_mutable_const)]
     use hyper::{header::HeaderName, http::HeaderValue};
 
-    // These strings are defined separately to be used in context where &str are used to represent
-    // headers (e.g. SendData) while keeping a single source of truth.
-    pub const DATADOG_SEND_REAL_HTTP_STATUS_STR: &str = "datadog-send-real-http-status";
-    pub const DATADOG_TRACE_COUNT_STR: &str = "x-datadog-trace-count";
     pub const APPLICATION_MSGPACK_STR: &str = "application/msgpack";
     pub const APPLICATION_PROTOBUF_STR: &str = "application/x-protobuf";
 
@@ -101,7 +97,7 @@ pub mod header {
     /// If this is not set then the agent will always return a 200 regardless if the payload is
     /// dropped.
     pub const DATADOG_SEND_REAL_HTTP_STATUS: HeaderName =
-        HeaderName::from_static(DATADOG_SEND_REAL_HTTP_STATUS_STR);
+        HeaderName::from_static("datadog-send-real-http-status");
     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_STR);

libdd-data-pipeline/src/stats_exporter.rs

@@ -84,10 +84,10 @@ impl StatsExporter {
         }
         let body = rmp_serde::encode::to_vec_named(&payload)?;
 
-        let mut headers: HashMap<&'static str, String> = self.meta.borrow().into();
+        let mut headers: HashMap<http::HeaderName, String> = self.meta.borrow().into();
 
         headers.insert(
-            http::header::CONTENT_TYPE.as_str(),
+            http::header::CONTENT_TYPE,
             libdd_common::header::APPLICATION_MSGPACK_STR.to_string(),
         );
 

libdd-data-pipeline/src/trace_exporter/agent_response.rs

@@ -1,11 +1,13 @@
 // Copyright 2024-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
+use http::HeaderName;
 use std::sync::Arc;
 
 use arc_swap::ArcSwap;
 
-pub const DATADOG_RATES_PAYLOAD_VERSION_HEADER: &str = "datadog-rates-payload-version";
+pub const DATADOG_RATES_PAYLOAD_VERSION: HeaderName =
+    HeaderName::from_static("datadog-rates-payload-version");
 
 /// `AgentResponse` structure holds agent response information upon successful request.
 #[derive(Debug, PartialEq)]

libdd-data-pipeline/src/trace_exporter/mod.rs

@@ -1,4 +1,4 @@
 // Copyright 2024-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 pub mod agent_response;
 pub mod builder;
@@ -19,7 +19,7 @@
 use crate::stats_exporter::StatsExporter;
 use crate::telemetry::{SendPayloadTelemetry, TelemetryClient};
 use crate::trace_exporter::agent_response::{
-    AgentResponsePayloadVersion, DATADOG_RATES_PAYLOAD_VERSION_HEADER,
+    AgentResponsePayloadVersion, DATADOG_RATES_PAYLOAD_VERSION,
 };
 use crate::trace_exporter::error::{InternalErrorKind, RequestError, TraceExporterError};
 use crate::{
@@ -148,8 +148,8 @@
     }
 }
 
-impl<'a> From<&'a TracerMetadata> for HashMap<&'static str, String> {
-    fn from(tags: &'a TracerMetadata) -> HashMap<&'static str, String> {
+impl<'a> From<&'a TracerMetadata> for HashMap<http::HeaderName, String> {
+    fn from(tags: &'a TracerMetadata) -> HashMap<http::HeaderName, String> {
         TracerHeaderTags::from(tags).into()
     }
 }
@@ -563,7 +563,7 @@
         &self,
         endpoint: &Endpoint,
         mp_payload: Vec<u8>,
-        headers: HashMap<&'static str, String>,
+        headers: HashMap<http::HeaderName, String>,
         chunks: usize,
         chunks_dropped_p0: usize,
     ) -> Result<AgentResponse, TraceExporterError> {
@@ -738,7 +738,7 @@
         match (
             status.is_success(),
             self.agent_payload_response_version.as_ref(),
-            response.headers().get(DATADOG_RATES_PAYLOAD_VERSION_HEADER),
+            response.headers().get(DATADOG_RATES_PAYLOAD_VERSION),
         ) {
             (false, _, _) => {
                 // If the status is not success, the rates are considered unchanged
@@ -909,7 +909,7 @@
     }
 
     #[test]
     fn test_from_tracer_tags_to_hashmap() {
         let tracer_tags = TracerMetadata {
             tracer_version: "v0.1".to_string(),
             language: "rust".to_string(),
@@ -920,7 +920,7 @@
             ..Default::default()
         };
 
-        let hashmap: HashMap<&'static str, String> = (&tracer_tags).into();
+        let hashmap: HashMap<http::HeaderName, String> = (&tracer_tags).into();
 
         assert_eq!(hashmap.get("datadog-meta-tracer-version").unwrap(), "v0.1");
         assert_eq!(hashmap.get("datadog-meta-lang").unwrap(), "rust");

libdd-data-pipeline/src/trace_exporter/trace_serializer.rs

@@ -1,14 +1,14 @@
 // Copyright 2024-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::trace_exporter::agent_response::{
-    AgentResponsePayloadVersion, DATADOG_RATES_PAYLOAD_VERSION_HEADER,
+    AgentResponsePayloadVersion, DATADOG_RATES_PAYLOAD_VERSION,
 };
 use crate::trace_exporter::error::TraceExporterError;
 use crate::trace_exporter::TraceExporterOutputFormat;
-use http::header::CONTENT_TYPE;
+use http::{header::CONTENT_TYPE, HeaderName};
 use libdd_common::header::{
-    APPLICATION_MSGPACK_STR, DATADOG_SEND_REAL_HTTP_STATUS_STR, DATADOG_TRACE_COUNT_STR,
+    APPLICATION_MSGPACK_STR, DATADOG_SEND_REAL_HTTP_STATUS, DATADOG_TRACE_COUNT,
 };
 use libdd_trace_utils::msgpack_decoder::decode::error::DecodeError;
 use libdd_trace_utils::msgpack_encoder;
@@ -22,7 +22,7 @@
     /// Serialized msgpack payload
     pub data: Vec<u8>,
     /// HTTP headers for the request
-    pub headers: HashMap<&'static str, String>,
+    pub headers: HashMap<HeaderName, String>,
     /// Number of trace chunks
     pub chunk_count: usize,
 }
@@ -82,14 +82,14 @@
         &self,
         header_tags: TracerHeaderTags,
         chunk_count: usize,
-    ) -> HashMap<&'static str, String> {
-        let mut headers: HashMap<&'static str, String> = header_tags.into();
-        headers.insert(DATADOG_SEND_REAL_HTTP_STATUS_STR, "1".to_string());
-        headers.insert(DATADOG_TRACE_COUNT_STR, chunk_count.to_string());
-        headers.insert(CONTENT_TYPE.as_str(), APPLICATION_MSGPACK_STR.to_string());
+    ) -> HashMap<HeaderName, String> {
+        let mut headers: HashMap<HeaderName, String> = header_tags.into();
+        headers.insert(DATADOG_SEND_REAL_HTTP_STATUS, "1".to_string());
+        headers.insert(DATADOG_TRACE_COUNT, chunk_count.to_string());
+        headers.insert(CONTENT_TYPE, APPLICATION_MSGPACK_STR.to_string());
         if let Some(agent_payload_response_version) = &self.agent_payload_response_version {
             headers.insert(
-                DATADOG_RATES_PAYLOAD_VERSION_HEADER,
+                DATADOG_RATES_PAYLOAD_VERSION,
                 agent_payload_response_version.header_value(),
             );
         }
@@ -115,9 +115,7 @@
     use super::*;
     use crate::trace_exporter::agent_response::AgentResponsePayloadVersion;
     use http::header::CONTENT_TYPE;
-    use libdd_common::header::{
-        APPLICATION_MSGPACK_STR, DATADOG_SEND_REAL_HTTP_STATUS_STR, DATADOG_TRACE_COUNT_STR,
-    };
+    use libdd_common::header::APPLICATION_MSGPACK_STR;
     use libdd_tinybytes::BytesString;
     use libdd_trace_utils::span::v04::SpanBytes;
     use libdd_trace_utils::trace_utils::TracerHeaderTags;
@@ -173,14 +171,17 @@
     }
 
     #[test]
     fn test_build_traces_headers() {
         let serializer = TraceSerializer::new(TraceExporterOutputFormat::V04, None);
         let header_tags = create_test_header_tags();
         let headers = serializer.build_traces_headers(header_tags, 3);
 
         // Check basic headers are present
-        assert_eq!(headers.get(DATADOG_SEND_REAL_HTTP_STATUS_STR).unwrap(), "1");
-        assert_eq!(headers.get(DATADOG_TRACE_COUNT_STR).unwrap(), "3");
+        assert_eq!(
+            headers.get(DATADOG_SEND_REAL_HTTP_STATUS.as_str()).unwrap(),
+            "1"
+        );
+        assert_eq!(headers.get(DATADOG_TRACE_COUNT.as_str()).unwrap(), "3");
         assert_eq!(
             headers.get(CONTENT_TYPE.as_str()).unwrap(),
             APPLICATION_MSGPACK_STR
@@ -205,15 +206,15 @@
     }
 
     #[test]
     fn test_build_traces_headers_with_agent_version() {
         let agent_version = AgentResponsePayloadVersion::new();
         let serializer = TraceSerializer::new(TraceExporterOutputFormat::V04, Some(&agent_version));
         let header_tags = create_test_header_tags();
         let headers = serializer.build_traces_headers(header_tags, 2);
 
         // Check that agent payload version header is included
-        assert!(headers.contains_key(DATADOG_RATES_PAYLOAD_VERSION_HEADER));
-        assert_eq!(headers.get(DATADOG_TRACE_COUNT_STR).unwrap(), "2");
+        assert!(headers.contains_key(DATADOG_RATES_PAYLOAD_VERSION.as_str()));
+        assert_eq!(headers.get(DATADOG_TRACE_COUNT.as_str()).unwrap(), "2");
     }
 
     #[test]
@@ -329,7 +330,7 @@
     }
 
     #[test]
     fn test_prepare_traces_payload_v04() {
         let serializer = TraceSerializer::new(TraceExporterOutputFormat::V04, None);
         let traces = vec![
             vec![create_test_span()],
@@ -346,7 +347,10 @@
         assert!(!prepared.headers.is_empty());
 
         // Check headers
-        assert_eq!(prepared.headers.get(DATADOG_TRACE_COUNT_STR).unwrap(), "2");
+        assert_eq!(
+            prepared.headers.get(DATADOG_TRACE_COUNT.as_str()).unwrap(),
+            "2"
+        );
         assert_eq!(prepared.headers.get("datadog-meta-lang").unwrap(), "rust");
     }
 
@@ -366,7 +370,7 @@
     }
 
     #[test]
     fn test_prepare_traces_payload_with_agent_version() {
         let agent_version = AgentResponsePayloadVersion::new();
         let serializer = TraceSerializer::new(TraceExporterOutputFormat::V04, Some(&agent_version));
         let traces = vec![vec![create_test_span()]];
@@ -379,11 +383,11 @@
         assert_eq!(prepared.chunk_count, 1);
         assert!(prepared
             .headers
-            .contains_key(DATADOG_RATES_PAYLOAD_VERSION_HEADER));
+            .contains_key(DATADOG_RATES_PAYLOAD_VERSION.as_str()));
     }
 
     #[test]
     fn test_prepare_traces_payload_empty_traces() {
         let serializer = TraceSerializer::new(TraceExporterOutputFormat::V04, None);
         let traces: Vec<Vec<SpanBytes>> = vec![];
         let header_tags = create_test_header_tags();
@@ -394,11 +398,14 @@
         let prepared = result.unwrap();
         assert_eq!(prepared.chunk_count, 0);
         assert!(!prepared.data.is_empty()); // Even empty traces result in some serialized data
-        assert_eq!(prepared.headers.get(DATADOG_TRACE_COUNT_STR).unwrap(), "0");
+        assert_eq!(
+            prepared.headers.get(DATADOG_TRACE_COUNT.as_str()).unwrap(),
+            "0"
+        );
     }
 
     #[test]
     fn test_header_tags_conversion() {
         let header_tags = TracerHeaderTags {
             lang: "python",
             lang_version: "3.9.0",

libdd-trace-utils/src/send_data/mod.rs

@@ -10,11 +10,11 @@ use crate::tracer_payload::TracerPayloadCollection;
 use anyhow::{anyhow, Context};
 use futures::stream::FuturesUnordered;
 use futures::StreamExt;
-use http::header::CONTENT_TYPE;
+use http::{header::CONTENT_TYPE, HeaderName};
 use libdd_common::{
     header::{
-        APPLICATION_MSGPACK_STR, APPLICATION_PROTOBUF_STR, DATADOG_SEND_REAL_HTTP_STATUS_STR,
-        DATADOG_TRACE_COUNT_STR,
+        APPLICATION_MSGPACK_STR, APPLICATION_PROTOBUF_STR, DATADOG_SEND_REAL_HTTP_STATUS,
+        DATADOG_TRACE_COUNT,
     },
     Connect, Endpoint, GenericHttpClient,
 };
@@ -68,7 +68,7 @@ pub struct SendData {
     pub(crate) tracer_payloads: TracerPayloadCollection,
     pub(crate) size: usize, // have a rough size estimate to force flushing if it's large
     target: Endpoint,
-    headers: HashMap<&'static str, String>,
+    headers: HashMap<HeaderName, String>,
     retry_strategy: RetryStrategy,
     #[cfg(feature = "compression")]
     compression: Compression,
@@ -85,7 +85,7 @@ pub struct SendDataBuilder {
     pub(crate) tracer_payloads: TracerPayloadCollection,
     pub(crate) size: usize,
     target: Endpoint,
-    headers: HashMap<&'static str, String>,
+    headers: HashMap<HeaderName, String>,
     retry_strategy: RetryStrategy,
     #[cfg(feature = "compression")]
     compression: Compression,
@@ -98,8 +98,8 @@ impl SendDataBuilder {
         tracer_header_tags: TracerHeaderTags,
         target: &Endpoint,
     ) -> SendDataBuilder {
-        let mut headers: HashMap<&'static str, String> = tracer_header_tags.into();
-        headers.insert(DATADOG_SEND_REAL_HTTP_STATUS_STR, "1".to_string());
+        let mut headers: HashMap<HeaderName, String> = tracer_header_tags.into();
+        headers.insert(DATADOG_SEND_REAL_HTTP_STATUS, "1".to_string());
         SendDataBuilder {
             tracer_payloads: tracer_payload,
             size,
@@ -160,8 +160,8 @@ impl SendData {
         tracer_header_tags: TracerHeaderTags,
         target: &Endpoint,
     ) -> SendData {
-        let mut headers: HashMap<&'static str, String> = tracer_header_tags.into();
-        headers.insert(DATADOG_SEND_REAL_HTTP_STATUS_STR, "1".to_string());
+        let mut headers: HashMap<HeaderName, String> = tracer_header_tags.into();
+        headers.insert(DATADOG_SEND_REAL_HTTP_STATUS, "1".to_string());
         SendData {
             tracer_payloads: tracer_payload,
             size,
@@ -243,7 +243,7 @@ impl SendData {
         &self,
         chunks: u64,
         payload: Vec<u8>,
-        headers: HashMap<&'static str, String>,
+        headers: HashMap<HeaderName, String>,
         http_client: &GenericHttpClient<C>,
         endpoint: Option<&Endpoint>,
     ) -> (SendWithRetryResult, u64, u64) {
@@ -268,7 +268,11 @@ impl SendData {
     }
 
     #[cfg(feature = "compression")]
-    fn compress_payload(&self, payload: Vec<u8>, headers: &mut HashMap<&str, String>) -> Vec<u8> {
+    fn compress_payload(
+        &self,
+        payload: Vec<u8>,
+        headers: &mut HashMap<HeaderName, String>,
+    ) -> Vec<u8> {
         match self.compression {
             Compression::Zstd(level) => {
                 let result = (|| -> std::io::Result<Vec<u8>> {
@@ -279,7 +283,7 @@ impl SendData {
 
                 match result {
                     Ok(compressed_payload) => {
-                        headers.insert("Content-Encoding", "zstd".to_string());
+                        headers.insert(http::header::CONTENT_ENCODING, "zstd".to_string());
                         compressed_payload
                     }
                     Err(_) => payload,
@@ -317,7 +321,7 @@ impl SendData {
                 #[cfg(not(feature = "compression"))]
                 let final_payload = serialized_trace_payload;
 
-                request_headers.insert(CONTENT_TYPE.as_str(), APPLICATION_PROTOBUF_STR.to_string());
+                request_headers.insert(CONTENT_TYPE, APPLICATION_PROTOBUF_STR.to_string());
 
                 let (response, bytes_sent, chunks) = self
                     .send_payload(
@@ -351,8 +355,8 @@ impl SendData {
                     #[allow(clippy::unwrap_used)]
                     let chunks = u64::try_from(tracer_payload.chunks.len()).unwrap();
                     let mut headers = self.headers.clone();
-                    headers.insert(DATADOG_TRACE_COUNT_STR, chunks.to_string());
-                    headers.insert(CONTENT_TYPE.as_str(), APPLICATION_MSGPACK_STR.to_string());
+                    headers.insert(DATADOG_TRACE_COUNT, chunks.to_string());
+                    headers.insert(CONTENT_TYPE, APPLICATION_MSGPACK_STR.to_string());
 
                     let payload = match rmp_serde::to_vec_named(tracer_payload) {
                         Ok(p) => p,
@@ -372,8 +376,8 @@ impl SendData {
                 #[allow(clippy::unwrap_used)]
                 let chunks = u64::try_from(self.tracer_payloads.size()).unwrap();
                 let mut headers = self.headers.clone();
-                headers.insert(DATADOG_TRACE_COUNT_STR, chunks.to_string());
-                headers.insert(CONTENT_TYPE.as_str(), APPLICATION_MSGPACK_STR.to_string());
+                headers.insert(DATADOG_TRACE_COUNT, chunks.to_string());
+                headers.insert(CONTENT_TYPE, APPLICATION_MSGPACK_STR.to_string());
 
                 let payload = msgpack_encoder::v04::to_vec(payload);
 
@@ -389,8 +393,8 @@ impl SendData {
                 #[allow(clippy::unwrap_used)]
                 let chunks = u64::try_from(self.tracer_payloads.size()).unwrap();
                 let mut headers = self.headers.clone();
-                headers.insert(DATADOG_TRACE_COUNT_STR, chunks.to_string());
-                headers.insert(CONTENT_TYPE.as_str(), APPLICATION_MSGPACK_STR.to_string());
+                headers.insert(DATADOG_TRACE_COUNT, chunks.to_string());
+                headers.insert(CONTENT_TYPE, APPLICATION_MSGPACK_STR.to_string());
 
                 let payload = match rmp_serde::to_vec(payload) {
                     Ok(p) => p,
@@ -574,7 +578,7 @@ mod tests {
         assert_eq!(data.target.url.path(), "/foo/bar");
 
         for (key, value) in HashMap::from(header_tags) {
-            assert_eq!(data.headers.get(key).unwrap(), &value);
+            assert_eq!(data.headers.get(&key).unwrap(), &value);
         }
     }
 
@@ -679,7 +683,7 @@ mod tests {
         let mock = server
             .mock_async(|when, then| {
                 when.method(POST)
-                    .header(DATADOG_TRACE_COUNT_STR, "1")
+                    .header(DATADOG_TRACE_COUNT.as_str(), "1")
                     .header("Content-type", "application/msgpack")
                     .header("datadog-meta-lang", header_tags.lang)
                     .header(
@@ -739,7 +743,7 @@ mod tests {
         let mock = server
             .mock_async(|when, then| {
                 when.method(POST)
-                    .header(DATADOG_TRACE_COUNT_STR, "1")
+                    .header(DATADOG_TRACE_COUNT.as_str(), "1")
                     .header("Content-type", "application/msgpack")
                     .header("datadog-meta-lang", header_tags.lang)
                     .header(
@@ -928,7 +932,7 @@ mod tests {
         let mock = server
             .mock_async(|when, then| {
                 when.method(POST)
-                    .header(DATADOG_TRACE_COUNT_STR, "2")
+                    .header(DATADOG_TRACE_COUNT.as_str(), "2")
                     .header("Content-type", "application/msgpack")
                     .header("datadog-meta-lang", header_tags.lang)
                     .header(