From 4dff7aad671d45f79a3f0356a41ebe52c9357a03 Mon Sep 17 00:00:00 2001 From: Douglas Q Hawkins Date: Mon, 22 Jun 2026 17:22:05 -0400 Subject: [PATCH 1/5] Add characterization test for non-root span _dd.p.* propagation CoreTracer span-build allocates a fresh propagationTagsFactory.empty() per local child span; only the distributed ExtractedContext path reuses the parent's. Before optimizing that per-span allocation away, this test pins the load-bearing behavior: that a non-root (local child) span still carries the inbound distributed _dd.p.* tags when it injects. Verdict (both tests pass): it does. DDSpanContext.getPropagationTags() routes to the root (getRootSpanContextOrThis), so a non-root child's own propagationTags field is never read for injection. The per-span empty() is pure allocation waste, not a latent correctness bug. This test is the gate + safety net for the planned "share the parent's PropagationTags for local children" allocation fix. Co-Authored-By: Claude Opus 4.8 --- .../core/PropagationTagsChildSpanTest.java | 98 +++++++++++++++++++ 1 file changed, 98 insertions(+) create mode 100644 dd-trace-core/src/test/java/datadog/trace/core/PropagationTagsChildSpanTest.java diff --git a/dd-trace-core/src/test/java/datadog/trace/core/PropagationTagsChildSpanTest.java b/dd-trace-core/src/test/java/datadog/trace/core/PropagationTagsChildSpanTest.java new file mode 100644 index 00000000000..d1cdc3e60e2 --- /dev/null +++ b/dd-trace-core/src/test/java/datadog/trace/core/PropagationTagsChildSpanTest.java @@ -0,0 +1,98 @@ +package datadog.trace.core; + +import static datadog.trace.api.TracePropagationStyle.DATADOG; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import datadog.trace.api.DDTraceId; +import datadog.trace.api.sampling.PrioritySampling; +import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.core.propagation.ExtractedContext; +import datadog.trace.core.propagation.PropagationTags; +import java.util.Collections; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +/** + * Characterization test for the open question in {@code ptags-allocation-findings.md}: when a + * distributed trace arrives carrying {@code _dd.p.*} propagation tags, does a non-root (local + * child) span still carry those inbound tags when it injects? + * + *

Inbound {@code _dd.p.*} live on the root's {@link PropagationTags} (inherited from the {@link + * ExtractedContext}, {@code CoreTracer} ~line 2031), but a local child currently receives a fresh + * {@code propagationTagsFactory.empty()} instance (~line 2020). If {@link + * #localChildCarriesInboundDdpTags()} fails, non-root injection is dropping inbound {@code + * _dd.p.*} — a latent correctness bug, not merely the known per-span allocation waste. If it + * passes, there is reconciliation and the per-span empties are pure waste (sharing the + * parent's instance is then a safe allocation win). + * + *

Either way this test is the gate + safety net for the planned "share the parent's + * PropagationTags for local children" fix. + */ +class PropagationTagsChildSpanTest extends DDCoreJavaSpecification { + + private static final String INBOUND_HEADER = "_dd.p.dm=934086a686-4,_dd.p.anytag=value"; + private static final String INBOUND_TAG = "_dd.p.anytag=value"; + + private CoreTracer tracer; + + @BeforeEach + void setup() { + tracer = tracerBuilder().build(); + } + + private static ExtractedContext extractedWithDdpTags() { + return new ExtractedContext( + DDTraceId.ONE, + 2, + PrioritySampling.SAMPLER_KEEP, + null, + 0, + Collections.emptyMap(), + Collections.emptyMap(), + null, + PropagationTags.factory() + .fromHeaderValue(PropagationTags.HeaderType.DATADOG, INBOUND_HEADER), + null, + DATADOG); + } + + /** What the Datadog codec would inject for {@code x-datadog-tags} from this span. */ + private static String injectedDdpHeader(AgentSpan span) { + return ((DDSpanContext) span.context()) + .getPropagationTags() + .headerValue(PropagationTags.HeaderType.DATADOG); + } + + /** Baseline: the root span (built directly from the extracted context) carries inbound tags. */ + @Test + void rootSpanCarriesInboundDdpTags() { + AgentSpan root = tracer.buildSpan("test", "root").asChildOf(extractedWithDdpTags()).start(); + try { + String header = injectedDdpHeader(root); + assertTrue( + header != null && header.contains(INBOUND_TAG), + "root injected _dd.p.* header should contain inbound tag; was: " + header); + } finally { + root.finish(); + } + } + + /** + * THE open question: a local child of the root. Inbound {@code _dd.p.*} must survive injection + * from the child, or downstream services lose the distributed tags on every non-root hop. + */ + @Test + void localChildCarriesInboundDdpTags() { + AgentSpan root = tracer.buildSpan("test", "root").asChildOf(extractedWithDdpTags()).start(); + AgentSpan child = tracer.buildSpan("test", "child").asChildOf(root.context()).start(); + try { + String header = injectedDdpHeader(child); + assertTrue( + header != null && header.contains(INBOUND_TAG), + "local child injected _dd.p.* header should contain inbound tag; was: " + header); + } finally { + child.finish(); + root.finish(); + } + } +} From dbbd71e7167f5feec0ef20440b73c2f64de4d620 Mon Sep 17 00:00:00 2001 From: Douglas Q Hawkins Date: Mon, 22 Jun 2026 17:27:09 -0400 Subject: [PATCH 2/5] Share parent's PropagationTags for local child spans MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit CoreTracer span-build allocated a fresh propagationTagsFactory.empty() for every local child span, reused from the parent only on the distributed ExtractedContext path — N+1 PropagationTags per N-span trace, N of them needless empties. A non-root child's own PropagationTags is never read for injection: DDSpanContext.getPropagationTags() routes to the root (getRootSpanContextOrThis), confirmed by PropagationTagsChildSpanTest (inbound _dd.p.* survive child injection). So local children can share the parent's (trace-level) instance instead of allocating their own, collapsing N+1 -> 1 per trace. Safe: the ctor's updateTraceIdHighOrderBits stamp is guard-idempotent and a no-op on the already-stamped shared root instance (same trace => same high-order bits). Full dd-trace-core propagation + span-build suite passes. Co-Authored-By: Claude Opus 4.8 --- .../src/main/java/datadog/trace/core/CoreTracer.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) 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 375480a8792..64ab771a8b7 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 @@ -2017,7 +2017,12 @@ protected static final DDSpanContext buildSpanContext( requestContextDataIast = null; ciVisibilityContextData = null; } - propagationTags = tracer.propagationTagsFactory.empty(); + // Local child: share the parent's (trace-level) PropagationTags instead of allocating a + // fresh empty() per span. getPropagationTags() routes to the root, so a non-root child's + // own instance is never read for injection — the per-span empty() was pure allocation + // waste (N+1 -> 1 PropagationTags per trace). The ctor's updateTraceIdHighOrderBits stamp + // is a guarded no-op on the already-stamped root instance (same trace => same high bits). + propagationTags = ddsc.getPropagationTags(); } else { long endToEndStartTime; From 1860ad6e6fcd6dbaa038d20b6bd1bbbcde187150 Mon Sep 17 00:00:00 2001 From: Douglas Q Hawkins Date: Tue, 23 Jun 2026 12:01:37 -0400 Subject: [PATCH 3/5] Simplify the share-PropagationTags comment (review feedback) Co-Authored-By: Claude Opus 4.8 --- .../src/main/java/datadog/trace/core/CoreTracer.java | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) 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 64ab771a8b7..c0e7f206db3 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 @@ -2017,11 +2017,8 @@ protected static final DDSpanContext buildSpanContext( requestContextDataIast = null; ciVisibilityContextData = null; } - // Local child: share the parent's (trace-level) PropagationTags instead of allocating a - // fresh empty() per span. getPropagationTags() routes to the root, so a non-root child's - // own instance is never read for injection — the per-span empty() was pure allocation - // waste (N+1 -> 1 PropagationTags per trace). The ctor's updateTraceIdHighOrderBits stamp - // is a guarded no-op on the already-stamped root instance (same trace => same high bits). + // Local children share the parent's PropagationTags (trace-level state; reads route to the + // root) instead of allocating an unused empty() per span. propagationTags = ddsc.getPropagationTags(); } else { long endToEndStartTime; From d2dcddd69d66b4609437392b561e90da2526f3f6 Mon Sep 17 00:00:00 2001 From: Douglas Q Hawkins Date: Mon, 29 Jun 2026 09:51:28 -0400 Subject: [PATCH 4/5] Reframe PropagationTagsChildSpanTest Javadoc as a regression guard The change landed, so drop the pre-implementation 'open question / planned fix' framing, the scratch-doc reference (ptags-allocation-findings.md), and the brittle CoreTracer line numbers. State what it guards: local children share the root's PropagationTags, and reads route to the root, so a non-root span still injects the inbound _dd.p.* tags. Co-Authored-By: Claude Opus 4.8 --- .../core/PropagationTagsChildSpanTest.java | 22 ++++++++----------- 1 file changed, 9 insertions(+), 13 deletions(-) diff --git a/dd-trace-core/src/test/java/datadog/trace/core/PropagationTagsChildSpanTest.java b/dd-trace-core/src/test/java/datadog/trace/core/PropagationTagsChildSpanTest.java index d1cdc3e60e2..3eaff2266f2 100644 --- a/dd-trace-core/src/test/java/datadog/trace/core/PropagationTagsChildSpanTest.java +++ b/dd-trace-core/src/test/java/datadog/trace/core/PropagationTagsChildSpanTest.java @@ -13,20 +13,16 @@ import org.junit.jupiter.api.Test; /** - * Characterization test for the open question in {@code ptags-allocation-findings.md}: when a - * distributed trace arrives carrying {@code _dd.p.*} propagation tags, does a non-root (local - * child) span still carry those inbound tags when it injects? + * Regression guard for the "local children share the parent's {@link PropagationTags}" optimization + * in {@code CoreTracer.buildSpanContext}: a non-root (local child) span must still carry the + * inbound distributed {@code _dd.p.*} tags when it injects. * - *

