From 801bf5ce80c57bc580e6e4c5177e9bb78363270f Mon Sep 17 00:00:00 2001 From: Stuart McCulloch Date: Mon, 9 Nov 2026 10:59:47 +0000 Subject: [PATCH] Reset async propagation when attaching agent-managed contexts New context scopes now use the default async propagation setting, matching activateSpan. Re-attaching the current context preserves its existing setting. Preserve inheritance in the OpenTelemetry shim because makeCurrent() is a manual tracing API. A manual attachment inside a scope with async propagation disabled must keep it disabled, including if the application fails to close the manual scope. This keeps manual scope management from inadvertently re-enabling async propagation disabled by instrumentation. --- .../shim/context/OtelContext.java | 11 ++++++- .../opentelemetry14/context/ContextTest.java | 32 +++++++++++++++++++ .../scopemanager/ContinuableScopeManager.java | 6 ++-- .../scopemanager/ScopeManagerForkedTest.java | 27 ++++++++++++++++ 4 files changed, 71 insertions(+), 5 deletions(-) diff --git a/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/context/OtelContext.java b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/context/OtelContext.java index ba4199b0c51..19008ee0732 100644 --- a/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/context/OtelContext.java +++ b/dd-java-agent/agent-otel/otel-shim/src/main/java/datadog/opentelemetry/shim/context/OtelContext.java @@ -1,5 +1,8 @@ package datadog.opentelemetry.shim.context; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.isAsyncPropagationEnabled; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.setAsyncPropagationEnabled; + import datadog.opentelemetry.shim.baggage.OtelBaggage; import datadog.opentelemetry.shim.trace.OtelSpan; import datadog.trace.bootstrap.instrumentation.api.AgentSpan; @@ -40,7 +43,13 @@ public static Context current() { @Override public Scope makeCurrent() { - return new OtelScope(Context.super.makeCurrent(), delegate.attach()); + boolean asyncPropagation = isAsyncPropagationEnabled(); + Scope scope = new OtelScope(Context.super.makeCurrent(), delegate.attach()); + // Manual tracing inherits disabled propagation from the active scope. + if (!asyncPropagation) { + setAsyncPropagationEnabled(false); + } + return scope; } @Nullable diff --git a/dd-java-agent/instrumentation/opentelemetry/opentelemetry-1.4/src/test/java/opentelemetry14/context/ContextTest.java b/dd-java-agent/instrumentation/opentelemetry/opentelemetry-1.4/src/test/java/opentelemetry14/context/ContextTest.java index f3ecbcc5791..08e45a4d9e5 100644 --- a/dd-java-agent/instrumentation/opentelemetry/opentelemetry-1.4/src/test/java/opentelemetry14/context/ContextTest.java +++ b/dd-java-agent/instrumentation/opentelemetry/opentelemetry-1.4/src/test/java/opentelemetry14/context/ContextTest.java @@ -2,6 +2,8 @@ import static datadog.trace.agent.test.assertions.SpanMatcher.span; import static datadog.trace.agent.test.assertions.TraceMatcher.trace; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.isAsyncPropagationEnabled; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.setAsyncPropagationEnabled; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; @@ -22,9 +24,39 @@ import opentelemetry14.AbstractOpenTelemetry14Test; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import org.tabletest.junit.TableTest; public class ContextTest extends AbstractOpenTelemetry14Test { + @Test + void firstManualAttachmentDefaultsToAsyncPropagation() { + Context context = Context.root().with(ContextKey.named("test-key"), "value"); + try (Scope ignored = context.makeCurrent()) { + assertTrue(isAsyncPropagationEnabled()); + } + } + + @TableTest({ + "Scenario | asyncPropagation | sameContext", + "Enabled parent, new context | true | false ", + "Disabled parent, new context | false | false ", + "Enabled parent, current context | true | true ", + "Disabled parent, current context | false | true " + }) + void manualAttachmentInheritsAsyncPropagation(boolean asyncPropagation, boolean sameContext) { + ContextKey key = ContextKey.named("test-key"); + Context parent = Context.root().with(key, "parent"); + try (Scope ignored = parent.makeCurrent()) { + setAsyncPropagationEnabled(asyncPropagation); + Context child = sameContext ? parent : parent.with(key, "child"); + try (Scope ignored2 = child.makeCurrent()) { + assertEquals(asyncPropagation, isAsyncPropagationEnabled()); + } + assertEquals(asyncPropagation, isAsyncPropagationEnabled()); + } + assertTrue(isAsyncPropagationEnabled()); + } + @DisplayName("test Span.current/makeCurrent()") @Test void testSpanCurrentMakeCurrent() { 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 a1c11f21a45..f46df068930 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 @@ -172,11 +172,9 @@ private ContextScope activate(final Context context) { assert context != null; - // Inherit the async propagation from the active scope - boolean asyncPropagation = top != null ? top.isAsyncPropagating() : DEFAULT_ASYNC_PROPAGATING; - final ContinuableScope scope = - new ContinuableScope(this, context, CONTEXT, asyncPropagation, createScopeState(context)); + new ContinuableScope( + this, context, CONTEXT, DEFAULT_ASYNC_PROPAGATING, createScopeState(context)); scopeStack.push(scope); healthMetrics.onActivateScope(); diff --git a/dd-trace-core/src/test/java/datadog/trace/core/scopemanager/ScopeManagerForkedTest.java b/dd-trace-core/src/test/java/datadog/trace/core/scopemanager/ScopeManagerForkedTest.java index 3bc3da7b29b..8333f6e2499 100644 --- a/dd-trace-core/src/test/java/datadog/trace/core/scopemanager/ScopeManagerForkedTest.java +++ b/dd-trace-core/src/test/java/datadog/trace/core/scopemanager/ScopeManagerForkedTest.java @@ -126,6 +126,33 @@ void noActiveScopeDefaultsToAsyncPropagation() { } } + @Test + void attachingNewContextResetsAsyncPropagation() { + ContextKey key = ContextKey.named("test-key"); + Context parent = Context.root().with(key, "parent"); + try (ContextScope ignored = parent.attach()) { + tracer.setAsyncPropagationEnabled(false); + try (ContextScope ignored2 = parent.with(key, "child").attach()) { + assertTrue(tracer.isAsyncPropagationEnabled()); + } + assertFalse(tracer.isAsyncPropagationEnabled()); + } + assertTrue(tracer.isAsyncPropagationEnabled()); + } + + @Test + void attachingTheCurrentContextPreservesAsyncPropagation() { + Context context = Context.root().with(ContextKey.named("test-key"), "value"); + try (ContextScope ignored = context.attach()) { + tracer.setAsyncPropagationEnabled(false); + try (ContextScope ignored2 = context.attach()) { + assertFalse(tracer.isAsyncPropagationEnabled()); + } + assertFalse(tracer.isAsyncPropagationEnabled()); + } + assertTrue(tracer.isAsyncPropagationEnabled()); + } + @Test void nonDdspanActivationResultsInAContinuableScope() { ContextScope scope = scopeManager.activateSpan(noopSpan());