Reuse SpanBuilder within a Thread

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

@@ -107,6 +107,7 @@ public final class GeneralConfig {
   public static final String OPTIMIZED_MAP_ENABLED = "optimized.map.enabled";
   public static final String TAG_NAME_UTF8_CACHE_SIZE = "tag.name.utf8.cache.size";
   public static final String TAG_VALUE_UTF8_CACHE_SIZE = "tag.value.utf8.cache.size";
+  public static final String SPAN_BUILDER_REUSE_ENABLED = "span.builder.reuse.enabled";
   public static final String STACK_TRACE_LENGTH_LIMIT = "stack.trace.length.limit";
 
   public static final String SSI_INJECTION_ENABLED = "injection.enabled";

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

@@ -243,6 +243,22 @@ public static CoreTracerBuilder builder() {
 
   private final PropagationTags.Factory propagationTagsFactory;
 
+  // DQH - storing into a static constant, so value will constant propagate and dead code eliminate
+  // the other branch in buildSpan
+  private static final boolean SPAN_BUILDER_REUSE_ENABLED =
+      Config.get().isSpanBuilderReuseEnabled();
+
+  // Cache used by buildSpan - instance so it can capture the CoreTracer
+  private final ThreadLocal<CoreSpanBuilder> tlSpanBuilder =
+      SPAN_BUILDER_REUSE_ENABLED
+          ? new ThreadLocal<CoreSpanBuilder>() {
+            @Override
+            protected CoreSpanBuilder initialValue() {
+              return new CoreSpanBuilder(CoreTracer.this);
+            }
+          }
+          : null;
+
   @Override
   public ConfigSnapshot captureTraceConfig() {
     return dynamicConfig.captureTraceConfig();
@@ -968,7 +984,42 @@ long getTimeWithNanoTicks(long nanoTicks) {
   @Override
   public CoreSpanBuilder buildSpan(
       final String instrumentationName, final CharSequence operationName) {
-    return new CoreSpanBuilder(this, instrumentationName, operationName);
+    return SPAN_BUILDER_REUSE_ENABLED
+        ? this.reuseSpanBuilder(instrumentationName, operationName)
+        : this.createSpanBuilder(instrumentationName, operationName);
+  }
+
+  private CoreSpanBuilder createSpanBuilder(
+      final String instrumentationName, final CharSequence operationName) {
+    CoreSpanBuilder newBuilder = new CoreSpanBuilder(this);
+    newBuilder.reset(instrumentationName, operationName);
+    return newBuilder;
+  }
+
+  private CoreSpanBuilder reuseSpanBuilder(
+      final String instrumentationName, final CharSequence operationName) {
+    // retrieve the thread's typical SpanBuilder and check if it is currently in use
+    CoreSpanBuilder tlSpanBuilder = this.tlSpanBuilder.get();
+    boolean wasReset = tlSpanBuilder.reset(instrumentationName, operationName);
+    if (wasReset) return tlSpanBuilder;
+
+    // TODO: counter for how often the fallback is used?
+    CoreSpanBuilder newSpanBuilder = new CoreSpanBuilder(this);
+    newSpanBuilder.reset(instrumentationName, operationName);
+
+    // DQH - Debated how best to handle the case of someone requesting a CoreSpanBuilder
+    // and then not using it.  Without an ability to replace the cached CoreSpanBuilder,
+    // that case could result in permanently burning the cache for a given thread.
+
+    // That could be solved with additional logic during CoreSpanBuilder#build
+    // that checks to see if the cached CoreSpanBuilder is in use and then replaces it
+    // with the freed CoreSpanBuilder, but that would put extra logic in the common path.
+
+    // Instead of making the release process more complicating, I'm chosing to just
+    // override here when we know we're already in an uncommon path.
+    this.tlSpanBuilder.set(newSpanBuilder);
+
+    return newSpanBuilder;
   }
 
   @Override
@@ -1400,11 +1451,18 @@ private static <K, V> Map<V, K> invertMap(Map<K, V> map) {
   }
 
   /** Spans are built using this builder */
-  public static class CoreSpanBuilder implements AgentTracer.SpanBuilder {
-    private final String instrumentationName;
-    private final CharSequence operationName;
+  /*
+   * To reduce overhead, CoreSpanBuilders are reused.
+   * For simplicity, CoreSpanBuilder isn't thread safe, so CoreSpanBuilders can only be reused within one thread.
+   */
+  public static final class CoreSpanBuilder implements AgentTracer.SpanBuilder {
     private final CoreTracer tracer;
 
+    private boolean inUse = false;
+
+    private String instrumentationName;
+    private CharSequence operationName;
+
     // Builder attributes
     private TagMap.Ledger tagLedger;
     private long timestampMicro;
@@ -1420,13 +1478,32 @@ public static class CoreSpanBuilder implements AgentTracer.SpanBuilder {
     private List<AgentSpanLink> links;
     private long spanId;
 
-    CoreSpanBuilder(
-        final CoreTracer tracer,
-        final String instrumentationName,
-        final CharSequence operationName) {
+    CoreSpanBuilder(CoreTracer tracer) {
+      this.tracer = tracer;
+    }
+
+    boolean reset(String instrumentationName, CharSequence operationName) {
+      if (this.inUse) return false;
+      this.inUse = true;
+
       this.instrumentationName = instrumentationName;
       this.operationName = operationName;
-      this.tracer = tracer;
+
+      if (this.tagLedger != null) this.tagLedger.reset();
+      this.timestampMicro = 0L;
+      this.parent = null;
+      this.serviceName = null;
+      this.resourceName = null;
+      this.errorFlag = false;
+      this.spanType = null;
+      this.ignoreScope = false;
+      this.builderRequestContextDataAppSec = null;
+      this.builderRequestContextDataIast = null;
+      this.builderCiVisibilityContextData = null;
+      this.links = null;
+      this.spanId = 0L;
+
+      return true;
     }
 
     @Override
@@ -1443,6 +1520,8 @@ private DDSpan buildSpan() {
           span.setEndpointTracker(tracker);
         }
       }
+
+      this.inUse = false;
       return span;
     }
 

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

@@ -1233,6 +1233,7 @@ public static String getHostName() {
   private final boolean jdkSocketEnabled;
 
   private final boolean optimizedMapEnabled;
+  private final boolean spanBuilderReuseEnabled;
   private final int tagNameUtf8CacheSize;
   private final int tagValueUtf8CacheSize;
   private final int stackTraceLengthLimit;
@@ -2749,6 +2750,8 @@ PROFILING_DATADOG_PROFILER_ENABLED, isDatadogProfilerSafeInCurrentEnvironment())
 
     this.optimizedMapEnabled =
         configProvider.getBoolean(GeneralConfig.OPTIMIZED_MAP_ENABLED, false);
+    this.spanBuilderReuseEnabled =
+        configProvider.getBoolean(GeneralConfig.SPAN_BUILDER_REUSE_ENABLED, false);
     this.tagNameUtf8CacheSize =
         Math.max(configProvider.getInteger(GeneralConfig.TAG_NAME_UTF8_CACHE_SIZE, 128), 0);
     this.tagValueUtf8CacheSize =
@@ -4474,6 +4477,10 @@ public boolean isOptimizedMapEnabled() {
     return optimizedMapEnabled;
   }
 
+  public boolean isSpanBuilderReuseEnabled() {
+    return spanBuilderReuseEnabled;
+  }
+
   public int getTagNameUtf8CacheSize() {
     return tagNameUtf8CacheSize;
   }