use jdk21

Author: laurit

conventions/src/main/kotlin/io/opentelemetry/instrumentation/gradle/OtelJavaExtension.kt

@@ -10,6 +10,7 @@ import org.gradle.api.provider.Property
 
 abstract class OtelJavaExtension {
   abstract val minJavaVersionSupported: Property<JavaVersion>
+  abstract val maxJavaVersionSupported: Property<JavaVersion>
 
   abstract val maxJavaVersionForTests: Property<JavaVersion>
 

conventions/src/main/kotlin/otel.java-conventions.gradle.kts

@@ -27,12 +27,15 @@ afterEvaluate {
 }
 
 // Version to use to compile code and run tests.
-val DEFAULT_JAVA_VERSION = JavaVersion.VERSION_17
+val DEFAULT_JAVA_VERSION = JavaVersion.VERSION_21
 
 java {
   toolchain {
     languageVersion.set(
-      otelJava.minJavaVersionSupported.map { JavaLanguageVersion.of(Math.max(it.majorVersion.toInt(), DEFAULT_JAVA_VERSION.majorVersion.toInt())) }
+      otelJava.minJavaVersionSupported.map {
+        val defaultJavaVersion = otelJava.maxJavaVersionSupported.getOrElse(DEFAULT_JAVA_VERSION).majorVersion.toInt()
+        JavaLanguageVersion.of(Math.max(it.majorVersion.toInt(), defaultJavaVersion))
+      }
     )
   }
 
@@ -69,11 +72,18 @@ tasks.withType<JavaCompile>().configureEach {
           "-Xlint:-processing",
           // We suppress the "options" warning because it prevents compilation on modern JDKs
           "-Xlint:-options",
+          // jdk21 generates more serial warnings than previous versions
+          "-Xlint:-serial",
 
           // Fail build on any warning
           "-Werror"
         )
       )
+      val defaultJavaVersion = otelJava.maxJavaVersionSupported.getOrElse(DEFAULT_JAVA_VERSION).majorVersion.toInt()
+      if (Math.max(otelJava.minJavaVersionSupported.get().majorVersion.toInt(), defaultJavaVersion) >= 21) {
+        // new warning in jdk21
+        compilerArgs.add("-Xlint:-this-escape")
+      }
     }
 
     encoding = "UTF-8"

instrumentation/executors/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/executors/ExecutorInstrumentationTest.java

@@ -7,8 +7,6 @@
 
 import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
 import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -26,8 +24,6 @@
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.condition.EnabledForJreRange;
-import org.junit.jupiter.api.condition.JRE;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
 abstract class ExecutorInstrumentationTest<T extends ExecutorService>
@@ -51,24 +47,6 @@ static class ThreadPoolExecutorTest extends ExecutorInstrumentationTest<ThreadPo
     }
   }
 
