chore(build-logic): default smokeTestApp to JDK 21 daemon + Gradle 8.14.5

Set conventions on `smokeTestApp`:
- `gradleVersion` defaults to `"8.14.5"` (Gradle 8 last release; pinned because
  Spring Boot plugin pre-3.5 calls `Configuration.getUploadTaskName()`, removed
  in Gradle 9).
- `javaLauncher` defaults to a JDK 21 toolchain (the version the root build
  requires for its own Gradle 9 migration; standardising the nested daemon on
  the same JDK avoids requiring an extra toolchain on dev machines and CI
  runners).

Consumers that need a different JDK or Gradle version still override
explicitly. The inner build script is responsible for pinning the produced
bytecode level (`java { sourceCompatibility = JavaVersion.VERSION_1_8 }` or
similar) — Gradle adds `--release N` automatically when source/target differs
from the daemon JVM.

`JavaToolchainService` is now injected into the extension; this works in any
project where a `java*` (or related) plugin is applied. Smoke-test modules
already apply `gradle/java.gradle`, which applies `java`, so the convention
resolves on first read.

Public defaults exposed as `DEFAULT_NESTED_GRADLE_VERSION` and
`DEFAULT_NESTED_JAVA_VERSION` constants so the values are discoverable.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: bric3

build-logic/smoke-test/src/main/kotlin/datadog/buildlogic/smoketest/NestedGradleBuild.kt

@@ -18,7 +18,9 @@ import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.PathSensitive
 import org.gradle.api.tasks.PathSensitivity
 import org.gradle.api.tasks.TaskAction
+import org.gradle.jvm.toolchain.JavaLanguageVersion
 import org.gradle.jvm.toolchain.JavaLauncher
+import org.gradle.jvm.toolchain.JavaToolchainService
 import org.gradle.tooling.GradleConnector
 import javax.inject.Inject
 
@@ -34,8 +36,19 @@ import javax.inject.Inject
  * `-P<propertyName>=<absolute-path>` and tracked as a task input so the nested build re-runs
  * when the upstream jar changes.
  */
