address semvar issues

Author: mabdinur

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

@@ -10,7 +10,8 @@ use libdd_common_ffi::{
 };
 
 use libdd_data_pipeline::trace_exporter::{
-    TelemetryConfig, TraceExporter, TraceExporterInputFormat, TraceExporterOutputFormat,
+    TelemetryConfig, TelemetryInstrumentationSessions, TraceExporter, TraceExporterInputFormat,
+    TraceExporterOutputFormat,
 };
 use std::{ptr::NonNull, time::Duration};
 use tracing::{debug, error};
@@ -71,6 +72,7 @@ pub struct TraceExporterConfig {
     compute_stats: bool,
     client_computed_stats: bool,
     telemetry_cfg: Option<TelemetryConfig>,
+    telemetry_instrumentation_sessions: TelemetryInstrumentationSessions,
     health_metrics_enabled: bool,
     process_tags: Option<String>,
     test_session_token: Option<String>,
@@ -308,6 +310,8 @@ pub unsafe extern "C" fn ddog_trace_exporter_config_enable_telemetry(
                         Err(e) => return Some(e),
                     },
                     debug_enabled: telemetry_cfg.debug_enabled,
+                };
+                let sessions = TelemetryInstrumentationSessions {
                     session_id: match sanitize_string(telemetry_cfg.session_id) {
                         Ok(s) => Some(s),
                         Err(e) => return Some(e),
@@ -321,8 +325,9 @@ pub unsafe extern "C" fn ddog_trace_exporter_config_enable_telemetry(
                         Err(e) => return Some(e),
                     },
                 };
-                debug!(telemetry_cfg = ?cfg, "Configuring telemetry");
+                debug!(telemetry_cfg = ?cfg, telemetry_sessions = ?sessions, "Configuring telemetry");
                 config.telemetry_cfg = Some(cfg);
+                config.telemetry_instrumentation_sessions = sessions;
             }
             None
         } else {
@@ -507,6 +512,9 @@ pub unsafe extern "C" fn ddog_trace_exporter_new(
             if let Some(cfg) = &config.telemetry_cfg {
                 builder.enable_telemetry(cfg.clone());
             }
+            builder.set_telemetry_instrumentation_sessions(
+                config.telemetry_instrumentation_sessions.clone(),
+            );
 
             if let Some(token) = &config.test_session_token {
                 builder.set_test_session_token(token);
@@ -889,21 +897,17 @@ mod tests {
             );
             assert!(cfg.telemetry_cfg.as_ref().unwrap().debug_enabled);
             assert_eq!(
-                cfg.telemetry_cfg.as_ref().unwrap().session_id.as_deref(),
+                cfg.telemetry_instrumentation_sessions.session_id.as_deref(),
                 Some("")
             );
             assert_eq!(
-                cfg.telemetry_cfg
-                    .as_ref()
-                    .unwrap()
+                cfg.telemetry_instrumentation_sessions
                     .root_session_id
                     .as_deref(),
                 Some("")
             );
             assert_eq!(
-                cfg.telemetry_cfg
-                    .as_ref()
-                    .unwrap()
+                cfg.telemetry_instrumentation_sessions
                     .parent_session_id
                     .as_deref(),
                 Some("")
@@ -922,10 +926,10 @@ mod tests {
                 }),
             );
             assert!(error.is_none());
-            let t = cfg.telemetry_cfg.as_ref().unwrap();
-            assert_eq!(t.session_id.as_deref(), Some("sess-z"));
-            assert_eq!(t.root_session_id.as_deref(), Some("root-z"));
-            assert_eq!(t.parent_session_id.as_deref(), Some("par-z"));
+            let s = &cfg.telemetry_instrumentation_sessions;
+            assert_eq!(s.session_id.as_deref(), Some("sess-z"));
+            assert_eq!(s.root_session_id.as_deref(), Some("root-z"));
+            assert_eq!(s.parent_session_id.as_deref(), Some("par-z"));
         }
     }
 
@@ -1206,9 +1210,6 @@ mod tests {
                     heartbeat: 10000,
                     runtime_id: Some("foo".to_string()),
                     debug_enabled: true,
-                    session_id: None,
-                    root_session_id: None,
-                    parent_session_id: None,
                 }),
                 ..Default::default()
             };

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