-  @EnabledForJreRange(min = JRE.JAVA_21)
-  static class VirtualThreadExecutorTest extends ExecutorInstrumentationTest<ExecutorService> {
-    VirtualThreadExecutorTest() {
-      super(newVirtualThreadPerTaskExecutor());
-    }
-
-    private static ExecutorService newVirtualThreadPerTaskExecutor() {
-      Method newVirtualThreadPerTaskExecutor;
-      try {
-        newVirtualThreadPerTaskExecutor =
-            Executors.class.getMethod("newVirtualThreadPerTaskExecutor");
-        return (ExecutorService) newVirtualThreadPerTaskExecutor.invoke(null);
-      } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException e) {
-        throw new IllegalStateException("Should not happen on Java 21+", e);
-      }
-    }
-  }
-
   static class WorkStealingPoolTest extends ExecutorInstrumentationTest<ExecutorService> {
     public WorkStealingPoolTest() {
       super(Executors.newWorkStealingPool(2));

instrumentation/executors/jdk21-testing/build.gradle.kts

@@ -0,0 +1,20 @@
+plugins {
+  id("otel.javaagent-testing")
+}
+
+dependencies {
+  testInstrumentation(project(":instrumentation:executors:javaagent"))
+
+  testCompileOnly(project(":instrumentation:executors:bootstrap"))
+  testImplementation(project(":instrumentation:executors:testing"))
+}
+
+otelJava {
+  minJavaVersionSupported.set(JavaVersion.VERSION_21)
+}
+
+tasks.withType<Test>().configureEach {
+  // needed for VirtualThreadTest
+  jvmArgs("--add-opens=java.base/java.lang=ALL-UNNAMED")
+  jvmArgs("-XX:+IgnoreUnrecognizedVMOptions")
+}

instrumentation/executors/jdk21-testing/src/test/java/io/opentelemetry/javaagent/instrumentation/executors/VirtualThreadExecutorTest.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.executors;
+
+import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
+import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+class VirtualThreadExecutorTest
+    extends AbstractExecutorServiceTest<ExecutorService, JavaAsyncChild> {
+
+  @RegisterExtension
+  static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
+
+  VirtualThreadExecutorTest() {
+    super(Executors.newVirtualThreadPerTaskExecutor(), testing);
+  }
+
+  @Override
+  protected JavaAsyncChild newTask(boolean doTraceableWork, boolean blockThread) {
+    return new JavaAsyncChild(doTraceableWork, blockThread);
+  }
+}

instrumentation/executors/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/executors/VirtualThreadTest.java instrumentation/executors/jdk21-testing/src/test/java/io/opentelemetry/javaagent/instrumentation/executors/VirtualThreadTest.java

@@ -12,21 +12,13 @@
 import java.util.concurrent.Callable;
 import java.util.concurrent.atomic.AtomicBoolean;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.condition.EnabledForJreRange;
-import org.junit.jupiter.api.condition.JRE;
 
-@EnabledForJreRange(min = JRE.JAVA_21)
 class VirtualThreadTest {
 
   @Test
   void testDisableContextPropagation() throws Exception {
     TestRunnable testRunnable = new TestRunnable();
-    // Thread.ofVirtual().start(testRunnable);
-    Method ofVirtualMethod = Thread.class.getMethod("ofVirtual");
-    Object virtualThreadBuilder = ofVirtualMethod.invoke(null);
-    Method startVirtualThread =
-        Class.forName("java.lang.Thread$Builder").getMethod("start", Runnable.class);
-    Thread thread = (Thread) startVirtualThread.invoke(virtualThreadBuilder, testRunnable);
+    Thread thread = Thread.ofVirtual().start(testRunnable);
     thread.join();
 
     assertThat(testRunnable.error).isNull();

instrumentation/executors/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/executors/JavaAsyncChild.java instrumentation/executors/testing/src/main/java/io/opentelemetry/javaagent/instrumentation/executors/JavaAsyncChild.java

@@ -11,6 +11,7 @@
 import java.util.concurrent.ForkJoinTask;
 import java.util.concurrent.atomic.AtomicBoolean;
 
+@SuppressWarnings("serial")
 final class JavaAsyncChild extends ForkJoinTask<Object> implements TestTask {
   private static final Tracer tracer = GlobalOpenTelemetry.getTracer("test");
 

instrumentation/grails-3.0/javaagent/build.gradle.kts

@@ -18,6 +18,10 @@ muzzle {
   }
 }
 
+otelJava {
+  maxJavaVersionSupported.set(JavaVersion.VERSION_17)
+}
+
 val grailsVersion = "3.0.6" // first version that the tests pass on
 val springBootVersion = "1.2.5.RELEASE"
 

instrumentation/zio/zio-2.0/javaagent/build.gradle.kts

@@ -28,6 +28,10 @@ muzzle {
   }
 }
 
+otelJava {
+  maxJavaVersionSupported.set(JavaVersion.VERSION_17)
+}
+
 dependencies {
   compileOnly("dev.zio:zio_$scalaVersion:$zioVersion")
 

muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/ReferenceMatcher.java

@@ -294,13 +294,19 @@ private static MethodDescription.InDefinedShape findMethod(
       return null;
     }
 
+    TypeDescription superType = null;
     if (typeOnClasspath.getSuperClass() != null) {
-      MethodDescription.InDefinedShape methodOnSupertype =
-          findMethod(methodRef, typeOnClasspath.getSuperClass().asErasure());
+      superType = typeOnClasspath.getSuperClass().asErasure();
+    } else if (!"java.lang.Object".equals(typeOnClasspath.getName())) {
+      superType = TypeDescription.ForLoadedType.of(Object.class);
+    }
+    if (superType != null) {
+      MethodDescription.InDefinedShape methodOnSupertype = findMethod(methodRef, superType);
       if (methodOnSupertype != null) {
         return methodOnSupertype;
       }
     }
+
     for (TypeDescription.Generic interfaceType : typeOnClasspath.getInterfaces()) {
       MethodDescription.InDefinedShape methodOnSupertype =
           findMethod(methodRef, interfaceType.asErasure());

settings.gradle.kts

@@ -225,6 +225,7 @@ include(":instrumentation:elasticsearch:elasticsearch-transport-common:javaagent
 include(":instrumentation:elasticsearch:elasticsearch-transport-common:testing")
 include(":instrumentation:executors:bootstrap")
 include(":instrumentation:executors:javaagent")
+include(":instrumentation:executors:jdk21-testing")
 include(":instrumentation:executors:testing")
 include(":instrumentation:external-annotations:javaagent")
 include(":instrumentation:external-annotations:javaagent-unit-tests")