feat(traces): propagate client_computed_stats to extension-generated aws.lambda span

When the Go tracer sends its placeholder span (dd-tracer-serverless-span)
with Datadog-Client-Computed-Stats: t, store that flag in the invocation
Context and pass it through to send_spans so the extension does not
double-count stats for the aws.lambda span it generates.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: lym953

bottlecap/src/lifecycle/invocation/context.rs

@@ -43,6 +43,11 @@ pub struct Context {
     /// tracing.
     ///
     pub extracted_span_context: Option<SpanContext>,
+    /// Whether the tracer has already computed stats for this invocation.
+    ///
+    /// Set from the `Datadog-Client-Computed-Stats` header when the tracer's
+    /// placeholder span (`dd-tracer-serverless-span`) is received.
+    pub client_computed_stats: bool,
 }
 
 /// Struct containing the information needed to reparent a span.
@@ -94,6 +99,7 @@ impl Default for Context {
             snapstart_restore_span: None,
             tracer_span: None,
             extracted_span_context: None,
+            client_computed_stats: false,
         }
     }
 }
@@ -508,7 +514,12 @@ 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) {
+    pub fn add_tracer_span(
+        &mut self,
+        request_id: &String,
+        tracer_span: &Span,
+        client_computed_stats: bool,
+    ) {
         if let Some(context) = self
             .buffer
             .iter_mut()
@@ -528,6 +539,7 @@ 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");
         }

bottlecap/src/lifecycle/invocation/processor.rs

@@ -610,9 +610,16 @@ 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, tags_provider, trace_sender)
-            .await;
+        self.send_spans(
+            traces,
+            body_size,
+            client_computed_stats,
+            tags_provider,
+            trace_sender,
+        )
+        .await;
     }
 
     fn get_ctx_spans(&mut self, context: Context) -> (Vec<Span>, usize) {
@@ -677,7 +684,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, tags_provider, trace_sender)
+            self.send_spans(traces, body_size, false, tags_provider, trace_sender)
                 .await;
         }
     }
@@ -689,6 +696,7 @@ impl Processor {
         &mut self,
         traces: Vec<Span>,
         body_size: usize,
+        client_computed_stats: bool,
         tags_provider: &Arc<provider::Provider>,
         trace_sender: &Arc<SendingTraceProcessor>,
     ) {
@@ -701,7 +709,7 @@ impl Processor {
             tracer_version: "",
             container_id: "",
             client_computed_top_level: false,
-            client_computed_stats: false,
+            client_computed_stats,
             dropped_p0_traces: 0,
             dropped_p0_spans: 0,
         };
@@ -1337,9 +1345,10 @@ 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) {
+    pub fn add_tracer_span(&mut self, span: &Span, client_computed_stats: bool) {
         if let Some(request_id) = span.meta.get("request_id") {
-            self.context_buffer.add_tracer_span(request_id, span);
+            self.context_buffer
+                .add_tracer_span(request_id, span, client_computed_stats);
         }
     }
 }

bottlecap/src/lifecycle/invocation/processor_service.rs

@@ -110,6 +110,7 @@ pub enum ProcessorCommand {
     },
     AddTracerSpan {
         span: Box<Span>,
+        client_computed_stats: bool,
     },
     OnOutOfMemoryError {
         timestamp: i64,
@@ -372,10 +373,12 @@ 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
     }
@@ -585,8 +588,11 @@ impl InvocationProcessorService {
                     let result = Ok(self.processor.set_cold_start_span_trace_id(trace_id));
                     let _ = response.send(result);
                 }
-                ProcessorCommand::AddTracerSpan { span } => {
-                    self.processor.add_tracer_span(&span);
+                ProcessorCommand::AddTracerSpan {
+                    span,
+                    client_computed_stats,
+                } => {
+                    self.processor.add_tracer_span(&span, client_computed_stats);
                 }
                 ProcessorCommand::OnOutOfMemoryError { timestamp } => {
                     self.processor.on_out_of_memory_error(timestamp);

bottlecap/src/traces/trace_agent.rs

@@ -501,7 +501,8 @@ impl TraceAgent {
             );
         }
 
-        let tracer_header_tags = (&parts.headers).into();
+        let tracer_header_tags: libdd_trace_utils::tracer_header_tags::TracerHeaderTags<'_> =
+            (&parts.headers).into();
 
         let (body_size, mut traces): (usize, Vec<Vec<pb::Span>>) = match version {
             ApiVersion::V04 => {
@@ -531,7 +532,6 @@ 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())
+                        .add_tracer_span(span.clone(), tracer_header_tags.client_computed_stats)
                         .await
                 {
                     error!("Failed to add tracer span to processor: {}", e);