Reuse SpanBuilder within a Thread

components/environment/src/main/java/datadog/environment/JavaVersion.java

@@ -87,6 +87,10 @@ public boolean is(int major, int minor, int update) {
     return this.major == major && this.minor == minor && this.update == update;
   }
 
+  public boolean isAtLeast(int major) {
+    return isAtLeast(major, 0, 0);
+  }
+
   public boolean isAtLeast(int major, int minor, int update) {
     return isAtLeast(this.major, this.minor, this.update, major, minor, update);
   }

components/environment/src/main/java/datadog/environment/ThreadUtils.java

@@ -0,0 +1,85 @@
+package datadog.environment;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+
+/**
+ * Helper class for working with Threads
+ *
+ * <p>Uses feature detection and provides static helpers to work with different versions of Java
+ *
+ * <p>This class is designed to use MethodHandles that constant propagate to minimize the overhead
+ */
+public final class ThreadUtils {
+  static final MethodHandle H_IS_VIRTUAL = lookupIsVirtual();
+  static final MethodHandle H_ID = lookupId();
+
+  private ThreadUtils() {}
+
+  /** Provides the best id available for the Thread Uses threadId on 19+; getId on older JVMs */
+  public static final long threadId(Thread thread) {
+    try {
+      return (long) H_ID.invoke(thread);
+    } catch (Throwable t) {
+      return 0L;
+    }
+  }
+
+  /** Indicates whether virtual threads are supported on this JVM */
+  public static final boolean supportsVirtualThreads() {
+    return (H_IS_VIRTUAL != null);
+  }
+
+  /** Indicates if the current thread is a virtual thread */
+  public static final boolean isCurrentThreadVirtual() {
+    // H_IS_VIRTUAL will constant propagate -- then dead code eliminate -- and inline as needed
+    try {
+      return (H_IS_VIRTUAL != null) && (boolean) H_IS_VIRTUAL.invoke(Thread.currentThread());
+    } catch (Throwable t) {
+      return false;
+    }
+  }
+
+  /** Indicates if the provided thread is a virtual thread */
+  public static final boolean isVirtual(Thread thread) {
+    // H_IS_VIRTUAL will constant propagate -- then dead code eliminate -- and inline as needed
+    try {
+      return (H_IS_VIRTUAL != null) && (boolean) H_IS_VIRTUAL.invoke(thread);
+    } catch (Throwable t) {
+      return false;
+    }
+  }
+
+  private static final MethodHandle lookupIsVirtual() {
+    try {
+      return MethodHandles.lookup()
+          .findVirtual(Thread.class, "isVirtual", MethodType.methodType(boolean.class));
+    } catch (NoSuchMethodException | IllegalAccessException e) {
+      return null;
+    }
+  }
+
+  private static final MethodHandle lookupId() {
+    MethodHandle threadIdHandle = lookupThreadId();
+    return threadIdHandle != null ? threadIdHandle : lookupGetId();
+  }
+
+  private static final MethodHandle lookupThreadId() {
+    try {
+      return MethodHandles.lookup()
+          .findVirtual(Thread.class, "threadId", MethodType.methodType(long.class));
+    } catch (NoSuchMethodException | IllegalAccessException e) {
+      return null;
+    }
+  }
+
+  private static final MethodHandle lookupGetId() {
+    try {
+      return MethodHandles.lookup()
+          .findVirtual(Thread.class, "getId", MethodType.methodType(long.class));
+    } catch (NoSuchMethodException | IllegalAccessException e) {
+      return null;
+    }
+  }
+}

components/environment/src/test/java/datadog/environment/ThreadUtilsTest.java

