feat(env): Add support for virtual thread detection

Author: PerfectSlayer

components/environment/build.gradle.kts

@@ -24,6 +24,7 @@ val excludedClassesCoverage by extra {
     "datadog.environment.JavaVirtualMachine.JvmOptionsHolder", // depends on OS and JVM vendor
     "datadog.environment.JvmOptions", // depends on OS and JVM vendor
     "datadog.environment.OperatingSystem**", // depends on OS
+    "datadog.environment.ThreadSupport", // requires Java 21
   )
 }
 val excludedClassesBranchCoverage by extra {

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

@@ -0,0 +1,84 @@
+package datadog.environment;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.util.Optional;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public final class ThreadSupport {
+  static final MethodHandle MH_IS_VIRTUAL = findIsVirtualMethodHandle();
+  static final MethodHandle MH_NEW_VIRTUAL_THREAD_PER_TASK_EXECUTOR =
+      findNewVirtualThreadPerTaskExecutorMethodHandle();
+
+  private ThreadSupport() {}
+
+  /**
+   * Checks whether the current thread is a virtual thread.
+   *
+   * @return {@code true} if the current thread is a virtual thread, {@code false} otherwise.
+   */
+  public static boolean isVirtual() {
+    if (MH_IS_VIRTUAL == null) {
+      return false;
+    }
+    return isVirtual(Thread.currentThread());
+  }
+
+  /**
+   * Checks whether the given thread is a virtual thread.
+   *
+   * @param thread The thread to check.
+   * @return {@code true} if the given thread is virtual, {@code false} otherwise.
+   */
+  public static boolean isVirtual(Thread thread) {
+    if (MH_IS_VIRTUAL == null) {
+      return false;
+    }
+    try {
+      return (boolean) MH_IS_VIRTUAL.invoke(thread);
+    } catch (Throwable e) {
+      return false;
+    }
+  }
+
+  public static Optional<ExecutorService> newVirtualThreadPerTaskExecutor() {
+    if (MH_NEW_VIRTUAL_THREAD_PER_TASK_EXECUTOR == null) {
+      return Optional.empty();
+    } else {
+      try {
+        ExecutorService executorService =
+            (ExecutorService) MH_NEW_VIRTUAL_THREAD_PER_TASK_EXECUTOR.invoke();
+        return Optional.of(executorService);
+      } catch (Throwable e) {
+        return Optional.empty();
+      }
+    }
+  }
+
+  private static MethodHandle findIsVirtualMethodHandle() {
+    if (JavaVersion.getRuntimeVersion().isAtLeast(21, 0, 0)) {
+      try {
+        return MethodHandles.lookup()
+            .findVirtual(Thread.class, "isVirtual", MethodType.methodType(boolean.class));
+      } catch (Throwable ignored) {
+      }
+    }
+    return null;
+  }
+
+  private static MethodHandle findNewVirtualThreadPerTaskExecutorMethodHandle() {
+    if (JavaVersion.getRuntimeVersion().isAtLeast(21, 0, 0)) {
+      try {
+        return MethodHandles.lookup()
+            .findStatic(
+                Executors.class,
+                "newVirtualThreadPerTaskExecutor",
+                MethodType.methodType(ExecutorService.class));
+      } catch (Throwable ignored) {
+      }
+    }
+    return null;
+  }
+}

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

@@ -0,0 +1,59 @@
+package datadog.environment;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.condition.JRE.JAVA_21;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledOnJre;
+
+class ThreadSupportTest {
+  private static ExecutorService singleThreadExecutor;
+  private static ExecutorService newVirtualThreadPerTaskExecutor;
+
+  @BeforeAll
+  static void beforeAll() {
+    singleThreadExecutor = Executors.newSingleThreadExecutor();
+    newVirtualThreadPerTaskExecutor = ThreadSupport.newVirtualThreadPerTaskExecutor().orElse(null);
+  }
+
+  @Test
+  void testPlatformThread() {
+    assertVirtualThread(singleThreadExecutor, false);
+  }
+
+  @Test
+  @EnabledOnJre(JAVA_21)
+  void testVirtualThread() {
+    assertVirtualThread(newVirtualThreadPerTaskExecutor, true);
+  }
+
+  static void assertVirtualThread(ExecutorService executorService, boolean expected) {
+    Future<Boolean> futureCurrent = executorService.submit(() -> ThreadSupport.isVirtual());
+    Future<Boolean> futureGiven =
+        executorService.submit(
+            () -> {
+              Thread thread = Thread.currentThread();
+              return ThreadSupport.isVirtual(thread);
+            });
+    try {
+      assertEquals(expected, futureCurrent.get(), "invalid current thread virtual status");
+      assertEquals(expected, futureGiven.get(), "invalid given thread virtual status");
+    } catch (Throwable e) {
+      fail("Can't get thread virtual status", e);
+    }
+  }
+
+  @AfterAll
+  static void afterAll() {
+    singleThreadExecutor.shutdown();
+    if (newVirtualThreadPerTaskExecutor != null) {
+      newVirtualThreadPerTaskExecutor.shutdown();
+    }
+  }
+}