From d61c3e050faae4f4671a2a95630495ae46e76910 Mon Sep 17 00:00:00 2001
From: Douglas Q Hawkins <douglas.hawkins@datadoghq.com>
Date: Fri, 29 May 2026 20:56:55 -0400
Subject: [PATCH] Fix W3C baggage not propagated on outgoing reactor-netty
 (WebClient) requests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

CaptureConnectSpan captured only the active span into the Reactor context at
subscription time, discarding the full Datadog Context (which carries baggage).
TransferConnectSpan then called captureSpan(span) on the Reactor I/O thread where
no Datadog scope is active, so the resulting continuation held a context of just
the span — no baggage.  HttpClientRequestTracingHandler.injectContext(current(),…)
therefore found no Baggage entry and skipped the baggage header.

Fix: CaptureConnectSpan now also stores Context.current() (the full context
including baggage) into the Reactor context alongside the span.
TransferConnectSpan uses the new captureSpan(AgentSpan, Context) overload to
build the continuation from that captured context, so baggage is carried across
the async boundary and injected correctly.

The new overload is wired through AgentTracer, TracerAPI, CoreTracer, and
ContinuableScopeManager.

Fixes: https://github.com/DataDog/dd-trace-java/issues/11510

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../reactor/netty/CaptureConnectSpan.java     |  4 ++-
 .../reactor/netty/TransferConnectSpan.java    | 10 ++++++-
 .../java/datadog/trace/core/CoreTracer.java   |  6 +++++
 .../scopemanager/ContinuableScopeManager.java |  7 +++++
 .../instrumentation/api/AgentTracer.java      | 26 +++++++++++++++++++
 5 files changed, 51 insertions(+), 2 deletions(-)

diff --git a/dd-java-agent/instrumentation/reactor-netty-1.0/src/main/java/datadog/trace/instrumentation/reactor/netty/CaptureConnectSpan.java b/dd-java-agent/instrumentation/reactor-netty-1.0/src/main/java/datadog/trace/instrumentation/reactor/netty/CaptureConnectSpan.java
index 351a37affd3..68cb2c55208 100644
--- a/dd-java-agent/instrumentation/reactor-netty-1.0/src/main/java/datadog/trace/instrumentation/reactor/netty/CaptureConnectSpan.java
+++ b/dd-java-agent/instrumentation/reactor-netty-1.0/src/main/java/datadog/trace/instrumentation/reactor/netty/CaptureConnectSpan.java
@@ -2,6 +2,7 @@
 
 import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan;
 
+import datadog.context.Context;
 import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
 import java.util.function.Function;
 import reactor.core.publisher.Mono;
