DataDog · bric3 · Jan 15, 2026 · Jan 12, 2026 · Jan 12, 2026 · Jan 12, 2026
@@ -29,14 +29,9 @@ or on Windows:
 Your output should look something like the following:
 
 ```
-ℹ️ Checking required JVMs:
-✅ JAVA_HOME is set to /Library/Java/JavaVirtualMachines/zulu-8.jdk/Contents/Home.
-✅ JAVA_8_HOME is set to /Library/Java/JavaVirtualMachines/zulu-8.jdk/Contents/Home.
-✅ JAVA_11_HOME is set to /Library/Java/JavaVirtualMachines/zulu-11.jdk/Contents/Home.
-✅ JAVA_17_HOME is set to /Library/Java/JavaVirtualMachines/zulu-17.jdk/Contents/Home.
-✅ JAVA_21_HOME is set to /Library/Java/JavaVirtualMachines/zulu-21.jdk/Contents/Home.
-✅ JAVA_25_HOME is set to /Library/Java/JavaVirtualMachines/zulu-25.jdk/Contents/Home.
-✅ JAVA_GRAALVM17_HOME is set to /Library/Java/JavaVirtualMachines/graalvm-ce-java17-22.3.1/Contents/Home.
+ℹ️ Checking required JVM:
+✅ JAVA_HOME is set to /Library/Java/JavaVirtualMachines/zulu-21.jdk/Contents/Home.
+ℹ️ Other JDK versions will be automatically downloaded by Gradle toolchain resolver.
 ℹ️ Checking git configuration:
 ✅ The git command line is installed.
 ✅ pre-commit hook is installed in repository.
@@ -53,19 +48,20 @@ If there is any issue with your output, check the requirements above and use the
 
 Requirements to build the full project:
 
-* The JDK versions 8, 11, 17, 21, and 25 must be installed.
-* The `JAVA_8_HOME`, `JAVA_11_HOME`, `JAVA_17_HOME`, `JAVA_21_HOME`, `JAVA_25_HOME`, and `JAVA_GRAALVM17_HOME` must point to their respective JDK location.
-* The JDK 8 `bin` directory must be the only JDK on the PATH (e.g. `$JAVA_8_HOME/bin`).
-* The `JAVA_HOME` environment variable may be unset. If set, it must point to the JDK 8 location (same as `JAVA_8_HOME`).
+* JDK 21 must be installed and `JAVA_HOME` must point to it.
+* Other JDK versions (8, 11, 17, 25) will be automatically downloaded by Gradle's toolchain resolver.
 * The `git` command line must be installed.
 * A container runtime environment must be available to run all tests (e.g. Docker Desktop).
 
-### Install the required JDKs
+### Install the required JDK
 
-Download and install JDK versions 8, 11, 17, 21 and 25, and GraalVM 17 for your OS.
+Download and install JDK 21 for your OS. Other JDK versions will be automatically downloaded by Gradle when needed.
 
 #### macOS
 
+
+Use your JDK manager ([mise](https://mise.jdx.dev/), [sdkman](https://sdkman.io/), etc.) or set-up the required JDKs with `brew`
+
 * Install the required JDKs using `brew`:
   ```shell
   brew install --cask zulu@8 zulu@11 zulu@17 zulu@21 zulu graalvm/tap/graalvm-ce-java17
