Fixed Virtual thread instrumentation.

Author: AlexeyKuznetsov-DD

dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-1.8/src/main/java/datadog/trace/instrumentation/java/concurrent/executor/ExecutorModule.java

@@ -52,7 +52,11 @@ public Map<String, String> contextStore() {
         RUNNABLE,
         Arrays.asList(
             "datadog.trace.bootstrap.instrumentation.java.concurrent.Wrapper",
-            "datadog.trace.bootstrap.instrumentation.java.concurrent.ComparableRunnable"));
+            "datadog.trace.bootstrap.instrumentation.java.concurrent.ComparableRunnable",
+            // VirtualThread context must be activated on mount/unmount, not on Runnable.run().
+            // If Runnable instrumentation also activates it, the scope can attach to carrier
+            // threads and fight with the dedicated virtual-thread instrumentation.
+            "java.lang.VirtualThread"));
     map.put(
         EXECUTOR,
         Collections.singletonList("org.apache.mina.filter.executor.OrderedThreadPoolExecutor"));

dd-java-agent/instrumentation/java/java-concurrent/java-concurrent-21.0/src/main/java/datadog/trace/instrumentation/java/concurrent/virtualthread/TaskRunnerInstrumentation.java

@@ -4,7 +4,6 @@
 import static datadog.trace.bootstrap.instrumentation.java.concurrent.AdviceUtils.capture;
 import static datadog.trace.bootstrap.instrumentation.java.concurrent.AdviceUtils.endTaskScope;
 import static datadog.trace.bootstrap.instrumentation.java.concurrent.AdviceUtils.startTaskScope;
-import static java.util.Collections.singletonMap;
 import static net.bytebuddy.matcher.ElementMatchers.isConstructor;
 import static net.bytebuddy.matcher.ElementMatchers.isMethod;
 
@@ -15,7 +14,10 @@
 import datadog.trace.bootstrap.InstrumentationContext;
 import datadog.trace.bootstrap.instrumentation.api.AgentScope;
 import datadog.trace.bootstrap.instrumentation.java.concurrent.State;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.RunnableFuture;
 import net.bytebuddy.asm.Advice;
 import net.bytebuddy.asm.Advice.OnMethodEnter;
 import net.bytebuddy.asm.Advice.OnMethodExit;
@@ -44,7 +46,13 @@ public boolean isEnabled() {
 
   @Override
   public Map<String, String> contextStore() {
-    return singletonMap("java.lang.Runnable", State.class.getName());
+    Map<String, String> stores = new HashMap<>(2);
+    stores.put(Runnable.class.getName(), State.class.getName());
+    // TaskRunner may wrap a RunnableFuture that already has captured context.
+    // Expose this store so Construct can reuse that existing state and avoid creating
+    // a second continuation for the same logical task.
+    stores.put(RunnableFuture.class.getName(), State.class.getName());
+    return Collections.unmodifiableMap(stores);
   }
 
   @Override
@@ -55,7 +63,21 @@ public void methodAdvice(MethodTransformer transformer) {
 
   public static final class Construct {
     @OnMethodExit(suppress = Throwable.class)
-    public static void captureScope(@Advice.This Runnable task) {
+    public static void captureScope(
+        @Advice.This Runnable task, @Advice.FieldValue("task") Runnable innerTask) {
+      if (innerTask instanceof RunnableFuture) {
+        // `submit(...)` creates a FutureTask and then wraps it in TaskRunner.
+        // The FutureTask constructor is already instrumented and captures continuation once.
+        // Reuse the same State so we don't capture a second continuation here.
+        State innerState =
+            InstrumentationContext.get(RunnableFuture.class, State.class)
+                .get((RunnableFuture<?>) innerTask);
+        if (innerState != null) {
+          InstrumentationContext.get(Runnable.class, State.class).put(task, innerState);
+          return;
+        }
+      }
+      // Plain execute(Runnable) path where there is no wrapped RunnableFuture state to reuse.
       capture(InstrumentationContext.get(Runnable.class, State.class), task);
     }
   }