Wire tag-id setTag into DDSpanContext (slice A): stored + intercepted paths

Connect the tag-id fast path into the span layer:
- CoreTagIds: hand-assigned tag-id constants for core tags + a KnownTags.Resolver
  that registers on class init (so id resolution is live before the first span).
  PARENT_ID is a stored tag (serial >= FIRST_STORED_SERIAL); ERROR is a reserved
  virtual tag (serial < FIRST_STORED_SERIAL, fieldPos sentinel so it never slots).
- DDSpanContext.setTag(long, Object): O(1) range-check routing — reserved tags go
  to the interceptor via id dispatch, stored tags go straight to the map by id
  (slot/bucket), bypassing the per-tag interceptor string switch.
- TagInterceptor.interceptTag(span, long, value): int-switch on globalSerial
  (ERROR), falling back to the string path by resolved name for other reserved ids.
- Migrate the constructor's PARENT_ID set to the id; drop the now-unused import.

Tests: PARENT_ID set-by-id is findable/serialized as _dd.parent_id; ERROR set-by-id
sets the error flag and is not stored. Existing DDSpanContext/serialization/tracer/
interceptor suites pass with the resolver now registered tracer-wide.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dougqh

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

@@ -0,0 +1,65 @@
+package datadog.trace.core;
+
+import datadog.trace.api.DDTags;
+import datadog.trace.api.KnownTags;
+import datadog.trace.bootstrap.instrumentation.api.Tags;
+
+/**
+ * Hand-assigned tag-id constants for tracer-core tags, plus the {@link KnownTags.Resolver} that
+ * resolves them.
+ *
+ * <p>Reserved serials {@code [1, KnownTags.FIRST_STORED_SERIAL)} name "virtual" tags handled by the
+ * tag interceptor / span fields and are NOT stored in the {@code TagMap}; their {@code fieldPos} is
+ * a sentinel ({@link #RESERVED_FIELD_POS}) that is out of slot range, so any incidental store
+ * routes to the hash buckets rather than a positional slot. Serials {@code >= FIRST_STORED_SERIAL}
+ * name stored tags that slot/bucket normally.
+ *
+ * <p>The resolver registers on class initialization, so simply referencing any constant here makes
+ * tag-id resolution live before the first span is built.
+ */
+public final class CoreTagIds {
+  // sentinel fieldPos for reserved (non-stored) tags: >= TagMap KNOWN_ENTRIES_CAPACITY, so set()
+  // can never place them in a positional slot
+  static final int RESERVED_FIELD_POS = 0xFFFF;
+
+  // ---- reserved / virtual (tag-interceptor handled, not stored) ----
+  public static final int ERROR_SERIAL = 1;
+  public static final long ERROR = KnownTags.tagId(ERROR_SERIAL, RESERVED_FIELD_POS, Tags.ERROR);
+
+  // ---- stored (slotted / bucketed) ----
+  public static final int PARENT_ID_SERIAL = KnownTags.FIRST_STORED_SERIAL;
+  public static final long PARENT_ID = KnownTags.tagId(PARENT_ID_SERIAL, 0, DDTags.PARENT_ID);
+
+  static final KnownTags.Resolver RESOLVER =
+      new KnownTags.Resolver() {
+        @Override
+        public String nameOf(long tagId) {
+          switch (KnownTags.globalSerial(tagId)) {
+            case ERROR_SERIAL:
+              return Tags.ERROR;
+            case PARENT_ID_SERIAL:
+              return DDTags.PARENT_ID;
+            default:
+              return null;
+          }
+        }
+
+        @Override
+        public long keyOf(String name) {
+          switch (name) {
+            case Tags.ERROR:
+              return ERROR;
+            case DDTags.PARENT_ID:
+              return PARENT_ID;
+            default:
+              return 0L;
+          }
+        }
+      };
+
+  static {
+    KnownTags.register(RESOLVER);
+  }
+
+  private CoreTagIds() {}
+}

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

@@ -1,6 +1,5 @@
 package datadog.trace.core;
 
-import static datadog.trace.api.DDTags.PARENT_ID;
 import static datadog.trace.api.DDTags.SPAN_LINKS;
 import static datadog.trace.api.cache.RadixTreeCache.HTTP_STATUSES;
 import static datadog.trace.bootstrap.instrumentation.api.ErrorPriorities.UNSET;
@@ -11,6 +10,7 @@
 import datadog.trace.api.DDTags;
 import datadog.trace.api.DDTraceId;
 import datadog.trace.api.Functions;
+import datadog.trace.api.KnownTags;
 import datadog.trace.api.ProcessTags;
 import datadog.trace.api.TagMap;
 import datadog.trace.api.cache.DDCache;