@@ -77,20 +73,13 @@ Download and install JDK versions 8, 11, 17, 21 and 25, and GraalVM 17 for your
   Example: `graalvm-ce-java17-22.3.1`
 * Use this version in the following command to fix the GraalVM installation by [removing the quarantine flag](https://www.graalvm.org/latest/docs/getting-started/macos/):
   ```
-  sudo xattr -r -d com.apple.quarantine /Library/Java/JavaVirtualMachines/graalvm-<current version of graalvm>
-  ```
-  Example: `/Library/Java/JavaVirtualMachines/graalvm-ce-java17-22.3.1`
-* Add the required environment variables to your shell using the `export` command. You can permanently install the environment variables by appending the `export` commands into your shell configuration file `~/.zshrc` or `.bashrc` or other.
+* Add the `JAVA_HOME` environment variable to your shell using the `export` command. You can permanently set it by appending the `export` command to your shell configuration file `~/.zshrc` or `~/.bashrc` or other.
   ```shell
-  export JAVA_8_HOME=/Library/Java/JavaVirtualMachines/zulu-8.jdk/Contents/Home
-  export JAVA_11_HOME=/Library/Java/JavaVirtualMachines/zulu-11.jdk/Contents/Home
-  export JAVA_17_HOME=/Library/Java/JavaVirtualMachines/zulu-17.jdk/Contents/Home
-  export JAVA_21_HOME=/Library/Java/JavaVirtualMachines/zulu-21.jdk/Contents/Home
-  export JAVA_25_HOME=/Library/Java/JavaVirtualMachines/zulu-25.jdk/Contents/Home
-  export JAVA_GRAALVM17_HOME=/Library/Java/JavaVirtualMachines/graalvm-<current version of graalvm>/Contents/Home
-  export JAVA_HOME=$JAVA_8_HOME
+  export JAVA_HOME=/Library/Java/JavaVirtualMachines/zulu-21.jdk/Contents/Home
   ```
-* Restart your shell after applying the changes if you appended the commands to your shell configuration file.
+
+  Gradle should automatically detect the JDK in usual places. As a fallback it can automatically provision them.
+* Restart your shell after applying the changes if you appended the command to your shell configuration file.
 
 > [!NOTE]
 > ARM users: there is no Oracle JDK v8 for ARM.
@@ -102,23 +91,21 @@ Download and install JDK versions 8, 11, 17, 21 and 25, and GraalVM 17 for your
 
 #### Linux
 
+Use your JDK manager ([mise](https://mise.jdx.dev/), [sdkman](https://sdkman.io/), etc.) or manually install the required JDKs.
+
 * Download and extract JDK 8, 11, 17, 21, and 25 from [Eclipse Temurin releases](https://adoptium.net/temurin/releases/) and GraalVM 17 from [Oracle downloads](https://www.graalvm.org/downloads/).
 * Install the GraalVM native image requirements for native builds by following [the GraalVM official documentation](https://www.graalvm.org/latest/reference-manual/native-image/#prerequisites).
-* Add the required environment variables to your shell using the `export` command. You can permanently install the environment variables by appending the `export` commands into your shell configuration file `~/.zshrc` or `~/.bashrc` or other.
+* Add the `JAVA_HOME` environment variable to your shell using the `export` command. You can permanently set it by appending the `export` command to your shell configuration file `~/.zshrc` or `~/.bashrc` or other.
   ```shell
-  export JAVA_8_HOME=/<path to extracted archive>/jdk8u<current version of JDK 8>
-  export JAVA_11_HOME=/<path to extracted archive>/jdk-11.<current version of JDK 11>
-  export JAVA_17_HOME=/<path to extracted archive>/jdk-17.<current version of JDK 17>
-  export JAVA_21_HOME=/<path to extracted archive>/jdk-21.<current version of JDK 21>
-  export JAVA_25_HOME=/<path to extracted archive>/jdk-25.<current version of JDK 25>
-  export JAVA_GRAALVM17_HOME=/<path to extracted archive>/graalvm-jdk-17.<current version of graalvm>/Contents/Home
-  export JAVA_HOME=$JAVA_8_HOME
+  export JAVA_HOME=/<path to extracted archive>/jdk-21.<current version of JDK 21>
   ```
+
+  Gradle should automatically detect the JDK in usual places. As a fallback it can automatically provision them.
 * Restart your shell after applying the changes if you appended the commands to your shell configuration file.
 
 #### Windows
 
-* Download and install JDK 8, 11, 17, 21, and 25 [Eclipse Temurin releases](https://adoptium.net/temurin/releases/).
+* Download and install JDK 8, 11, 17, 21, and 25 from [Eclipse Temurin releases](https://adoptium.net/temurin/releases/).
 
   <details>
   <summary>Alternatively, install JDKs using winget or scoop. (click here to expand)</summary>
@@ -142,18 +129,13 @@ Download and install JDK versions 8, 11, 17, 21 and 25, and GraalVM 17 for your
 
   </details>
 
-* To add the required environment variables, run the following PowerShell commands for each SDK version, replacing the paths with the correct version installed:
+* Set the `JAVA_HOME` environment variable, replacing the path with your JDK 21 installation:
   ```pwsh
-  [Environment]::SetEnvironmentVariable("JAVA_8_HOME",  "C:\Program Files\Eclipse Adoptium\jdk-8.0.432.6-hotspot", [EnvironmentVariableTarget]::User)
-  [Environment]::SetEnvironmentVariable("JAVA_11_HOME", "C:\Program Files\Eclipse Adoptium\jdk-11.0.25.9-hotspot", [EnvironmentVariableTarget]::User)
-  [Environment]::SetEnvironmentVariable("JAVA_17_HOME", "C:\Program Files\Eclipse Adoptium\jdk-17.0.12.7-hotspot", [EnvironmentVariableTarget]::User)
-  [Environment]::SetEnvironmentVariable("JAVA_21_HOME", "C:\Program Files\Eclipse Adoptium\jdk-21.0.5.11-hotspot", [EnvironmentVariableTarget]::User)
-  [Environment]::SetEnvironmentVariable("JAVA_25_HOME", "C:\Program Files\Eclipse Adoptium\jdk-25.0.1.9-hotspot", [EnvironmentVariableTarget]::User)
-
-  # JAVA_HOME = JAVA_8_HOME
-  [Environment]::SetEnvironmentVariable("JAVA_HOME",    "C:\Program Files\Eclipse Adoptium\jdk-8.0.432.6-hotspot", [EnvironmentVariableTarget]::User)
+  [Environment]::SetEnvironmentVariable("JAVA_HOME", "C:\Program Files\Eclipse Adoptium\jdk-21.0.5.11-hotspot", [EnvironmentVariableTarget]::User)
   ```
 
+  Gradle should automatically detect the JDK in usual places. As a fallback it can automatically provision them.
+
 ### Install git
 
 #### macOS

@@ -50,10 +50,10 @@ To run the formatting verify task only:
 
 For IntelliJ IDEA, we suggest the following settings and plugin.
 
-The default JVM to build and run tests from the command line should be Java 8.
+The default JVM to build and run tests from the command line should be Java 21.
 
-* Use Java 8 to build and run tests:
-  * `Project Structure` -> `Project` -> `SDK` -> `Download JDK...` -> `Version: 1.8` -> `Download`
+* Use Java 21 to build and run tests:
+  * `Project Structure` -> `Project` -> `SDK` -> `Download JDK...` -> `Version: 21` -> `Download`
 * Configure Java and Groovy import formatting:  
   * `Settings...` ->`Editor` > `Code Style` > `Java` > `Imports`
     * `Use single class import`: checked
@@ -82,11 +82,6 @@ The default JVM to build and run tests from the command line should be Java 8.
 * IntelliJ 2021.3
   complains `Failed to find KotlinGradleProjectData for GradleSourceSetData` https://youtrack.jetbrains.com/issue/KTIJ-20173.
     * Switch to `IntelliJ IDEA CE 2021.2.3`.
-
-* IntelliJ Gradle fails to import the project with `JAVA_11_HOME must be set to build Java 11 code`.
-    * A workaround is to run IntelliJ from your terminal with `JAVA_11_HOME`.
-    * In order to verify what's visible from IntelliJ, use the `Add Configuration` bar and go
-      to `Add New` -> `Gradle` -> `Environmental Variables`.
 </details>
 
 ## Pull request guidelines

@@ -1,9 +1,12 @@
 package datadog.gradle.plugin.testJvmConstraints
 
+import com.gradle.scan.agent.serialization.scan.serializer.kryo.it
 import org.gradle.api.GradleException
 import org.gradle.api.Project
+import org.gradle.api.internal.project.ProjectInternal
 import org.gradle.api.internal.provider.PropertyFactory
 import org.gradle.api.provider.Provider
+import org.gradle.internal.jvm.inspection.JavaInstallationRegistry
 import org.gradle.jvm.toolchain.JavaLanguageVersion
 import org.gradle.jvm.toolchain.JavaLauncher
 import org.gradle.jvm.toolchain.JavaToolchainService
@@ -51,25 +54,22 @@ class TestJvmSpec(val project: Project) {
       throw GradleException("testJvm property is blank")
     }
 
-    // "stable" is calculated as the largest X found in JAVA_X_HOME
+    // "stable" is calculated as the largest Java version found via toolchains or JAVA_X_HOME
     when (testJvm) {
       "stable" -> {
-        val javaVersions = project.providers.environmentVariablesPrefixedBy("JAVA_").map { javaHomes ->
-          javaHomes
-            .filter { it.key.matches(Regex("^JAVA_[0-9]+_HOME$")) && it.key != "JAVA_26_HOME" } // JDK 26 is EA
-            .map { Regex("^JAVA_(\\d+)_HOME$").find(it.key)!!.groupValues[1].toInt() }
-        }.get()
+        val javaVersions = discoverJavaVersionsViaToolchains()
+          ?: discoverJavaVersionsViaEnvVars()
 
         if (javaVersions.isEmpty()) {
-          throw GradleException("No valid JAVA_X_HOME environment variables found.")
+          throw GradleException("No Java installations found via toolchains or JAVA_X_HOME environment variables.")
         }
 
         javaVersions.max().toString()
       }
 
       else -> testJvm
     }
-  }.map { project.logger.info("normalized testJvm: $it"); it }
+  }.map { project.logger.info("normalized testJvm: {}", it); it }
 
   /**
    * The home path of the test JVM.
@@ -127,7 +127,7 @@ class TestJvmSpec(val project: Project) {
         """.trimIndent()
       )
     }
-  }.map { project.logger.info("testJvm home path: $it"); it }
+  }.map { project.logger.info("testJvm home path: {}", it); it }
 
   /**
    * The Java launcher for the test JVM.
@@ -145,7 +145,7 @@ class TestJvmSpec(val project: Project) {
           throw GradleException("Unable to find launcher for Java '$testJvm'. Does $TEST_JVM point to a JDK?")
         })
       }
-    }.flatMap { it }.map { project.logger.info("testJvm launcher: ${it.executablePath}"); it }
+    }.flatMap { it }.map { project.logger.info("testJvm launcher: {}", it.executablePath); it }
 
   private fun String.normalizeToJDKJavaHome(): Path {
     val javaHome = project.file(this).toPath().toRealPath()
@@ -159,4 +159,38 @@ class TestJvmSpec(val project: Project) {
   private val Project.javaToolchains: JavaToolchainService
     get() =
       extensions.getByName("javaToolchains") as JavaToolchainService
+
+  /**
+   * Discovers available Java versions via Gradle's internal JavaInstallationRegistry.
+   */
+  private fun discoverJavaVersionsViaToolchains(): List<Int>? {
+    val registry = (project as ProjectInternal).services.get(JavaInstallationRegistry::class.java)
+    val versions = registry.toolchains().mapNotNull { installation ->
+        installation.metadata.languageVersion.majorVersion.toInt()
+    }
+
+    return if (versions.isNotEmpty()) {
+      project.logger.info("Discovered Java versions via toolchains: {}", versions)
+      versions
+    } else {
+      null
+    }
+  }
+
+  /**
+   * Discovers available Java versions via JAVA_X_HOME environment variables.
+   * Fallback method when toolchain discovery is not available.
+   */
+  private fun discoverJavaVersionsViaEnvVars(): List<Int> {
+    val versions = project.providers.environmentVariablesPrefixedBy("JAVA_").map { javaHomes ->
+      javaHomes
+        .filter { it.key.matches(Regex("^JAVA_[0-9]+_HOME$")) }
+        .mapNotNull { Regex("^JAVA_(\\d+)_HOME$").find(it.key)?.groupValues?.get(1)?.toIntOrNull() }
+    }.get()
+
+    if (versions.isNotEmpty()) {
+      project.logger.info("Discovered Java versions via JAVA_X_HOME env vars: {}", versions)
+    }
+    return versions
+  }
 }
@@ -11,7 +11,7 @@
 import org.junit.jupiter.api.Test;
 
 class EnvironmentVariablesTest {
-  private static final String EXISTING_ENV_VAR = "JAVA_8_HOME";
+  private static final String EXISTING_ENV_VAR = "PATH";
   private static final String MISSING_ENV_VAR = "UNDEFINED_ENV_VAR";
   private static final String DEFAULT_VALUE = "DEFAULT";
 

@@ -9,7 +9,6 @@ import datadog.trace.api.config.TracerConfig
 import java.nio.file.Paths
 import spock.lang.Specification
 import spock.lang.TempDir
-import spock.util.environment.Jvm
 
 import java.nio.file.Path
 
@@ -29,10 +28,20 @@ abstract class CiVisibilitySmokeTest extends Specification {
   protected Path prefsDir
 
   protected static String buildJavaHome() {
-    if (Jvm.current.isJava8()) {
-      return System.getenv("JAVA_8_HOME")
+    def javaHome = System.getProperty("java.home")
+    def javacPath = Paths.get(javaHome, "bin", "javac").toFile()
+    if (javacPath.exists()) {
+      return javaHome
     }
-    return System.getenv("JAVA_" + Jvm.current.getJavaSpecificationVersion() + "_HOME")
+    // In CI for JDK 8, java.home may point to the JRE directory (e.g., /usr/lib/jvm/8/jre)
+    // The JDK with javac is in the parent directory
+    def parentDir = new File(javaHome).getParentFile()
+    def parentJavacPath = new File(parentDir, Paths.get("bin", "javac").toString())
+    if (parentJavacPath.exists()) {
+      return parentDir.getAbsolutePath()
+    }
+    // Fallback to java.home and let callers handle the error if javac is not found
+    return javaHome
   }
 
   protected static String javaPath() {

@@ -231,7 +231,7 @@ tasks.register('extractLatestMuleServices', Sync) {
 // build the mule application via maven
 tasks.register('mvnPackage', Exec) {
   workingDir("$appDir")
-  environment.JAVA_HOME = System.getenv("JAVA_8_HOME")
+  environment["JAVA_HOME"] = getLazyJavaHomeFor(8)
 
   List<String> mvnArgs = [
     "$rootDir/mvnw",

@@ -57,8 +57,10 @@ def gradlewCommand = isWindows ? 'gradlew.bat' : 'gradlew'
 // define the task that builds the armeria project
 tasks.register('armeriaBuild', Exec) {
   workingDir "$appDir"
-  def toolchain17 = getJavaLauncherFor(17).get()
-  environment += ["GRADLE_OPTS": "-Dorg.gradle.jvmargs='-Xmx512M'", "JAVA_HOME": "$toolchain17.metadata.installationPath"]
+  environment += [
+    "GRADLE_OPTS": "-Dorg.gradle.jvmargs='-Xmx512M'",
+    "JAVA_HOME": getLazyJavaHomeFor(17)
+  ]
   commandLine "${rootDir}/${gradlewCommand}", "build", "--no-daemon", "--max-workers=4", "-PappBuildDir=$appBuildDir", "-PapiJar=${project(':dd-trace-api').tasks.jar.archiveFile.get()}"
 
   outputs.cacheIf { true }

@@ -49,6 +49,7 @@ dependencies {
 tasks.withType(Test).configureEach {
   def shadowJarTask = tasks.named('shadowJar', ShadowJar)
   dependsOn shadowJarTask
+  environment("JAVA_HOME", getLazyJavaHomeFor(25))
   jvmArgumentProviders.add(new CommandLineArgumentProvider() {
       @Override
       Iterable<String> asArguments() {

@@ -17,7 +17,9 @@ abstract class AbstractStructuredConcurrencyTest extends AbstractSmokeTest {
   ProcessBuilder createProcessBuilder() {
     def jarPath = System.getProperty("datadog.smoketest.shadowJar.path")
     def command = new ArrayList<String>()
-    command.add(Paths.get(System.getenv("JAVA_25_HOME"), "bin", "java").toString())
+
+    def javaHome = Paths.get(System.getenv("JAVA_HOME"), "bin", "java").toString()
+    command.add(javaHome)
     command.addAll(defaultJavaProperties)
     command.add("--enable-preview")
     command.add("-Ddd.trace.otel.enabled=true")

@@ -22,9 +22,10 @@ final gradlewCommand = isWindows ? 'gradlew.bat' : 'gradlew'
 
 tasks.register('bootJar', Exec) {
   workingDir appDir
-
-  final toolchain17 = getJavaLauncherFor(17).get()
-  environment += ["GRADLE_OPTS": "-Dorg.gradle.jvmargs='-Xmx512M'", "JAVA_HOME": "$toolchain17.metadata.installationPath"]
+  environment += [
+    "GRADLE_OPTS": "-Dorg.gradle.jvmargs='-Xmx512M'",
+    "JAVA_HOME": getLazyJavaHomeFor(17)
+  ]
   commandLine "$rootDir/${gradlewCommand}", "bootJar", "--no-daemon", "--max-workers=4", "-PappBuildDir=$appBuildDir"
 
   outputs.cacheIf { true }

@@ -1,22 +1,21 @@
+import java.util.regex.Pattern
+
 apply from: "$rootDir/gradle/java.gradle"
 
 dependencies {
   testImplementation project(':dd-smoke-tests')
 }
+// Check 'testJvm' gradle command parameter is GraalVM (e.g., -PtestJvm=graalvm21),
+// if not nothing is done
 def testJvm = gradle.startParameter.projectProperties.getOrDefault('testJvm', '')
-// In order to support GraalVM 21 we need at least Java 17 for Gradle
-def java17Home = providers.environmentVariable('JAVA_17_HOME').orNull
-// Check 'testJvm' gradle command parameter to be at least GraalVM 17
-def matcher = testJvm?.toLowerCase(Locale.ROOT) =~ /graalvm([0-9]+)/
-def version = matcher?.size() == 1 ? Integer.parseInt(matcher[0][1]) : -1
-if (version >= 17) {
-  // Retrieve GRAALVM_HOME from JVM environment variables
-  def testJvmEnv = "JAVA_${testJvm}_HOME"
-  def testJvmHome = providers.environmentVariable(testJvmEnv).orNull
-  if (!testJvmHome) {
-    throw new GradleException("Unable to find launcher for Java '$testJvm'. Have you set '$testJvmEnv'?")
-  }
-  def javaHome = version >= 21 ? java17Home : testJvmHome
+def graalvmMatcher = Pattern.compile("graalvm([0-9]+)").matcher(testJvm?.toLowerCase(Locale.ROOT) ?: '')
+def testGraalvmVersion = graalvmMatcher.find() ? Integer.parseInt(graalvmMatcher.group(1)) : -1
+
+if (testGraalvmVersion >= 17) {
+  // GraalVM with native-image capability for native compilation
+  def graalvmHome = getLazyJavaHomeFor(testGraalvmVersion, true)
+  // For GraalVM 21+ we need Java 17+ to run Gradle, for earlier versions use GraalVM itself
+  def gradleJavaHome = testGraalvmVersion >= 21 ? getLazyJavaHomeFor(17) : graalvmHome
   // Configure build directory for application
   def appDir = "$projectDir/application"
   def appBuildDir = "$buildDir/application"
@@ -28,8 +27,8 @@ if (version >= 17) {
     workingDir "$appDir"
     environment += [
       'GRADLE_OPTS' : "-Dorg.gradle.jvmargs='-Xmx512M'",
-      'JAVA_HOME'   : javaHome,
-      'GRAALVM_HOME': testJvmHome
+      'JAVA_HOME'   : gradleJavaHome,
+      'GRAALVM_HOME': graalvmHome
     ]
     commandLine(
       "$rootDir/${gradlewCommand}",