Split TagMap into id and name stores, owned directly by the span

build-logic/tag-registry/src/main/kotlin/datadog/buildlogic/tagRegistry/KnownTagsEmitter.kt

@@ -209,6 +209,21 @@ object KnownTagsEmitter {
         """
           };
 
+          /**
+           * Each tag's id, indexed by serial; slot 0 (no tag) is 0. Lets a store that keeps only the
+           * 16-bit serial recover the full id, flag and slot bits included.
+           */
+          static final long[] IDS_BY_SERIAL = {
+            0L,
+        """.trimIndent()
+      )
+      for (t in reg.tags.sortedBy { it.serial }) {
+        appendLine("    ${idC(t.ddName)},")
+      }
+      appendLine(
+        """
+          };
+
           /**
            * The registry's name↔id tables, as a {@link KnownTagCodec.Resolver}. {@code KnownTagCodec}
            * reads this field from its own holder, so the two classes complete each other: the codec owns
@@ -221,6 +236,11 @@ object KnownTagsEmitter {
                   int serial = KnownTagCodec.serialNum(tagId);
                   return serial < NAMES_BY_SERIAL.length ? NAMES_BY_SERIAL[serial] : null;
                 }
+
+                @Override
+                public long idOf(int serial) {
+                  return IDS_BY_SERIAL[serial];
+                }
 
                 // openTelemetryNameOf: id -> OTel-namespace name on spans of a direction, null when
                 // the tag has none there. The caller (a serializer) owns any fall-back-to-Datadog-name

build-logic/tag-registry/src/test/kotlin/datadog/buildlogic/tagRegistry/TagRegistryGeneratorPluginTest.kt

@@ -247,6 +247,7 @@ class TagRegistryGeneratorPluginTest {
       public final class KnownTagCodec {
         public interface Resolver {
           String nameOf(long id);
+          long idOf(int serial);
           String openTelemetryNameOf(long id, int direction);
           long keyOf(String name);
           long directionalKeyOf(String name, int direction);

dd-java-agent/instrumentation/opentelemetry/opentelemetry-0.3/src/test/groovy/TypeConverterTest.groovy

@@ -53,7 +53,6 @@ class TypeConverterTest extends InstrumentationSpecification {
       [:],
       false,
       "fakeType",
-      0,
       trace,
       null,
       null,

dd-java-agent/instrumentation/opentracing/opentracing-0.31/src/test/groovy/TypeConverterTest.groovy

@@ -65,7 +65,6 @@ class TypeConverterTest extends InstrumentationSpecification {
       [:],
       false,
       "fakeType",
-      0,
       trace,
       null,
       null,

dd-java-agent/instrumentation/opentracing/opentracing-0.32/src/test/groovy/TypeConverterTest.groovy

@@ -65,7 +65,6 @@ class TypeConverterTest extends InstrumentationSpecification {
       [:],
       false,
       "fakeType",
-      0,
       trace,
       null,
       null,

dd-trace-api/src/main/java/datadog/trace/api/config/TracerConfig.java

@@ -190,5 +190,11 @@ public final class TracerConfig {
   public static final String TRACE_ORG_GUARD_STRICT = "trace.org.guard.strict";
   public static final String TRACE_ORG_GUARD_TRUSTED_OPMS = "trace.org.guard.trusted.opms";
 
+  /**
+   * Stores known tags that have a dense-store slot in TagMap's dense store (no per-tag entry)
+   * instead of its hash buckets. Experimental, off by default.
+   */
+  public static final String TRACE_DENSE_TAGS_ENABLED = "trace.experimental.dense.tags.enabled";
+
   private TracerConfig() {}
 }

dd-trace-core/src/jmh/java/datadog/trace/common/writer/ddagent/TraceMapperBenchmark.java

@@ -116,7 +116,6 @@ public void init(Blackhole blackhole) {
             Collections.<String, String>emptyMap(),
             false,
             UTF8BytesString.create("type"),
-            0,
             traceCollector,
             null,
             null,

dd-trace-core/src/jmh/java/datadog/trace/core/GetTagBenchmark.java

@@ -0,0 +1,116 @@
+package datadog.trace.core;
+
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+
+import datadog.trace.api.KnownTags;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.TearDown;
+import org.openjdk.jmh.annotations.Warmup;
+
+/**
+ * Measures reading tags back from a live span, by how the tag is named: a known tag's name, a
+ * custom name, an OpenTelemetry name ({@code server.address}, which the core treats as a custom
+ * name), and misses. {@code getTag} takes the span's tag lock; {@code unsafeGetTag} reads without
+ * it, as the tracer's internal readers do.
+ */
+@State(Scope.Thread)
+@Warmup(iterations = 3, time = 1)
+@Measurement(iterations = 5, time = 1)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(NANOSECONDS)
+@Fork(value = 3)
+public class GetTagBenchmark {
+  static final CoreTracer TRACER = CoreTracer.builder().build();
+
+  private DDSpan span;
+
+  /**
+   * The known tags the span holds, read in turn by the {@code *_cycle} arms so a read's cost is
+   * averaged over the span's tags rather than decided by whether one particular tag collides in its
+   * bucket. A power-of-two length lets the index wrap with a mask.
+   */
+  private static final String[] KNOWN_HELD = {
+    "span.kind",
+    KnownTags.HTTP_ROUTE_NAME,
+    KnownTags.PEER_HOSTNAME_NAME,
+    KnownTags.HTTP_STATUS_CODE_NAME
+  };
+
+  private int next;
+
+  @Setup
+  public void setup() {
+    span = (DDSpan) TRACER.startSpan("benchmark", "get.tag");
+    span.setTag("span.kind", "client");
+    span.setTag(KnownTags.HTTP_ROUTE_NAME, "/users/{id}");
+    span.setTag(KnownTags.PEER_HOSTNAME_NAME, "db.example");
+    span.setTag(KnownTags.HTTP_STATUS_CODE_NAME, 200);
+    span.setTag("my.custom.tag", "custom");
+    span.setTag("my.other.tag", 42);
+  }
+
+  @TearDown
+  public void tearDown() {
+    span.finish();
+  }
+
+  @Benchmark
+  public Object knownTag_getTag() {
+    return span.getTag(KnownTags.HTTP_ROUTE_NAME);
+  }
+
+  @Benchmark
+  public Object customTag_getTag() {
+    return span.getTag("my.custom.tag");
+  }
+
+  @Benchmark
+  public Object aliasName_getTag() {
+    return span.getTag("server.address");
+  }
+
+  @Benchmark
+  public Object missingTag_getTag() {
+    return span.getTag("not.there");
+  }
+
+  /** A known tag the span doesn't hold: a clear slot bit can answer without a probe. */
+  @Benchmark
+  public Object missingKnownTag_getTag() {
+    return span.getTag(KnownTags.HTTP_METHOD_NAME);
+  }
+
+  @Benchmark
+  public Object missingKnownTag_unsafeGetTag() {
+    return span.unsafeGetTag(KnownTags.HTTP_METHOD_NAME);
+  }
+
+  @Benchmark
+  public Object knownTag_unsafeGetTag() {
+    return span.unsafeGetTag(KnownTags.HTTP_ROUTE_NAME);
+  }
+
+  /** Every known tag the span holds, in turn; see {@link #KNOWN_HELD}. */
+  @Benchmark
+  public Object knownTags_cycle_unsafeGetTag() {
+    return span.unsafeGetTag(KNOWN_HELD[next++ & (KNOWN_HELD.length - 1)]);
+  }
+
+  @Benchmark
+  public Object knownTags_cycle_getTag() {
+    return span.getTag(KNOWN_HELD[next++ & (KNOWN_HELD.length - 1)]);
+  }
+
+  @Benchmark
+  public Object customTag_unsafeGetTag() {
+    return span.unsafeGetTag("my.custom.tag");
+  }
+}

dd-trace-core/src/jmh/java/datadog/trace/core/PendingTraceWrite.java

@@ -55,7 +55,6 @@ public void init(TraceCounters counters, Blackhole blackhole) {
                 Collections.<String, String>emptyMap(),
                 false,
                 "type",
-                0,
                 traceCollector,
                 null,
                 null,
@@ -80,7 +79,6 @@ public void init(TraceCounters counters, Blackhole blackhole) {
                 Collections.<String, String>emptyMap(),
                 false,
                 "type",
-                0,
                 traceCollector,
                 null,
                 null,

dd-trace-core/src/jmh/java/datadog/trace/core/TracerMapperMap.java

@@ -135,7 +135,6 @@ private DDSpan createSpanWithOrigin(int iter, final String origin) {
             Collections.<String, String>emptyMap(),
             false,
             "type",
-            0,
             traceCollector,
             null,
             null,

dd-trace-core/src/jmh/java/datadog/trace/core/propagation/InjectorBenchmark.java

@@ -122,7 +122,6 @@ public void setUp(Blackhole blackhole) {
             Collections.<String, String>emptyMap(),
             false,
             "type",
-            0,
             tracer.createTraceCollector(traceId),
             null,
             null,

dd-trace-core/src/main/java/datadog/trace/core/CoreTracer.java

@@ -207,10 +207,43 @@ private static final class LocalRootSpanTags {
     final TagMap tags;
     final boolean needsIntercept;
 
+    /** The last {@link #traceLevelParent}, with the merged tracer tags it was built over. */
+    private volatile TraceLevelTags traceLevel;
+
     LocalRootSpanTags(final TagMap tags, final boolean needsIntercept) {
       this.tags = tags;
       this.needsIntercept = needsIntercept;
     }
+
+    /**
+     * All of a root span's trace-level tags in one frozen map -- these tags over {@code
+     * mergedTracerTags} -- for the root span to read through instead of copying them in. The tag
+     * registry colors trace-level tags separately, so they reuse span-level slot bits; keeping them
+     * out of the span's own store keeps its slot bits exact. Built once per config snapshot; a racy
+     * rebuild is harmless, since it builds the same map.
+     */
+    TagMap traceLevelParent(final TagMap mergedTracerTags) {
+      TraceLevelTags cached = this.traceLevel;
+      if (cached != null && cached.mergedTracerTags == mergedTracerTags) {
+        return cached.parent;
+      }
+      TagMap parent = TagMap.create();
+      parent.putAll(mergedTracerTags);
+      parent.putAll(this.tags);
+      parent.freeze();
+      this.traceLevel = new TraceLevelTags(mergedTracerTags, parent);
+      return parent;
+    }
+  }
+
+  private static final class TraceLevelTags {
+    final TagMap mergedTracerTags;
+    final TagMap parent;
+
+    TraceLevelTags(final TagMap mergedTracerTags, final TagMap parent) {
+      this.mergedTracerTags = mergedTracerTags;
+      this.parent = parent;
+    }
   }
 
   private volatile LocalRootSpanTags localRootSpanTags;
@@ -2129,6 +2162,7 @@ protected static final DDSpanContext buildSpanContext(
       final CharSequence origin;
       final TagMap coreTags;
       final boolean coreTagsNeedsIntercept;
+      final LocalRootSpanTags localRootSpanTags;
       final TagMap rootSpanTags;
       final boolean rootSpanTagsNeedsIntercept;
       final DDSpanContext context;
@@ -2158,6 +2192,7 @@ protected static final DDSpanContext buildSpanContext(
         origin = null;
         coreTags = null;
         coreTagsNeedsIntercept = false;
+        localRootSpanTags = null;
         rootSpanTags = null;
         rootSpanTagsNeedsIntercept = false;
         parentServiceName = ddsc.getServiceName();
@@ -2232,7 +2267,7 @@ protected static final DDSpanContext buildSpanContext(
           ciVisibilityContextData = null;
         }
 
-        LocalRootSpanTags localRootSpanTags = tracer.localRootSpanTags;
+        localRootSpanTags = tracer.localRootSpanTags;
         rootSpanTags = localRootSpanTags.tags;
         rootSpanTagsNeedsIntercept = localRootSpanTags.needsIntercept;
 
@@ -2311,12 +2346,22 @@ protected static final DDSpanContext buildSpanContext(
       final TagMap mergedTracerTags = traceConfig.mergedTracerTags;
       boolean mergedTracerTagsNeedsIntercept = traceConfig.mergedTracerTagsNeedsIntercept;
 
-      final int tagsSize =
-          mergedTracerTags.size()
-              + (null == tagLedger ? 0 : tagLedger.estimateSize())
-              + (null == coreTags ? 0 : coreTags.size())
-              + (null == rootSpanTags ? 0 : rootSpanTags.size())
-              + (null == contextualTags ? 0 : contextualTags.size());
+      // With builder tags taking precedence, a root span reads its trace-level tags (root-span tags
+      // over the merged tracer tags) through one shared frozen parent instead of copying the
+      // root-span tags in. They become the precedence floor: the flag's order already puts them
+      // below builder and contextual tags, and now inbound header tags and prototype defaults also
+      // win over them. Tags needing interception are still copied in.
+      final boolean rootSpanTagsReadThrough =
+          localRootSpanTags != null
+              && tracer.builderTagsPrecedence
+              && !rootSpanTagsNeedsIntercept
+              && !mergedTracerTagsNeedsIntercept;
+      final TagMap tagParent;
+      if (rootSpanTagsReadThrough) {
+        tagParent = localRootSpanTags.traceLevelParent(mergedTracerTags);
+      } else {
+        tagParent = mergedTracerTagsNeedsIntercept ? null : mergedTracerTags;
+      }
 
       if (builderRequestContextDataAppSec != null) {
         requestContextDataAppSec = builderRequestContextDataAppSec;
@@ -2345,7 +2390,6 @@ protected static final DDSpanContext buildSpanContext(
               w3cBaggage,
               errorFlag,
               spanType,
-              tagsSize,
               parentTraceCollector,
               requestContextDataAppSec,
               requestContextDataIast,
@@ -2356,7 +2400,7 @@ protected static final DDSpanContext buildSpanContext(
               tracer.profilingContextIntegration,
               tracer.injectBaggageAsTags,
               tracer.injectLinksAsTags,
-              mergedTracerTagsNeedsIntercept ? null : mergedTracerTags);
+              tagParent);
 
       // By setting the tags on the context we apply decorators to any tags that have been set via
       // the builder. The `mergedTracerTags` are always applied first (the precedence floor:
@@ -2381,7 +2425,9 @@ protected static final DDSpanContext buildSpanContext(
       }
       if (tracer.builderTagsPrecedence) {
         context.setAllTags(coreTags, coreTagsNeedsIntercept);
-        context.setAllTags(rootSpanTags, rootSpanTagsNeedsIntercept);
+        if (!rootSpanTagsReadThrough) {
+          context.setAllTags(rootSpanTags, rootSpanTagsNeedsIntercept);
+        }
         context.setAllTags(contextualTags);
         context.setAllTags(tagLedger);
       } else {