revert(traces): revert Datadog-Client-Computed-Stats header support (#1176)

duncanista · web-flow · commit 56d4b5b0f736 · 2026-04-08T21:39:24.000-04:00
## Summary - Reverts #1118 (`feat(traces): [SVLS-8734] respect Datadog-Client-Computed-Stats header`) which introduced logic to skip backend stats when the tracer claims client-computed-stats, causing stats to vanish entirely in some scenarios. - Reverts #1136 (`fix(tests): remove stale _dd.compute_stats:1 assertion from logs integration test`) which was a follow-up test adjustment for #1118. Restores the pre-v95 behavior where `_dd.compute_stats` is set solely by `DD_COMPUTE_TRACE_STATS_ON_EXTENSION`, keeping the backend as a safety net. ## Test plan - [x] `cargo fmt --check` passes - [x] `cargo clippy --all-targets -- -D warnings` passes - [x] `cargo test` — all 513 tests pass [SVLS-8734]: https://datadoghq.atlassian.net/browse/SVLS-8734?atlOrigin=eyJpIjoiNWRkNTljNzYxNjVmNDY3MDlhMDU5Y2ZhYzA5YTRkZjUiLCJwIjoiZ2l0aHViLWNvbS1KU1cifQ
diff --git a/bottlecap/src/lifecycle/invocation/context.rs b/bottlecap/src/lifecycle/invocation/context.rs
@@ -43,16 +43,6 @@ pub struct Context {
     /// tracing.
     ///
     pub extracted_span_context: Option<SpanContext>,
-    /// Whether the tracer has already generated stats for the dummy `aws.lambda` span
-    /// for this invocation (which only exists for universal instrumentation
-    /// languages).
-    ///
-    /// Set from the `Datadog-Client-Computed-Stats` header when the tracer's
-    /// dummy `aws.lambda` span (with `resource_name="dd-tracer-serverless-span"`) is received.
-    /// The value will be propagated to the same field of the real `aws.lambda` span generated by
-    /// the extension, which will be used to decide whether stats should be generated on extension
-    /// or backend.
-    pub client_computed_stats: bool,
 }
 
 /// Struct containing the information needed to reparent a span.
@@ -104,7 +94,6 @@ impl Default for Context {
             snapstart_restore_span: None,
             tracer_span: None,
             extracted_span_context: None,
-            client_computed_stats: false,
         }
     }
 }