@@ -0,0 +1,106 @@
+package datadog.environment;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.jupiter.api.Test;
+
+public class ThreadUtilsTest {
+  @Test
+  public void threadId() throws InterruptedException {
+    Thread thread = new Thread("foo");
+    thread.start();
+    try {
+      // always works on Thread's where getId isn't overridden by child class
+      assertEquals(thread.getId(), ThreadUtils.threadId(thread));
+    } finally {
+      thread.join();
+    }
+  }
+
+  @Test
+  public void supportsVirtualThreads() {
+    assertEquals(
+        JavaVersion.getRuntimeVersion().isAtLeast(21), ThreadUtils.supportsVirtualThreads());
+  }
+
+  @Test
+  public void isVirtualThread_false() throws InterruptedException {
+    Thread thread = new Thread("foo");
+    thread.start();
+    try {
+      assertFalse(ThreadUtils.isVirtual(thread));
+    } finally {
+      thread.join();
+    }
+  }
+
+  @Test
+  public void isCurrentThreadVirtual_false() throws InterruptedException, ExecutionException {
+    ExecutorService executor = Executors.newSingleThreadExecutor();
+    try {
+      assertFalse(executor.submit(() -> ThreadUtils.isCurrentThreadVirtual()).get());
+    } finally {
+      executor.shutdown();
+    }
+  }
+
+  @Test
+  public void isVirtualThread_true() throws InterruptedException {
+    if (!ThreadUtils.supportsVirtualThreads()) return;
+
+    Thread vThread = startVirtualThread(() -> {});
+    try {
+      assertTrue(ThreadUtils.isVirtual(vThread));
+    } finally {
+      vThread.join();
+    }
+  }
+
+  @Test
+  public void isCurrentThreadVirtual_true() throws InterruptedException {
+    if (!ThreadUtils.supportsVirtualThreads()) return;
+
+    AtomicBoolean result = new AtomicBoolean();
+
+    Thread vThread =
+        startVirtualThread(
+            () -> {
+              result.set(ThreadUtils.isCurrentThreadVirtual());
+            });
+
+    vThread.join();
+    assertTrue(result.get());
+  }
+
+  /*
+   * Should only be called on JVMs that support virtual threads
+   */
+  static final Thread startVirtualThread(Runnable runnable) {
+    MethodHandle h_startVThread;
+    try {
+      h_startVThread =
+          MethodHandles.lookup()
+              .findStatic(
+                  Thread.class,
+                  "startVirtualThread",
+                  MethodType.methodType(Runnable.class, Thread.class));
+    } catch (NoSuchMethodException | IllegalAccessException e) {
+      throw new IllegalStateException(e);
+    }
+
+    try {
+      return (Thread) h_startVThread.invoke(runnable);
+    } catch (Throwable e) {
+      throw new IllegalStateException(e);
+    }
+  }
+}

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

@@ -110,6 +110,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/jmh/java/datadog/trace/core/CoreTracerBenchmark.java

@@ -0,0 +1,49 @@
+package datadog.trace.core;
+
+import static java.util.concurrent.TimeUnit.MICROSECONDS;
+
+import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Threads;
+import org.openjdk.jmh.annotations.Warmup;
+
+/**
+ * Benchmark of key operations of the CoreTracer
+ *
+ * <p>NOTE: This is a multi-threaded benchmark; single threaded benchmarks don't accurately reflect
+ * some of the optimizations.
+ *
+ * <p>Use -t 1, if you'd like to do a single threaded run
+ */
+@State(Scope.Benchmark)
+@Warmup(iterations = 3)
+@Measurement(iterations = 5)
+@BenchmarkMode(Mode.Throughput)
+@Threads(8)
+@OutputTimeUnit(MICROSECONDS)
+@Fork(value = 1)
+public class CoreTracerBenchmark {
+  static final CoreTracer TRACER = CoreTracer.builder().build();
+
+  @Benchmark
+  public AgentSpan startSpan() {
+    return TRACER.startSpan("foo", "bar");
+  }
+
+  @Benchmark
+  public AgentSpan buildSpan() {
+    return TRACER.buildSpan("foo", "bar").start();
+  }
+
+  @Benchmark
+  public AgentSpan singleSpanBuilder() {
+    return TRACER.singleSpanBuilder("foo", "bar").start();
+  }
+}