@@ -385,7 +385,7 @@ public DDSpanContext(
     if (samplingPriority != PrioritySampling.UNSET) {
       setSamplingPriority(samplingPriority, SamplingMechanism.UNKNOWN);
     }
-    setTag(PARENT_ID, this.propagationTags.getLastParentId());
+    setTag(CoreTagIds.PARENT_ID, this.propagationTags.getLastParentId());
   }
 
   @Override
@@ -901,6 +901,33 @@ public void setTag(final String tag, final String value) {
     }
   }
 
+  /**
+   * Sets a tag by its generated tag id. Reserved "virtual" tags (interceptor-handled, not stored)
+   * are routed to the interceptor via an id dispatch; stored tags go straight to the map (slot or
+   * bucket) keyed by id, bypassing the per-tag interceptor string switch. The id classification is
+   * a single range check (see {@link KnownTags#isReserved}).
+   */
+  public void setTag(final long tagId, final Object value) {
+    if (null == value) {
+      String name = KnownTags.nameOf(tagId);
+      if (name != null) {
+        removeTag(name);
+      }
+      return;
+    }
+    if (KnownTags.isReserved(tagId)) {
+      if (!tagInterceptor.interceptTag(this, tagId, value)) {
+        synchronized (unsafeTags) {
+          unsafeTags.set(tagId, value);
+        }
+      }
+    } else {
+      synchronized (unsafeTags) {
+        unsafeTags.set(tagId, value);
+      }
+    }
+  }
+
   public void setTag(TagMap.EntryReader entry) {
     if (entry == null) {
       return;

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

@@ -24,6 +24,7 @@
 import datadog.trace.api.Config;
 import datadog.trace.api.ConfigDefaults;
 import datadog.trace.api.DDTags;
+import datadog.trace.api.KnownTags;
 import datadog.trace.api.Pair;
 import datadog.trace.api.TagMap;
 import datadog.trace.api.config.GeneralConfig;
@@ -36,6 +37,7 @@
 import datadog.trace.bootstrap.instrumentation.api.Tags;
 import datadog.trace.bootstrap.instrumentation.api.URIUtils;
 import datadog.trace.bootstrap.instrumentation.api.UTF8BytesString;
+import datadog.trace.core.CoreTagIds;
 import datadog.trace.core.DDSpanContext;
 import java.net.URI;
 import java.util.Map;
@@ -131,6 +133,22 @@ public boolean needsIntercept(String tag) {
     }
   }
 
+  /**
+   * Id-dispatched variant of {@link #interceptTag(DDSpanContext, String, Object)}: switches on the
+   * tagId's globalSerial (an int) instead of the tag-name string. Used by {@code
+   * DDSpanContext.setTag(long, Object)} for reserved (virtual) tags. Falls back to the string path
+   * for any reserved id without a dedicated case.
+   */
+  public boolean interceptTag(DDSpanContext span, long tagId, Object value) {
+    switch (KnownTags.globalSerial(tagId)) {
+      case CoreTagIds.ERROR_SERIAL:
+        return interceptError(span, value);
+      default:
+        String name = KnownTags.nameOf(tagId);
+        return name != null && interceptTag(span, name, value);
+    }
+  }
+
   public boolean interceptTag(DDSpanContext span, String tag, Object value) {
     switch (tag) {
       case DDTags.RESOURCE_NAME:

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

@@ -24,6 +24,7 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -70,6 +71,33 @@ void setup() {
             .build();
   }
 
+  @Test
+  void setTagById_storedTagResolvesByName() {
+    AgentSpan span = tracer.buildSpan("datadog", "fakeOperation").start();
+    DDSpanContext context = (DDSpanContext) span.context();
+
+    // PARENT_ID is a stored tag (serial >= FIRST_STORED_SERIAL): set by id, it lands in the map and
+    // is findable / serialized by its resolved name.
+    context.setTag(CoreTagIds.PARENT_ID, "p123");
+    assertEquals("p123", context.getTags().get(DDTags.PARENT_ID));
+
+    span.finish();
+  }
+
+  @Test
+  void setTagById_reservedTagIsIntercepted() {
+    AgentSpan span = tracer.buildSpan("datadog", "fakeOperation").start();
+    DDSpanContext context = (DDSpanContext) span.context();
+
+    // ERROR is a reserved (virtual) tag: setting it by id dispatches through the interceptor
+    // (id-keyed), which sets the error flag and does NOT store an "error" tag.
+    context.setTag(CoreTagIds.ERROR, true);
+    assertTrue(context.getErrorFlag());
+    assertNull(context.getTags().get(Tags.ERROR));
+
+    span.finish();
+  }
+
   @ParameterizedTest
   @ValueSource(strings = {DDTags.SERVICE_NAME, DDTags.RESOURCE_NAME, DDTags.SPAN_TYPE, "some.tag"})
   void nullValuesForTagsDeleteExistingTags(String name) throws Exception {