@@ -32,9 +32,6 @@ pub struct TelemetryClientBuilder {
     tracer_version: Option<String>,
     config: libdd_telemetry::config::Config,
     runtime_id: Option<String>,
-    session_id: Option<String>,
-    root_session_id: Option<String>,
-    parent_session_id: Option<String>,
 }
 
 impl TelemetryClientBuilder {
@@ -99,21 +96,21 @@ impl TelemetryClientBuilder {
     /// Sets the instrumentation session id sent as the `dd-session-id` header on telemetry
     /// requests.
     pub fn set_session_id(mut self, id: &str) -> Self {
-        self.session_id = Some(id.to_string());
+        self.config.session_id = Some(id.to_string());
         self
     }
 
     /// Sets the root session id sent as the `dd-root-session-id` header (only with a valid session
     /// id).
     pub fn set_root_session_id(mut self, id: &str) -> Self {
-        self.root_session_id = Some(id.to_string());
+        self.config.root_session_id = Some(id.to_string());
         self
     }
 
     /// Sets the parent session id sent as the `dd-parent-session-id` header (only with a valid
     /// session id).
     pub fn set_parent_session_id(mut self, id: &str) -> Self {
-        self.parent_session_id = Some(id.to_string());
+        self.config.parent_session_id = Some(id.to_string());
         self
     }
 
@@ -141,9 +138,6 @@ impl TelemetryClientBuilder {
         if let Some(id) = self.runtime_id {
             builder.runtime_id = Some(id);
         }
-        builder.session_id = self.session_id;
-        builder.root_session_id = self.root_session_id;
-        builder.parent_session_id = self.parent_session_id;
 
         let (worker_handle, worker) = builder.build_worker(runtime);
 

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

@@ -9,9 +9,9 @@ use crate::telemetry::TelemetryClientBuilder;
 use crate::trace_exporter::agent_response::AgentResponsePayloadVersion;
 use crate::trace_exporter::error::BuilderErrorKind;
 use crate::trace_exporter::{
-    add_path, StatsComputationStatus, TelemetryConfig, TraceExporter, TraceExporterError,
-    TraceExporterInputFormat, TraceExporterOutputFormat, TraceExporterWorkers, TracerMetadata,
-    INFO_ENDPOINT,
+    add_path, StatsComputationStatus, TelemetryConfig, TelemetryInstrumentationSessions,
+    TraceExporter, TraceExporterError, TraceExporterInputFormat, TraceExporterOutputFormat,
+    TraceExporterWorkers, TracerMetadata, INFO_ENDPOINT,
 };
 use arc_swap::ArcSwap;
 use libdd_common::http_common::new_default_client;
@@ -49,6 +49,7 @@ pub struct TraceExporterBuilder {
     compute_stats_by_span_kind: bool,
     peer_tags: Vec<String>,
     telemetry: Option<TelemetryConfig>,
+    telemetry_instrumentation_sessions: TelemetryInstrumentationSessions,
     health_metrics_enabled: bool,
     test_session_token: Option<String>,
     agent_rates_payload_version_enabled: bool,
@@ -209,6 +210,15 @@ impl TraceExporterBuilder {
         self
     }
 
+    /// Sets optional `dd-session-id` / root / parent session headers on telemetry requests.
+    pub fn set_telemetry_instrumentation_sessions(
+        &mut self,
+        sessions: TelemetryInstrumentationSessions,
+    ) -> &mut Self {
+        self.telemetry_instrumentation_sessions = sessions;
+        self
+    }
+
     /// Enables health metrics emission.
     pub fn enable_health_metrics(&mut self) -> &mut Self {
         self.health_metrics_enabled = true;
@@ -294,6 +304,7 @@ impl TraceExporterBuilder {
             stats = StatsComputationStatus::DisabledByAgent { bucket_size };
         }
 
+        let sessions = self.telemetry_instrumentation_sessions.clone();
         let telemetry = self.telemetry.map(|telemetry_config| {
             let mut builder = TelemetryClientBuilder::default()
                 .set_language(&self.language)
@@ -308,13 +319,13 @@ impl TraceExporterBuilder {
             if let Some(id) = telemetry_config.runtime_id {
                 builder = builder.set_runtime_id(&id);
             }
-            if let Some(ref id) = telemetry_config.session_id {
+            if let Some(ref id) = sessions.session_id {
                 builder = builder.set_session_id(id);
             }
-            if let Some(ref id) = telemetry_config.root_session_id {
+            if let Some(ref id) = sessions.root_session_id {
                 builder = builder.set_root_session_id(id);
             }
-            if let Some(ref id) = telemetry_config.parent_session_id {
+            if let Some(ref id) = sessions.parent_session_id {
                 builder = builder.set_parent_session_id(id);
             }
             builder.build(runtime.handle().clone())
@@ -446,7 +457,6 @@ mod tests {
                 heartbeat: 1000,
                 runtime_id: None,
                 debug_enabled: false,
-                ..Default::default()
             });
         let exporter = builder.build().unwrap();
 

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

@@ -10,6 +10,14 @@ mod trace_serializer;
 // Re-export the builder
 pub use builder::TraceExporterBuilder;
 
+/// Optional instrumentation session headers for telemetry (`dd-session-id`, etc.).
+#[derive(Debug, Default, Clone)]
+pub struct TelemetryInstrumentationSessions {
+    pub session_id: Option<String>,
+    pub root_session_id: Option<String>,
+    pub parent_session_id: Option<String>,
+}
+
 use self::agent_response::AgentResponse;
 use self::metrics::MetricsEmitter;
 use self::stats::StatsComputationStatus;
@@ -904,12 +912,6 @@ pub struct TelemetryConfig {
     pub heartbeat: u64,
     pub runtime_id: Option<String>,
     pub debug_enabled: bool,
-    /// Sent as the `dd-session-id` telemetry header when set.
-    pub session_id: Option<String>,
-    /// Sent as `dd-root-session-id` when set (only with a valid session id).
-    pub root_session_id: Option<String>,
-    /// Sent as `dd-parent-session-id` when set (only with a valid session id).
-    pub parent_session_id: Option<String>,
 }
 
 #[allow(missing_docs)]