Inbound {@code _dd.p.*} live on the root's {@link PropagationTags} (inherited from the {@link - * ExtractedContext}, {@code CoreTracer} ~line 2031), but a local child currently receives a fresh - * {@code propagationTagsFactory.empty()} instance (~line 2020). If {@link - * #localChildCarriesInboundDdpTags()} fails, non-root injection is dropping inbound {@code - * _dd.p.*} — a latent correctness bug, not merely the known per-span allocation waste. If it - * passes, there is reconciliation and the per-span empties are pure waste (sharing the - * parent's instance is then a safe allocation win). - * - *

Either way this test is the gate + safety net for the planned "share the parent's - * PropagationTags for local children" fix. + *

Inbound {@code _dd.p.*} live on the root's {@code PropagationTags} (inherited from the {@link + * ExtractedContext}), and reads route to the root via {@code DDSpanContext.getPropagationTags()} — + * so a local child injects the same tags whether it holds its own instance or shares the root's. + * That invariant is what lets the child skip allocating its own {@code empty()} and share the + * root's instead. If {@link #localChildCarriesInboundDdpTags()} regresses, non-root injection is + * dropping inbound {@code _dd.p.*} on every hop. */ class PropagationTagsChildSpanTest extends DDCoreJavaSpecification { From 1d03e0ae7141aec1b2903412febb813debb68170 Mon Sep 17 00:00:00 2001 From: Douglas Q Hawkins Date: Mon, 29 Jun 2026 17:46:50 -0400 Subject: [PATCH 5/5] Fix PropagationTagsChildSpanTest compile: context() -> spanContext() The master merge renamed AgentSpan.context() to spanContext(); update the two call sites so :dd-trace-core:compileTestJava passes. Co-Authored-By: Claude Opus 4.8 --- .../java/datadog/trace/core/PropagationTagsChildSpanTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dd-trace-core/src/test/java/datadog/trace/core/PropagationTagsChildSpanTest.java b/dd-trace-core/src/test/java/datadog/trace/core/PropagationTagsChildSpanTest.java index 3eaff2266f2..1f20e58c661 100644 --- a/dd-trace-core/src/test/java/datadog/trace/core/PropagationTagsChildSpanTest.java +++ b/dd-trace-core/src/test/java/datadog/trace/core/PropagationTagsChildSpanTest.java @@ -54,7 +54,7 @@ private static ExtractedContext extractedWithDdpTags() { /** What the Datadog codec would inject for {@code x-datadog-tags} from this span. */ private static String injectedDdpHeader(AgentSpan span) { - return ((DDSpanContext) span.context()) + return ((DDSpanContext) span.spanContext()) .getPropagationTags() .headerValue(PropagationTags.HeaderType.DATADOG); } @@ -80,7 +80,7 @@ void rootSpanCarriesInboundDdpTags() { @Test void localChildCarriesInboundDdpTags() { AgentSpan root = tracer.buildSpan("test", "root").asChildOf(extractedWithDdpTags()).start(); - AgentSpan child = tracer.buildSpan("test", "child").asChildOf(root.context()).start(); + AgentSpan child = tracer.buildSpan("test", "child").asChildOf(root.spanContext()).start(); try { String header = injectedDdpHeader(child); assertTrue(