Introduce TagStore for eager tag post-processors (dense store - part 3)

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

@@ -19,6 +19,7 @@
 import datadog.trace.api.KnownTags;
 import datadog.trace.api.ProcessTags;
 import datadog.trace.api.TagMap;
+import datadog.trace.api.TagStore;
 import datadog.trace.api.cache.DDCache;
 import datadog.trace.api.cache.DDCaches;
 import datadog.trace.api.config.TracerConfig;
@@ -68,7 +69,7 @@
  * the associated Span instance
  */
 public class DDSpanContext
-    implements AgentSpanContext, RequestContext, TraceSegment, ProfilerContext {
+    implements AgentSpanContext, RequestContext, TraceSegment, ProfilerContext, TagStore {
   private static final Logger log = LoggerFactory.getLogger(DDSpanContext.class);
 
   public static final String PRIORITY_SAMPLING_KEY = "_sampling_priority_v1";
@@ -1395,6 +1396,50 @@ Object getTag(final String key) {
     }
   }
 
+  /*
+   * TagStore: the span's tags as stored, loaded and stored with no locking, interception or
+   * interpretation -- the storage beneath the span, as a Map was beneath a TagMap. A span isn't
+   * conceptually a TagStore. It implements one so post-processing is handed the span's storage
+   * without allocating: a wrapper would be free only if escape analysis removed it, and the
+   * post-processor chain's dispatch loop defeats that. Callers hold the span's tag lock, as
+   * post-processing does.
+   */
+
+  @Override
+  public Object load(String tag) {
+    return unsafeTags.getObject(tag);
+  }
+
+  @Override
+  public String loadString(String tag) {
+    return unsafeTags.getString(tag);
+  }
+
+  @Override
+  public Object load(long tagId) {
+    return unsafeTags.load(tagId);
+  }
+
+  @Override
+  public String loadString(long tagId) {
+    return unsafeTags.loadString(tagId);
+  }
+
+  @Override
+  public void store(String tag, Object value) {
+    unsafeTags.set(tag, value);
+  }
+
+  @Override
+  public void store(long tagId, Object value) {
+    unsafeTags.set(tagId, value);
+  }
+
+  @Override
+  public void store(TagMap.EntryReader entry) {
+    unsafeTags.set(entry);
+  }
+
   /**
    * This is not thread-safe and must only be used when it can be guaranteed that the context will
    * not be mutated. This is internal API and must not be exposed to users.
@@ -1500,7 +1545,7 @@ public <T> void setMetaStruct(final String field, final T value) {
 
   void earlyProcessTags(AppendableSpanLinks links) {
     synchronized (unsafeTags) {
-      TagsPostProcessorFactory.eagerProcessor().processTags(unsafeTags, this, links);
+      TagsPostProcessorFactory.eagerProcessor().processTags(this, this, links);
     }
   }
 

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

@@ -0,0 +1,24 @@
+package datadog.trace.core.tagprocessor;
+
+import datadog.trace.api.TagStore;
+import datadog.trace.bootstrap.instrumentation.api.AppendableSpanLinks;
+import datadog.trace.core.DDSpanContext;
+import java.util.Objects;
+import javax.annotation.Nonnull;
+
+/** Runs eager post-processors in order. */
+public final class EagerPostProcessorChain extends EagerTagsPostProcessor {
+  private final EagerTagsPostProcessor[] chain;
+
+  public EagerPostProcessorChain(@Nonnull final EagerTagsPostProcessor... processors) {
+    chain = Objects.requireNonNull(processors);
+  }
+
+  @Override
+  public void processTags(
+      TagStore unsafeTags, DDSpanContext spanContext, AppendableSpanLinks spanLinks) {
+    for (final EagerTagsPostProcessor processor : chain) {
+      processor.processTags(unsafeTags, spanContext, spanLinks);
+    }
+  }
+}

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

@@ -0,0 +1,23 @@
+package datadog.trace.core.tagprocessor;
+
+import datadog.trace.api.TagStore;
+import datadog.trace.bootstrap.instrumentation.api.AppendableSpanLinks;
+import datadog.trace.core.DDSpanContext;
+
+/**
+ * A tag post-processor run on the application thread as a span finishes. It works on the span's
+ * tags as stored, through a {@link TagStore}, rather than a {@code TagMap} the span would have to
+ * build for it. The span passes itself as that store, which allocates nothing.
+ */
+public abstract class EagerTagsPostProcessor {
+  /**
+   * Processes the span's tags.
+   *
+   * @param unsafeTags the span's tags as stored, to read and write; the caller holds the span's tag
+   *     lock
+   * @param spanContext the span, for its other properties
+   * @param spanLinks the span's links
+   */
+  public abstract void processTags(
+      TagStore unsafeTags, DDSpanContext spanContext, AppendableSpanLinks spanLinks);
+}

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

@@ -1,10 +1,10 @@
 package datadog.trace.core.tagprocessor;
 
+import static datadog.trace.api.KnownTags.HTTP_METHOD_ID;
+import static datadog.trace.api.KnownTags.HTTP_ROUTE_ID;
 import static datadog.trace.bootstrap.instrumentation.api.OtelHttpSemantics.urlOrPath;
-import static datadog.trace.bootstrap.instrumentation.api.Tags.HTTP_METHOD;
-import static datadog.trace.bootstrap.instrumentation.api.Tags.HTTP_ROUTE;
 
-import datadog.trace.api.TagMap;
+import datadog.trace.api.TagStore;
 import datadog.trace.api.endpoint.EndpointResolver;
 import datadog.trace.api.internal.VisibleForTesting;
 import datadog.trace.bootstrap.instrumentation.api.AppendableSpanLinks;
@@ -30,7 +30,7 @@
  *   <li>If {@code alwaysSimplifiedEndpoint=true}, always compute from URL regardless of route
  * </ul>
  */
-public class HttpEndpointPostProcessor extends TagsPostProcessor {
+public class HttpEndpointPostProcessor extends EagerTagsPostProcessor {
   private static final Logger log = LoggerFactory.getLogger(HttpEndpointPostProcessor.class);
 
   private final EndpointResolver endpointResolver;
@@ -55,18 +55,18 @@ public HttpEndpointPostProcessor() {
 
   @Override
   public void processTags(
-      TagMap unsafeTags, DDSpanContext spanContext, AppendableSpanLinks spanLinks) {
+      TagStore unsafeTags, DDSpanContext spanContext, AppendableSpanLinks spanLinks) {
     if (!endpointResolver.isEnabled()) {
       log.debug("EndpointResolver is not enabled, skipping HTTP endpoint post processing");
       return;
     }
 
-    if (unsafeTags.getObject(HTTP_METHOD) == null) {
+    if (unsafeTags.load(HTTP_METHOD_ID) == null) {
       return;
     }
 
     try {
-      String httpRoute = unsafeTags.getString(HTTP_ROUTE);
+      String httpRoute = unsafeTags.loadString(HTTP_ROUTE_ID);
       Object httpUrl = urlOrPath(unsafeTags);
       endpointResolver.resolveEndpoint(
           unsafeTags, httpRoute, httpUrl == null ? null : httpUrl.toString());

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

@@ -1,16 +1,17 @@
 package datadog.trace.core.tagprocessor;
 
-import static datadog.trace.bootstrap.instrumentation.api.Tags.VERSION;
+import static datadog.trace.api.KnownTags.DD_BASE_SERVICE_ID;
+import static datadog.trace.api.KnownTags.VERSION_ID;
 
-import datadog.trace.api.DDTags;
 import datadog.trace.api.TagMap;
+import datadog.trace.api.TagStore;
 import datadog.trace.bootstrap.instrumentation.api.AppendableSpanLinks;
 import datadog.trace.bootstrap.instrumentation.api.UTF8BytesString;
 import datadog.trace.core.DDSpanContext;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
-public final class InternalTagsAdder extends TagsPostProcessor {
+public final class InternalTagsAdder extends EagerTagsPostProcessor {
   private final UTF8BytesString ddService;
 
   // Prebuilt once to avoid per-span Entry allocation.
@@ -19,30 +20,30 @@ public final class InternalTagsAdder extends TagsPostProcessor {
 
   public InternalTagsAdder(@Nonnull final String ddService, @Nullable final String version) {
     this.ddService = UTF8BytesString.create(ddService);
-    this.baseServiceEntry = TagMap.Entry.create(DDTags.BASE_SERVICE, this.ddService);
+    this.baseServiceEntry = TagMap.Entry.create(DD_BASE_SERVICE_ID, this.ddService);
     this.versionEntry =
         version != null && !version.isEmpty()
-            ? TagMap.Entry.create(VERSION, UTF8BytesString.create(version))
+            ? TagMap.Entry.create(VERSION_ID, UTF8BytesString.create(version))
             : null;
   }
 
   @Override
   public void processTags(
-      TagMap unsafeTags, DDSpanContext spanContext, AppendableSpanLinks spanLinks) {
+      TagStore unsafeTags, DDSpanContext spanContext, AppendableSpanLinks spanLinks) {
     if (spanContext == null) {
       return;
     }
 
     if (!ddService.toString().equalsIgnoreCase(spanContext.getServiceName())) {
       if (baseServiceEntry != null) {
         // service name != DD_SERVICE
-        unsafeTags.set(baseServiceEntry);
+        unsafeTags.store(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 (versionEntry != null && !unsafeTags.containsKey(VERSION)) {
-        unsafeTags.set(versionEntry);
+      if (versionEntry != null && unsafeTags.load(VERSION_ID) == null) {
+        unsafeTags.store(versionEntry);
       }
     }
   }

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

@@ -1,18 +1,19 @@
 package datadog.trace.core.tagprocessor;
 
+import static datadog.trace.api.KnownTags.DD_PEER_SERVICE_REMAPPED_FROM_ID;
+import static datadog.trace.api.KnownTags.PEER_SERVICE_ID;
+
 import datadog.trace.api.Config;
-import datadog.trace.api.DDTags;
-import datadog.trace.api.TagMap;
+import datadog.trace.api.TagStore;
 import datadog.trace.api.internal.VisibleForTesting;
 import datadog.trace.api.naming.NamingSchema;
 import datadog.trace.api.naming.SpanNaming;
 import datadog.trace.bootstrap.instrumentation.api.AppendableSpanLinks;
-import datadog.trace.bootstrap.instrumentation.api.Tags;
 import datadog.trace.core.DDSpanContext;
 import java.util.Map;
 import javax.annotation.Nonnull;
 
-public final class PeerServiceCalculator extends TagsPostProcessor {
+public final class PeerServiceCalculator extends EagerTagsPostProcessor {
   private final NamingSchema.ForPeerService peerServiceNaming;
 
   private final Map<String, String> peerServiceMapping;
@@ -34,8 +35,8 @@ public PeerServiceCalculator() {
 
   @Override
   public void processTags(
-      TagMap unsafeTags, DDSpanContext spanContext, AppendableSpanLinks spanLinks) {
-    Object peerService = unsafeTags.getObject(Tags.PEER_SERVICE);
+      TagStore unsafeTags, DDSpanContext spanContext, AppendableSpanLinks spanLinks) {
+    Object peerService = unsafeTags.load(PEER_SERVICE_ID);
     // the user set it
     if (peerService != null) {
       if (canRemap) {
@@ -46,18 +47,18 @@ public void processTags(
       // calculate the defaults (if any)
       peerServiceNaming.tags(unsafeTags);
       // only remap if the mapping is not empty (saves one get)
-      remapPeerService(unsafeTags, canRemap ? unsafeTags.getObject(Tags.PEER_SERVICE) : null);
+      remapPeerService(unsafeTags, canRemap ? unsafeTags.load(PEER_SERVICE_ID) : null);
       return;
     }
     // we have no peer.service and we do not compute defaults. Leave the map untouched
   }
 
-  private void remapPeerService(TagMap unsafeTags, Object value) {
+  private void remapPeerService(TagStore unsafeTags, Object value) {
     if (value != null) {
       String mapped = peerServiceMapping.get(value);
       if (mapped != null) {
-        unsafeTags.put(Tags.PEER_SERVICE, mapped);
-        unsafeTags.put(DDTags.PEER_SERVICE_REMAPPED_FROM, value);
+        unsafeTags.store(PEER_SERVICE_ID, mapped);
+        unsafeTags.store(DD_PEER_SERVICE_REMAPPED_FROM_ID, value);
       }
     }
   }

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

@@ -9,11 +9,11 @@ public final class TagsPostProcessorFactory {
   private static boolean addRemoteHostname = true;
 
   private static class Lazy {
-    private static TagsPostProcessor eagerProcessor = createEagerChain();
+    private static EagerTagsPostProcessor eagerProcessor = createEagerChain();
     private static TagsPostProcessor lazyProcessor = createLazyChain();
 
-    private static TagsPostProcessor createEagerChain() {
-      final List<TagsPostProcessor> processors = new ArrayList<>(3);
+    private static EagerTagsPostProcessor createEagerChain() {
+      final List<EagerTagsPostProcessor> processors = new ArrayList<>(3);
       processors.add(new PeerServiceCalculator());
       if (addInternalTags) {
         processors.add(
@@ -24,7 +24,7 @@ private static TagsPostProcessor createEagerChain() {
       if (Config.get().isTraceResourceRenamingEnabled()) {
         processors.add(new HttpEndpointPostProcessor());
       }
-      return new PostProcessorChain(processors.toArray(new TagsPostProcessor[0]));
+      return new EagerPostProcessorChain(processors.toArray(new EagerTagsPostProcessor[0]));
     }
 
     private static TagsPostProcessor createLazyChain() {
@@ -54,7 +54,7 @@ private static TagsPostProcessor createLazyChain() {
     }
   }
 
-  public static TagsPostProcessor eagerProcessor() {
+  public static EagerTagsPostProcessor eagerProcessor() {
     return Lazy.eagerProcessor;
   }