Keep TagMap.Ledger in parallel arrays keyed by tag id (phase 2 - dense tag storage)

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

@@ -2,6 +2,7 @@
 
 import static java.util.concurrent.TimeUnit.MICROSECONDS;
 
+import datadog.trace.api.KnownTags;
 import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
 import datadog.trace.bootstrap.instrumentation.api.SpanPrototype;
 import datadog.trace.bootstrap.instrumentation.api.Tags;
@@ -222,6 +223,26 @@ public void webServerSpanViaBuilder() {
     span.finish();
   }
 
+  /**
+   * {@link #webServerSpanViaBuilder}, setting each builder tag by its {@link KnownTags} id: no name
+   * lookup when the tag is recorded, and the ledger stores the id directly.
+   */
+  @Benchmark
+  public void webServerSpanViaBuilderById() {
+    AgentSpan span =
+        tracer
+            .buildSpan(INSTRUMENTATION_NAME, SERVER_OPERATION_NAME)
+            .withTag(KnownTags.COMPONENT_ID, COMPONENT_VALUE)
+            .withTag(KnownTags.SPAN_KIND_ID, Tags.SPAN_KIND_SERVER)
+            .withTag(KnownTags.HTTP_METHOD_ID, HTTP_METHOD_VALUE)
+            .withTag(KnownTags.HTTP_ROUTE_ID, HTTP_ROUTE_VALUE)
+            .withTag(KnownTags.HTTP_URL_ID, HTTP_URL_VALUE)
+            .withTag(KnownTags.HTTP_STATUS_CODE_ID, HTTP_STATUS_VALUE)
+            .withTag(KnownTags.PEER_PORT_ID, PEER_PORT_VALUE)
+            .start();
+    span.finish();
+  }
+
   /** JDBC/DB-client-shaped span: create -> set the typical DB known tags (9) -> finish. */
   @Benchmark
   public void jdbcClientSpan() {

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

@@ -43,6 +43,7 @@
 import datadog.trace.api.EndpointTracker;
 import datadog.trace.api.IdGenerationStrategy;
 import datadog.trace.api.InstrumenterConfig;
+import datadog.trace.api.KnownTagCodec;
 import datadog.trace.api.Pair;
 import datadog.trace.api.TagMap;
 import datadog.trace.api.TraceConfig;
@@ -2075,6 +2076,24 @@ public final CoreSpanBuilder withTag(final String tag, final Object value) {
       return this;
     }
 
+    @Override
+    public final CoreSpanBuilder withTag(final long tagId, final Object value) {
+      if (!KnownTagCodec.isKnown(tagId)) {
+        return this;
+      }
+      TagMap.Ledger tagLedger = this.tagLedger;
+      if (tagLedger == null) {
+        this.tagLedger = tagLedger = TagMap.ledger();
+      }
+      if (value == null) {
+        // see withTag(String, Object): only a removal of a tag this builder set is recorded
+        tagLedger.smartRemove(tagId);
+      } else {
+        tagLedger.set(tagId, value);
+      }
+      return this;
+    }
+
     @Override
     public final <T> AgentTracer.SpanBuilder withRequestContextData(
         RequestContextSlot slot, T data) {

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

@@ -1322,22 +1322,41 @@ void setAllTags(final TagMap.Ledger ledger) {
     }
 
     synchronized (unsafeTags) {
-      for (final TagMap.EntryChange entryChange : ledger) {
-        String tag = entryChange.tag();
-        if (entryChange.isRemoval()) {
-          if (tagEquals(tag, Tags.SPAN_KIND)) {
-            // mirror removeTag(String): keep the cached ordinal in sync with unsafeTags
-            spanKindOrdinal = SPAN_KIND_UNSET;
-          }
-          unsafeTags.remove(tag);
-        } else {
-          TagMap.Entry entry = (TagMap.Entry) entryChange;
+      // Interception needs an intercepted id in the ledger, or a split-by-tags entry, which is
+      // config rather than an id bit. Without either, every change goes straight to storage.
+      if (ledger.hasInterceptedTags() || tagInterceptor.hasSplitServiceTags()) {
+        ledger.forEach(this, DDSpanContext::interceptOrApplyLedgerChange);
+      } else {
+        ledger.forEach(this, DDSpanContext::applyLedgerChange);
+      }
+    }
+  }
 
-          if (!tagInterceptor.interceptTag(this, entry)) {
-            unsafeTags.set(entry);
-          }
-        }
+  /** Call while holding the {@code unsafeTags} lock. */
+  private static void interceptOrApplyLedgerChange(
+      DDSpanContext ctx, TagMap.EntryChangeReader change) {
+    if (change.isRemoval() || !ctx.tagInterceptor.interceptTag(ctx, change)) {
+      applyLedgerChange(ctx, change);
+    }
+  }
+
+  /** Call while holding the {@code unsafeTags} lock. */
+  private static void applyLedgerChange(DDSpanContext ctx, TagMap.EntryChangeReader change) {
+    long tagId = change.tagId();
+    if (change.isRemoval()) {
+      if (tagId == KnownTags.SPAN_KIND_ID) {
+        // mirror removeTag(String): keep the cached ordinal in sync with unsafeTags
+        ctx.spanKindOrdinal = SPAN_KIND_UNSET;
       }
+      if (tagId != 0) {
+        ctx.unsafeTags.getAndRemove(tagId);
+      } else {
+        ctx.unsafeTags.remove(change.tag());
+      }
+    } else if (tagId != 0) {
+      ctx.unsafeTags.internals().setKnown(tagId, change.objectValue());
+    } else {
+      ctx.unsafeTags.set(change);
     }
   }
 

dd-trace-core/src/main/java/datadog/trace/core/taginterceptor/TagInterceptor.java

@@ -61,6 +61,9 @@ public class TagInterceptor {
   /** split-by-tags entries naming custom tags; null when there are none. */
   private final Set<String> splitServiceCustomNames;
 
+  /** Whether any split-by-tags entry is configured; see {@link #hasSplitServiceTags}. */
+  private final boolean hasSplitServiceTags;
+
   private final boolean shouldSet404ResourceName;
   private final boolean shouldSetUrlResourceAsName;
   private final boolean jeeSplitByDeployment;
@@ -84,6 +87,7 @@ public TagInterceptor(
     this.inferredServiceName = inferredServiceName;
     this.splitServiceSerials = knownTagSerials(splitServiceTags);
     this.splitServiceCustomNames = customTagNames(splitServiceTags);
+    this.hasSplitServiceTags = !splitServiceTags.isEmpty();
     this.ruleFlags = ruleFlags;
     splitByServletContext = isSplitServiceTag(SERVLET_CONTEXT_ID);
 
@@ -129,6 +133,15 @@ private static Set<String> customTagNames(Set<String> names) {
     return custom;
   }
 
+  /**
+   * Whether any split-by-tags entry is configured. split-by-tags is tracer config, not an id bit,
+   * so a batch of tags needs no interception only when this is false and no id in the batch has
+   * {@link KnownTagCodec#INTERCEPTED}.
+   */
+  public boolean hasSplitServiceTags() {
+    return hasSplitServiceTags;
+  }
+
   /** Requires a known id, whose serial is always in range of the table. */
   private boolean isSplitServiceTag(long tagId) {
     return splitServiceSerials[KnownTagCodec.serialNum(tagId)];

dd-trace-core/src/test/java/datadog/trace/core/CoreSpanBuilderWithTagByIdTest.java

@@ -0,0 +1,75 @@
+package datadog.trace.core;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import datadog.trace.api.KnownTagCodec;
+import datadog.trace.api.KnownTags;
+import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
+import datadog.trace.common.writer.ListWriter;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/** {@code SpanBuilder.withTag(long, ...)}: a builder tag set by id lands like one set by name. */
+class CoreSpanBuilderWithTagByIdTest extends DDCoreJavaSpecification {
+  private CoreTracer tracer;
+
+  @BeforeEach
+  void setup() {
+    tracer = tracerBuilder().writer(new ListWriter()).build();
+  }
+
+  @AfterEach
+  void tearDown() {
+    tracer.close();
+  }
+
+  @Test
+  void aTagSetByIdIsStoredUnderItsName() {
+    AgentSpan span =
+        tracer
+            .buildSpan("datadog", "op")
+            .withTag(KnownTags.HTTP_ROUTE_ID, "/users/{id}")
+            .withTag(KnownTags.HTTP_STATUS_CODE_ID, 200)
+            .withTag("my.custom.tag", "x")
+            .start();
+
+    assertEquals("/users/{id}", span.getTag(KnownTags.HTTP_ROUTE_NAME));
+    assertEquals(200, span.getTag(KnownTags.HTTP_STATUS_CODE_NAME));
+    assertEquals("x", span.getTag("my.custom.tag"));
+    span.finish();
+  }
+
+  @Test
+  void anInterceptedTagSetByIdIsRouted() {
+    AgentSpan span =
+        tracer.buildSpan("datadog", "op").withTag(KnownTags.RESOURCE_NAME_ID, "GET /x").start();
+
+    assertEquals("GET /x", span.getResourceName().toString());
+    span.finish();
+  }
+
+  @Test
+  void aNullValueRemovesOnlyATagTheBuilderSet() {
+    AgentSpan span =
+        tracer
+            .buildSpan("datadog", "op")
+            .withTag(KnownTags.HTTP_ROUTE_ID, "/users")
+            .withTag(KnownTags.HTTP_ROUTE_ID, null)
+            .withTag(KnownTags.HTTP_METHOD_ID, null)
+            .start();
+
+    assertNull(span.getTag(KnownTags.HTTP_ROUTE_NAME));
+    span.finish();
+  }
+
+  @Test
+  void anUnknownIdIsIgnored() {
+    AgentSpan span =
+        tracer.buildSpan("datadog", "op").withTag(KnownTagCodec.makeTagId(9999), "x").start();
+
+    assertNull(span.getTag("x"));
+    span.finish();
+  }
+}