Pre-build id-bearing shared Entries for common tags (InternalTagsAdder)

Handle the per-span "common" tags (base.service / version) via the tag-id fast
path. These values are fixed for the tracer's life, so build their TagMap.Entry
once and share across every span (Entry is immutable + safe to share) — dropping
InternalTagsAdder's per-span Entry allocation to zero (cf. PR #11555, the
string-keyed precursor), and making the entries tag-id-bearing so they also land
in their positional slot.

- TagMap.Entry.create(long, Object)/create(long, CharSequence): tag-id keyed,
  null/empty-rejecting factories mirroring the String create().
- CoreTagIds.BASE_SERVICE / VERSION (stored range) + resolver entries.
- InternalTagsAdder prebuilds baseServiceEntry/versionEntry in its ctor and
  set()s the shared entry; empty DD_SERVICE early-returns (regression test added).

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

Author: dougqh

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

@@ -30,6 +30,14 @@ public final class CoreTagIds {
   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);
 
+  // common (process-constant) tags added by InternalTagsAdder to ~every span
+  public static final int BASE_SERVICE_SERIAL = KnownTags.FIRST_STORED_SERIAL + 1;
+  public static final long BASE_SERVICE =
+      KnownTags.tagId(BASE_SERVICE_SERIAL, 1, DDTags.BASE_SERVICE);
+
+  public static final int VERSION_SERIAL = KnownTags.FIRST_STORED_SERIAL + 2;
+  public static final long VERSION = KnownTags.tagId(VERSION_SERIAL, 2, Tags.VERSION);
+
   static final KnownTags.Resolver RESOLVER =
       new KnownTags.Resolver() {
         @Override
@@ -39,6 +47,10 @@ public String nameOf(long tagId) {
               return Tags.ERROR;
             case PARENT_ID_SERIAL:
               return DDTags.PARENT_ID;
+            case BASE_SERVICE_SERIAL:
+              return DDTags.BASE_SERVICE;
+            case VERSION_SERIAL:
+              return Tags.VERSION;
             default:
               return null;
           }
@@ -51,6 +63,10 @@ public long keyOf(String name) {
               return ERROR;
             case DDTags.PARENT_ID:
               return PARENT_ID;
+            case DDTags.BASE_SERVICE:
+              return BASE_SERVICE;
+            case Tags.VERSION:
+              return VERSION;
             default:
               return 0L;
           }

dd-trace-core/src/main/java/datadog/trace/core/tagprocessor/InternalTagsAdder.java

@@ -2,37 +2,48 @@
 
 import static datadog.trace.bootstrap.instrumentation.api.Tags.VERSION;
 
-import datadog.trace.api.DDTags;
 import datadog.trace.api.TagMap;
 import datadog.trace.bootstrap.instrumentation.api.AppendableSpanLinks;
 import datadog.trace.bootstrap.instrumentation.api.UTF8BytesString;
+import datadog.trace.core.CoreTagIds;
 import datadog.trace.core.DDSpanContext;
 import javax.annotation.Nullable;
 
 public final class InternalTagsAdder extends TagsPostProcessor {
   private final UTF8BytesString ddService;
-  private final UTF8BytesString version;
+
+  // base.service / version are fixed for the life of the tracer, so their TagMap.Entry objects are
+  // pre-built once and shared across every span (Entry is immutable and safe to share between
+  // maps).
+  // The entries are tag-id-bearing (CoreTagIds), so they also land in their positional slot. null
+  // when the corresponding value is absent/empty. See PR #11555 for the string-keyed precursor.
+  @Nullable private final TagMap.Entry baseServiceEntry;
+  @Nullable private final TagMap.Entry versionEntry;
 
   public InternalTagsAdder(@Nullable final String ddService, @Nullable final String version) {
     this.ddService = ddService != null ? UTF8BytesString.create(ddService) : null;
-    this.version = version != null && !version.isEmpty() ? UTF8BytesString.create(version) : null;
+    this.baseServiceEntry = TagMap.Entry.create(CoreTagIds.BASE_SERVICE, this.ddService);
+    this.versionEntry =
+        version != null && !version.isEmpty()
+            ? TagMap.Entry.create(CoreTagIds.VERSION, UTF8BytesString.create(version))
+            : null;
   }
 
   @Override
   public void processTags(
       TagMap unsafeTags, DDSpanContext spanContext, AppendableSpanLinks spanLinks) {
-    if (spanContext == null || ddService == null) {
+    if (spanContext == null || ddService == null || ddService.length() == 0) {
       return;
     }
 
     if (!ddService.toString().equalsIgnoreCase(spanContext.getServiceName())) {
-      // service name !=  DD_SERVICE
-      unsafeTags.set(DDTags.BASE_SERVICE, ddService);
+      // service name != DD_SERVICE
+      unsafeTags.set(baseServiceEntry);
     } else {
       // as per config consistency, the version tag is added across tracers only if
-      // the service name is DD_SERVICE and version  tag is not manually set
-      if (version != null && !unsafeTags.containsKey(VERSION)) {
-        unsafeTags.set(VERSION, version);
+      // the service name is DD_SERVICE and version tag is not manually set
+      if (versionEntry != null && !unsafeTags.containsKey(VERSION)) {
+        unsafeTags.set(versionEntry);
       }
     }
   }

dd-trace-core/src/test/java/datadog/trace/core/tagprocessor/InternalTagsAdderTest.java

@@ -14,6 +14,7 @@
 import datadog.trace.test.util.DDJavaSpecification;
 import java.util.Collections;
 import java.util.Objects;
+import org.junit.jupiter.api.Test;
 import org.tabletest.junit.TableTest;
 
 class InternalTagsAdderTest extends DDJavaSpecification {
@@ -67,4 +68,16 @@ void shouldAddVersionWhenDdServiceEqualsServiceNameAndVersionSet(
     verify(spanContext, times(1)).getServiceName();
     assertEquals(expected, Objects.toString(unsafeTags.get(VERSION), null));
   }
+
+  // Regression: empty DD_SERVICE is treated the same as unset — processTags exits early and writes
+  // no tags, regardless of the span's service name (the prebuilt base.service entry is null).
+  @Test
+  void emptyDdServiceWritesNoTags() {
+    InternalTagsAdder adder = new InternalTagsAdder("", "1.0");
+    DDSpanContext spanContext = mock(DDSpanContext.class);
+
+    TagMap tags = TagMap.fromMap(Collections.emptyMap());
+    adder.processTags(tags, spanContext, link -> {});
+    assertTrue(tags.isEmpty());
+  }
 }

internal-api/src/main/java/datadog/trace/api/TagMap.java

@@ -455,6 +455,18 @@ public static final Entry create(String tag, CharSequence value) {
           : TagMap.Entry.newObjectEntry(tag, value);
     }
 
+    /** Tag-id keyed {@link #create(String, Object)}: null value yields null. */
+    public static final Entry create(long tagId, Object value) {
+      return (value == null) ? null : TagMap.Entry.newAnyEntry(tagId, value);
+    }
+
+    /** Tag-id keyed {@link #create(String, CharSequence)}: null/empty value yields null. */
+    public static final Entry create(long tagId, CharSequence value) {
+      return (value == null || value.length() == 0)
+          ? null
+          : TagMap.Entry.newObjectEntry(tagId, value);
+    }
+
     public static final Entry create(String tag, boolean value) {
       return TagMap.Entry.newBooleanEntry(tag, value);
     }