-abstract class NestedGradleBuild @Inject constructor(private val objects: ObjectFactory) :
-  DefaultTask() {
+abstract class NestedGradleBuild @Inject constructor(
+  private val objects: ObjectFactory,
+  javaToolchains: JavaToolchainService,
+) : DefaultTask() {
+
+  init {
+    gradleVersion.convention(DEFAULT_NESTED_GRADLE_VERSION)
+    javaLauncher.convention(
+      javaToolchains.launcherFor {
+        languageVersion.set(JavaLanguageVersion.of(DEFAULT_NESTED_JAVA_VERSION))
+      },
+    )
+  }
 
   @get:Internal
   abstract val applicationDir: DirectoryProperty

build-logic/smoke-test/src/main/kotlin/datadog/buildlogic/smoketest/SmokeTestAppExtension.kt

@@ -11,7 +11,9 @@ import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.testing.Test
+import org.gradle.jvm.toolchain.JavaLanguageVersion
 import org.gradle.jvm.toolchain.JavaLauncher
+import org.gradle.jvm.toolchain.JavaToolchainService
 import org.gradle.process.CommandLineArgumentProvider
 import java.util.Locale
 import javax.inject.Inject
@@ -23,12 +25,24 @@ import javax.inject.Inject
  * stays unconfigured, the plugin is a no-op and consumers can register [NestedGradleBuild]
  * directly.
  */
-abstract class SmokeTestAppExtension @Inject constructor(private val project: Project) {
+abstract class SmokeTestAppExtension @Inject constructor(
+  private val project: Project,
+  javaToolchains: JavaToolchainService,
+) {
 
-  /** Gradle version used by the nested daemon. Defaults to the root build's version. */
+  /**
+   * Gradle version used by the nested daemon. Defaults to [DEFAULT_NESTED_GRADLE_VERSION] —
+   * the version pinned for smoke-test applications whose Spring Boot plugin is incompatible
+   * with Gradle 9.
+   */
   abstract val gradleVersion: Property<String>
 
-  /** JDK used by the nested daemon. Required when calling [application]. */
+  /**
+   * JDK used by the nested daemon. Defaults to a [DEFAULT_NESTED_JAVA_VERSION] toolchain;
+   * override to pin a different JDK if the nested application's plugin chain requires it.
+   * The inner build script is responsible for pinning the produced bytecode level (e.g.
+   * `java { sourceCompatibility = JavaVersion.VERSION_1_8 }`).
+   */
   abstract val javaLauncher: Property<JavaLauncher>
 
   /** Directory containing the nested project's `settings.gradle` + sources. */
@@ -45,7 +59,12 @@ abstract class SmokeTestAppExtension @Inject constructor(private val project: Pr
   init {
     applicationDir.convention(project.layout.projectDirectory.dir("application"))
     applicationBuildDir.convention(project.layout.buildDirectory.dir("application"))
-    gradleVersion.convention(project.gradle.gradleVersion)
+    gradleVersion.convention(DEFAULT_NESTED_GRADLE_VERSION)
+    javaLauncher.convention(
+      javaToolchains.launcherFor {
+        languageVersion.set(JavaLanguageVersion.of(DEFAULT_NESTED_JAVA_VERSION))
+      },
+    )
   }
 
   /**
@@ -54,9 +73,6 @@ abstract class SmokeTestAppExtension @Inject constructor(private val project: Pr
    * register [NestedGradleBuild] manually can leave [application] uncalled.
    */
   fun application(action: Action<ApplicationSpec>) {
-    require(javaLauncher.isPresent) {
-      "smokeTestApp.javaLauncher must be set before configuring application { ... }"
-    }
     val spec = project.objects.newInstance(ApplicationSpec::class.java)
     action.execute(spec)
     val taskName = requireNotNull(spec.taskName.orNull) {
@@ -167,6 +183,21 @@ abstract class ApplicationSpec @Inject constructor() {
   abstract val additionalSystemProperties: MapProperty<String, String>
 }
 
+/**
+ * Default Gradle distribution version for the nested daemon. Pinned to a Gradle 8 release
+ * because the Spring Boot Gradle plugin pre-3.5.0 calls `Configuration.getUploadTaskName()`,
+ * removed in Gradle 9.
+ */
+const val DEFAULT_NESTED_GRADLE_VERSION = "8.14.5"
+
+/**
+ * Default JDK language version for the nested daemon. JDK 21 is the version the root build
+ * requires for Gradle 9; standardising the nested daemon on the same JDK avoids pulling a
+ * second toolchain onto dev machines and CI runners. Inner build scripts cross-compile down
+ * to their actual bytecode target via `java { sourceCompatibility = ... }`.
+ */
+const val DEFAULT_NESTED_JAVA_VERSION = 21
+
 private class SmokeTestArgProvider(
   private val sysProperty: String,
   private val artifact: Provider<RegularFile>,

build-logic/smoke-test/src/test/kotlin/datadog/buildlogic/smoketest/SmokeTestAppPluginTest.kt

@@ -1,6 +1,8 @@
 package datadog.buildlogic.smoketest
 
 import org.assertj.core.api.Assertions.assertThat
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.jvm.toolchain.JavaLanguageVersion
 import org.gradle.testfixtures.ProjectBuilder
 import org.junit.jupiter.api.Test
 
@@ -54,12 +56,26 @@ class SmokeTestAppPluginTest {
   }
 
   @Test
-  fun `extension defaults gradleVersion to the host build's version`() {
+  fun `extension defaults gradleVersion to the smoke-test pinned version`() {
     val project = ProjectBuilder.builder().build()
     project.plugins.apply("dd-trace-java.smoke-test-app")
 
     val extension = project.extensions.getByType(SmokeTestAppExtension::class.java)
 
-    assertThat(extension.gradleVersion.get()).isEqualTo(project.gradle.gradleVersion)
+    assertThat(extension.gradleVersion.get()).isEqualTo(DEFAULT_NESTED_GRADLE_VERSION)
+  }
+
+  @Test
+  fun `extension defaults javaLauncher to a JDK 21 toolchain`() {
+    // JavaToolchainService is contributed by the `java-base` plugin; apply something that
+    // pulls it in so ProjectBuilder can resolve the convention.
+    val project = ProjectBuilder.builder().build()
+    project.plugins.apply(JavaPlugin::class.java)
+    project.plugins.apply("dd-trace-java.smoke-test-app")
+
+    val extension = project.extensions.getByType(SmokeTestAppExtension::class.java)
+
+    assertThat(extension.javaLauncher.get().metadata.languageVersion)
+      .isEqualTo(JavaLanguageVersion.of(DEFAULT_NESTED_JAVA_VERSION))
   }
 }