@@ -519,12 +508,7 @@ impl ContextBuffer {
 
     /// Adds the tracer span to a `Context` in the buffer.
     ///
-    pub fn add_tracer_span(
-        &mut self,
-        request_id: &String,
-        tracer_span: &Span,
-        client_computed_stats: bool,
-    ) {
+    pub fn add_tracer_span(&mut self, request_id: &String, tracer_span: &Span) {
         if let Some(context) = self
             .buffer
             .iter_mut()
@@ -544,7 +528,6 @@ impl ContextBuffer {
                 .extend(tracer_span.metrics.clone());
 
             context.tracer_span = Some(tracer_span.clone());
-            context.client_computed_stats = client_computed_stats;
         } else {
             debug!("Could not add tracer span - context not found");
         }
diff --git a/bottlecap/src/lifecycle/invocation/processor.rs b/bottlecap/src/lifecycle/invocation/processor.rs
@@ -653,16 +653,9 @@ impl Processor {
         trace_sender: &Arc<SendingTraceProcessor>,
         context: Context,
     ) {
-        let client_computed_stats = context.client_computed_stats;
         let (traces, body_size) = self.get_ctx_spans(context);
-        self.send_spans(
-            traces,
-            body_size,
-            client_computed_stats,
-            tags_provider,
-            trace_sender,
-        )
-        .await;
+        self.send_spans(traces, body_size, tags_provider, trace_sender)
+            .await;
     }
 
     fn get_ctx_spans(&mut self, context: Context) -> (Vec<Span>, usize) {
@@ -727,7 +720,7 @@ impl Processor {
             let traces = vec![cold_start_span.clone()];
             let body_size = size_of_val(cold_start_span);
 
-            self.send_spans(traces, body_size, false, tags_provider, trace_sender)
+            self.send_spans(traces, body_size, tags_provider, trace_sender)
                 .await;
         }
     }
@@ -739,7 +732,6 @@ impl Processor {
         &mut self,
         traces: Vec<Span>,
         body_size: usize,
-        client_computed_stats: bool,
         tags_provider: &Arc<provider::Provider>,
         trace_sender: &Arc<SendingTraceProcessor>,
     ) {
@@ -752,7 +744,7 @@ impl Processor {
             tracer_version: "",
             container_id: "",
             client_computed_top_level: false,
-            client_computed_stats,
+            client_computed_stats: false,
             dropped_p0_traces: 0,
             dropped_p0_spans: 0,
         };
@@ -1399,10 +1391,9 @@ impl Processor {
     ///
     /// This is used to enrich the invocation span with additional metadata from the tracers
     /// top level span, since we discard the tracer span when we create the invocation span.
-    pub fn add_tracer_span(&mut self, span: &Span, client_computed_stats: bool) {
+    pub fn add_tracer_span(&mut self, span: &Span) {
         if let Some(request_id) = span.meta.get("request_id") {
-            self.context_buffer
-                .add_tracer_span(request_id, span, client_computed_stats);
+            self.context_buffer.add_tracer_span(request_id, span);
         }
     }
 
@@ -2213,98 +2204,6 @@ mod tests {
         );
     }
 
-    /// Verifies that `client_computed_stats` set on a context via `add_tracer_span` is
-    /// propagated all the way through `send_ctx_spans` to the `aws.lambda` payload sent
-    /// to the backend, so the extension does not generate duplicate stats.
-    #[tokio::test]
-    #[allow(clippy::unwrap_used)]
-    async fn test_client_computed_stats_propagated_to_aws_lambda_span() {
-        use crate::traces::stats_concentrator_service::StatsConcentratorService;
-        use crate::traces::stats_generator::StatsGenerator;
-        use libdd_trace_obfuscation::obfuscation_config::ObfuscationConfig;
-        use tokio::sync::mpsc;
-
-        let config = Arc::new(config::Config {
-            apm_dd_url: "https://trace.agent.datadoghq.com".to_string(),
-            ..config::Config::default()
-        });
-        let tags_provider = Arc::new(provider::Provider::new(
-            Arc::clone(&config),
-            LAMBDA_RUNTIME_SLUG.to_string(),
-            &HashMap::from([("function_arn".to_string(), "test-arn".to_string())]),
-        ));
-        let aws_config = Arc::new(AwsConfig {
-            region: "us-east-1".into(),
-            aws_lwa_proxy_lambda_runtime_api: None,
-            function_name: "test-function".into(),
-            sandbox_init_time: Instant::now(),
-            runtime_api: "***".into(),
-            exec_wrapper: None,
-            initialization_type: "on-demand".into(),
-        });
-        let (aggregator_service, aggregator_handle) =
-            AggregatorService::new(EMPTY_TAGS, 1024).expect("failed to create aggregator service");
-        tokio::spawn(aggregator_service.run());
-        let propagator = Arc::new(DatadogCompositePropagator::new(Arc::clone(&config)));
-        let (durable_context_tx, _) = tokio::sync::mpsc::channel(1);
-        let mut p = Processor::new(
-            Arc::clone(&tags_provider),
-            Arc::clone(&config),
-            aws_config,
-            aggregator_handle,
-            propagator,
-            durable_context_tx,
-        );
-
-        let (trace_tx, mut trace_rx) = mpsc::channel(10);
-        let (stats_concentrator_service, stats_concentrator_handle) =
-            StatsConcentratorService::new(Arc::clone(&config));
-        tokio::spawn(stats_concentrator_service.run());
-        let trace_sender = Arc::new(SendingTraceProcessor {
-            appsec: None,
-            processor: Arc::new(trace_processor::ServerlessTraceProcessor {
-                obfuscation_config: Arc::new(
-                    ObfuscationConfig::new().expect("Failed to create ObfuscationConfig"),
-                ),
-            }),
-            trace_tx,
-            stats_generator: Arc::new(StatsGenerator::new(stats_concentrator_handle)),
-        });
-
-        let mut context = Context::from_request_id("req-1");
-        context.invocation_span.trace_id = 1;
-        context.invocation_span.span_id = 2;
-        context.client_computed_stats = true;
-
-        p.send_ctx_spans(&tags_provider, &trace_sender, context)
-            .await;
-
-        let payload = trace_rx
-            .recv()
-            .await
-            .expect("expected payload from trace_tx");
-        assert!(
-            payload.header_tags.client_computed_stats,
-            "client_computed_stats must be propagated to the aws.lambda span payload"
-        );
-
-        // Verify _dd.compute_stats is "0" in the built payload tags: client_computed_stats=true
-        // means the tracer has already computed stats, so neither extension nor backend should.
-        let send_data = payload.builder.build();
-        let libdd_trace_utils::tracer_payload::TracerPayloadCollection::V07(payloads) =
-            send_data.get_payloads()
-        else {
-            panic!("expected V07 payload");
-        };
-        for p in payloads {
-            assert_eq!(
-                p.tags.get(crate::tags::lambda::tags::COMPUTE_STATS_KEY),
-                Some(&"0".to_string()),
-                "_dd.compute_stats must be 0 when client_computed_stats is true"
-            );
-        }
-    }
-
     fn make_trace_sender(config: Arc<config::Config>) -> Arc<SendingTraceProcessor> {
         use libdd_trace_obfuscation::obfuscation_config::ObfuscationConfig;
         let (stats_concentrator_service, stats_concentrator_handle) =
diff --git a/bottlecap/src/lifecycle/invocation/processor_service.rs b/bottlecap/src/lifecycle/invocation/processor_service.rs
@@ -109,7 +109,6 @@ pub enum ProcessorCommand {
     },
     AddTracerSpan {
         span: Box<Span>,
-        client_computed_stats: bool,
     },
     ForwardDurableContext {
         request_id: String,
@@ -378,12 +377,10 @@ impl InvocationProcessorHandle {
     pub async fn add_tracer_span(
         &self,
         span: Span,
-        client_computed_stats: bool,
     ) -> Result<(), mpsc::error::SendError<ProcessorCommand>> {
         self.sender
             .send(ProcessorCommand::AddTracerSpan {
                 span: Box::new(span),
-                client_computed_stats,
             })
             .await
     }
@@ -612,11 +609,8 @@ impl InvocationProcessorService {
                     let result = Ok(self.processor.set_cold_start_span_trace_id(trace_id));
                     let _ = response.send(result);
                 }
-                ProcessorCommand::AddTracerSpan {
-                    span,
-                    client_computed_stats,
-                } => {
-                    self.processor.add_tracer_span(&span, client_computed_stats);
+                ProcessorCommand::AddTracerSpan { span } => {
+                    self.processor.add_tracer_span(&span);
                 }
                 ProcessorCommand::ForwardDurableContext {
                     request_id,
diff --git a/bottlecap/src/tags/lambda/tags.rs b/bottlecap/src/tags/lambda/tags.rs
@@ -39,7 +39,7 @@ const VERSION_KEY: &str = "version";
 const SERVICE_KEY: &str = "service";
 
 // ComputeStatsKey is the tag key indicating whether trace stats should be computed
-pub(crate) const COMPUTE_STATS_KEY: &str = "_dd.compute_stats";
+const COMPUTE_STATS_KEY: &str = "_dd.compute_stats";
 // FunctionTagsKey is the tag key for a function's tags to be set on the top level tracepayload
 const FUNCTION_TAGS_KEY: &str = "_dd.tags.function";
 // TODO(astuyve) decide what to do with the version
@@ -135,6 +135,12 @@ fn tags_from_env(
         tags_map.extend(config.tags.clone());
     }
 
+    // The value of _dd.compute_stats is the opposite of config.compute_trace_stats_on_extension.
+    // "config.compute_trace_stats_on_extension == true" means computing stats on the extension side,
+    // so we set _dd.compute_stats to 0 so stats won't be computed on the backend side.
+    let compute_stats = i32::from(!config.compute_trace_stats_on_extension);
+    tags_map.insert(COMPUTE_STATS_KEY.to_string(), compute_stats.to_string());
+
     tags_map
 }
 
@@ -294,7 +300,8 @@ mod tests {
     fn test_new_from_config() {
         let metadata = HashMap::new();
         let tags = Lambda::new_from_config(Arc::new(Config::default()), &metadata);
-        assert_eq!(tags.tags_map.len(), 2);
+        assert_eq!(tags.tags_map.len(), 3);
+        assert_eq!(tags.tags_map.get(COMPUTE_STATS_KEY).unwrap(), "1");
         let arch = arch_to_platform();
         assert_eq!(
             tags.tags_map.get(ARCHITECTURE_KEY).unwrap(),
@@ -429,7 +436,7 @@ mod tests {
                 (parts[0].to_string(), parts[1].to_string())
             })
             .collect();
-        assert_eq!(fn_tags_map.len(), 13);
+        assert_eq!(fn_tags_map.len(), 14);
         assert_eq!(fn_tags_map.get("key1").unwrap(), "value1");
         assert_eq!(fn_tags_map.get("key2").unwrap(), "value2");
         assert_eq!(fn_tags_map.get(ACCOUNT_ID_KEY).unwrap(), "123456789012");
@@ -471,7 +478,7 @@ mod tests {
                 (parts[0].to_string(), parts[1].to_string())
             })
             .collect();
-        assert_eq!(fn_tags_map.len(), 13);
+        assert_eq!(fn_tags_map.len(), 14);
         assert_eq!(fn_tags_map.get("key1").unwrap(), "value1");
         assert_eq!(fn_tags_map.get("key2").unwrap(), "value2");
         assert_eq!(fn_tags_map.get(ACCOUNT_ID_KEY).unwrap(), "123456789012");
diff --git a/bottlecap/src/traces/trace_agent.rs b/bottlecap/src/traces/trace_agent.rs
@@ -501,8 +501,7 @@ impl TraceAgent {
             );
         }
 
-        let tracer_header_tags: libdd_trace_utils::tracer_header_tags::TracerHeaderTags<'_> =
-            (&parts.headers).into();
+        let tracer_header_tags = (&parts.headers).into();
 
         let (body_size, mut traces): (usize, Vec<Vec<pb::Span>>) = match version {
             ApiVersion::V04 => {
@@ -532,6 +531,7 @@ impl TraceAgent {
                 }
             },
         };
+
         let mut reparenting_info = match invocation_processor_handle.get_reparenting_info().await {
             Ok(info) => info,
             Err(e) => {
@@ -586,7 +586,7 @@ impl TraceAgent {
 
                 if span.resource == INVOCATION_SPAN_RESOURCE
                     && let Err(e) = invocation_processor_handle
-                        .add_tracer_span(span.clone(), tracer_header_tags.client_computed_stats)
+                        .add_tracer_span(span.clone())
                         .await
                 {
                     error!("Failed to add tracer span to processor: {}", e);
diff --git a/bottlecap/src/traces/trace_processor.rs b/bottlecap/src/traces/trace_processor.rs
diff --git a/bottlecap/tests/logs_integration_test.rs b/bottlecap/tests/logs_integration_test.rs