@@ -11,6 +12,7 @@ public class CaptureConnectSpan
     implements Function<Mono<? extends Connection>, Mono<? extends Connection>> {
 
   static final String CONNECT_SPAN = "datadog.connect.span";
+  static final String CONNECT_CONTEXT = "datadog.connect.context";
 
   @Override
   public Mono<? extends Connection> apply(Mono<? extends Connection> mono) {
@@ -18,7 +20,7 @@ public Mono<? extends Connection> apply(Mono<? extends Connection> mono) {
         context -> {
           final AgentSpan span = activeSpan();
           if (null != span) {
-            return context.put(CONNECT_SPAN, span);
+            return context.put(CONNECT_SPAN, span).put(CONNECT_CONTEXT, Context.current());
           } else {
             return context;
           }
diff --git a/dd-java-agent/instrumentation/reactor-netty-1.0/src/main/java/datadog/trace/instrumentation/reactor/netty/TransferConnectSpan.java b/dd-java-agent/instrumentation/reactor-netty-1.0/src/main/java/datadog/trace/instrumentation/reactor/netty/TransferConnectSpan.java
index 5d07e5c3c26..b0a4926e865 100644
--- a/dd-java-agent/instrumentation/reactor-netty-1.0/src/main/java/datadog/trace/instrumentation/reactor/netty/TransferConnectSpan.java
+++ b/dd-java-agent/instrumentation/reactor-netty-1.0/src/main/java/datadog/trace/instrumentation/reactor/netty/TransferConnectSpan.java
@@ -2,8 +2,10 @@
 
 import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.captureSpan;
 import static datadog.trace.instrumentation.netty41.AttributeKeys.CONNECT_PARENT_CONTINUATION_ATTRIBUTE_KEY;
+import static datadog.trace.instrumentation.reactor.netty.CaptureConnectSpan.CONNECT_CONTEXT;
 import static datadog.trace.instrumentation.reactor.netty.CaptureConnectSpan.CONNECT_SPAN;
 
+import datadog.context.Context;
 import datadog.trace.bootstrap.instrumentation.api.AgentScope.Continuation;
 import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
 import java.util.function.BiConsumer;
@@ -14,7 +16,13 @@ public class TransferConnectSpan implements BiConsumer<HttpClientRequest, Connec
   @Override
   public void accept(HttpClientRequest httpClientRequest, Connection connection) {
     final AgentSpan span = httpClientRequest.currentContextView().getOrDefault(CONNECT_SPAN, null);
-    final Continuation continuation = null == span ? null : captureSpan(span);
+    if (null == span) {
+      return;
+    }
+    final Context capturedContext =
+        httpClientRequest.currentContextView().getOrDefault(CONNECT_CONTEXT, null);
+    final Continuation continuation =
+        capturedContext != null ? captureSpan(span, capturedContext) : captureSpan(span);
     if (null != continuation) {
       Continuation current =
           connection
diff --git a/dd-trace-core/src/main/java/datadog/trace/core/CoreTracer.java b/dd-trace-core/src/main/java/datadog/trace/core/CoreTracer.java
index 73e3c2063e0..f0e1a1a37a8 100644
--- a/dd-trace-core/src/main/java/datadog/trace/core/CoreTracer.java
+++ b/dd-trace-core/src/main/java/datadog/trace/core/CoreTracer.java
@@ -22,6 +22,7 @@
 import datadog.communication.ddagent.DDAgentFeaturesDiscovery;
 import datadog.communication.ddagent.ExternalAgentLauncher;
 import datadog.communication.ddagent.SharedCommunicationObjects;
+import datadog.context.Context;
 import datadog.context.propagation.Propagators;
 import datadog.environment.ThreadSupport;
 import datadog.logging.RatelimitedLogger;
@@ -1163,6 +1164,11 @@ public AgentScope.Continuation captureSpan(final AgentSpan span) {
     return scopeManager.captureSpan(span);
   }
 
+  @Override
+  public AgentScope.Continuation captureSpan(final AgentSpan span, final Context capturedContext) {
+    return scopeManager.captureSpan(span, capturedContext);
+  }
+
   @Override
   public boolean isAsyncPropagationEnabled() {
     return scopeManager.isAsyncPropagationEnabled();
diff --git a/dd-trace-core/src/main/java/datadog/trace/core/scopemanager/ContinuableScopeManager.java b/dd-trace-core/src/main/java/datadog/trace/core/scopemanager/ContinuableScopeManager.java
index 5d997f87b39..7cb081cd340 100644
--- a/dd-trace-core/src/main/java/datadog/trace/core/scopemanager/ContinuableScopeManager.java
+++ b/dd-trace-core/src/main/java/datadog/trace/core/scopemanager/ContinuableScopeManager.java
@@ -121,6 +121,13 @@ public AgentScope.Continuation captureSpan(final AgentSpan span) {
     return captureSpan(context, INSTRUMENTATION, span);
   }
 
+  public AgentScope.Continuation captureSpan(final AgentSpan span, final Context capturedContext) {
+    if (span == null) {
+      return AgentTracer.noopContinuation();
+    }
+    return captureSpan(capturedContext.with(span), INSTRUMENTATION, span);
+  }
+
   private AgentScope.Continuation captureSpan(Context context, byte source, AgentSpan span) {
     AgentTraceCollector traceCollector = span.context().getTraceCollector();
     return new ScopeContinuation(this, context, source, traceCollector).register();
diff --git a/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentTracer.java b/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentTracer.java
index 14a5b5d6d21..545d65a7061 100644
--- a/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentTracer.java
+++ b/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentTracer.java
@@ -1,5 +1,6 @@
 package datadog.trace.bootstrap.instrumentation.api;
 
+import datadog.context.Context;
 import datadog.trace.api.ConfigDefaults;
 import datadog.trace.api.DDTraceId;
 import datadog.trace.api.EndpointCheckpointer;
@@ -104,6 +105,23 @@ public static AgentScope.Continuation captureSpan(final AgentSpan span) {
     return get().captureSpan(span);
   }
 
+  /**
+   * Like {@link #captureSpan(AgentSpan)} but uses an explicitly supplied context instead of the
+   * current thread's scope-stack context. Use this when the context with baggage was captured on a
+   * different thread (e.g. a Reactor subscription thread) and needs to be carried into the
+   * continuation created on an I/O thread that has no active scope.
+   *
+   * @param span the span to include in the continuation
+   * @param capturedContext the context (e.g. containing baggage) captured from the originating
+   *     thread
+   * @return Continuation with the supplied context, no-op continuation if the span is null.
+   */
+  @Nonnull
+  public static AgentScope.Continuation captureSpan(
+      final AgentSpan span, final Context capturedContext) {
+    return get().captureSpan(span, capturedContext);
+  }
+
   /**
    * Checkpoints the active scope. A subsequent call to {@link #rollbackActiveToCheckpoint()} closes
    * outstanding scopes up to but not including the most recent checkpointed scope.
@@ -329,6 +347,8 @@ AgentSpan startSpan(
 
     AgentScope.Continuation captureSpan(AgentSpan span);
 
+    AgentScope.Continuation captureSpan(AgentSpan span, Context capturedContext);
+
     void checkpointActiveForRollback();
 
     void rollbackActiveToCheckpoint();
@@ -488,6 +508,12 @@ public AgentScope.Continuation captureSpan(final AgentSpan span) {
       return NoopContinuation.INSTANCE;
     }
 
+    @Override
+    public AgentScope.Continuation captureSpan(
+        final AgentSpan span, final Context capturedContext) {
+      return NoopContinuation.INSTANCE;
+    }
+
     @Override
     public boolean isAsyncPropagationEnabled() {
       return false;