Upgrade to Gradle 9.3.1 with JDK 21 build requirement (#365)

Author: jbachorik

.github/actions/setup_cached_java/action.yml

@@ -18,11 +18,12 @@ runs:
         shell: bash
         id: infer_build_jdk
         run: |
-          echo "Infering JDK 11 [${{ inputs.arch }}]"
+          # Gradle 9 requires JDK 17+ to run; using JDK 21 (LTS)
+          echo "Inferring JDK 21 [${{ inputs.arch }}]"
           if [[ ${{ inputs.arch }} =~ "-musl" ]]; then
-            echo "build_jdk=jdk11-librca" >> $GITHUB_OUTPUT
+            echo "build_jdk=jdk21-librca" >> $GITHUB_OUTPUT
           else
-            echo "build_jdk=jdk11" >> $GITHUB_OUTPUT
+            echo "build_jdk=jdk21" >> $GITHUB_OUTPUT
           fi
       - name: Cache Build JDK [${{ inputs.arch }}]
         id: cache_build_jdk

.github/dependabot.yml

@@ -0,0 +1,35 @@
+version: 2
+updates:
+  # Gradle dependencies (root project)
+  - package-ecosystem: "gradle"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    open-pull-requests-limit: 5
+    groups:
+      gradle-minor:
+        update-types:
+          - "minor"
+          - "patch"
+
+  # Gradle dependencies (build-logic composite build)
+  - package-ecosystem: "gradle"
+    directory: "/build-logic"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    open-pull-requests-limit: 5
+    groups:
+      gradle-minor:
+        update-types:
+          - "minor"
+          - "patch"
+
+  # GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    open-pull-requests-limit: 5

.github/workflows/ci.yml

@@ -47,6 +47,13 @@ jobs:
     if: needs.check-for-pr.outputs.skip != 'true'
     steps:
       - uses: actions/checkout@v3
+
+      - name: Setup Java
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'zulu'
+          java-version: '21'
+
       - name: Setup OS
         run: |
           sudo apt-get update

.github/workflows/test_workflow.yml

@@ -15,6 +15,22 @@ jobs:
   cache-jdks:
     # This job is used to cache the JDKs for the test jobs
     uses: ./.github/workflows/cache_java.yml
+  filter-musl-configs:
+    # Sanitizers (asan/tsan) are not supported on musl - filter them out
+    runs-on: ubuntu-latest
+    outputs:
+      configs: ${{ steps.filter.outputs.configs }}
+      has_configs: ${{ steps.filter.outputs.has_configs }}
+    steps:
+      - id: filter
+        run: |
+          configs=$(echo '${{ inputs.configuration }}' | jq -c '[.[] | select(. != "asan" and . != "tsan")]')
+          if [ "$configs" = "[]" ]; then
+            echo "has_configs=false" >> $GITHUB_OUTPUT
+          else
+            echo "has_configs=true" >> $GITHUB_OUTPUT
+          fi
+          echo "configs=$configs" >> $GITHUB_OUTPUT
   test-linux-glibc-amd64:
     needs: cache-jdks
     strategy:
@@ -132,12 +148,13 @@ jobs:
           path: test-reports
 
   test-linux-musl-amd64:
-    needs: cache-jdks
+    needs: [cache-jdks, filter-musl-configs]
+    if: needs.filter-musl-configs.outputs.has_configs == 'true'
     strategy:
      fail-fast: false
      matrix:
        java_version: [ "8-librca", "11-librca", "17-librca", "21-librca", "25-librca" ]
-       config: ${{ fromJson(inputs.configuration) }}
+       config: ${{ fromJson(needs.filter-musl-configs.outputs.configs) }}
     runs-on: ubuntu-latest
     container:
       image: "alpine:3.21"
@@ -368,12 +385,13 @@ jobs:
           path: test-reports
 
   test-linux-musl-aarch64:
-     needs: cache-jdks
+     needs: [cache-jdks, filter-musl-configs]
+     if: needs.filter-musl-configs.outputs.has_configs == 'true'
      strategy:
        fail-fast: false
        matrix:
          java_version: [ "8-librca", "11-librca", "17-librca", "21-librca", "25-librca" ]
-         config: ${{ fromJson(inputs.configuration) }}
+         config: ${{ fromJson(needs.filter-musl-configs.outputs.configs) }}
      runs-on:
        group: ARM LINUX SHARED
        labels: arm-4core-linux-ubuntu24.04

AGENTS.md

@@ -274,11 +274,22 @@ Release builds automatically extract debug symbols:
 ## Development Workflow
 
 ### Running Single Tests
-Use standard Gradle syntax:
+Use the `-Ptests` property across all platforms:
 ```bash
-./gradlew :ddprof-test:test --tests "ClassName.methodName"
+./gradlew :ddprof-test:testDebug -Ptests=ClassName.methodName  # Single method
+./gradlew :ddprof-test:testDebug -Ptests=ClassName              # Entire class
+./gradlew :ddprof-test:testDebug -Ptests="*.ClassName"          # Pattern matching
 ```
 
+**Platform Implementation Details:**
+- **glibc/macOS**: Test tasks use Gradle's native Test task type with JUnit Platform integration
+- **musl (Alpine)**: Exec tasks with custom ProfilerTestRunner (bypasses Gradle 9 toolchain probe issues)
+- **Custom Test Runner**: Uses JUnit Platform Launcher API directly (same API used by IDEs and Gradle internally)
+- **Result**: Unified `-Ptests` property works identically across all platforms, no platform-specific syntax required
+
+**Why `-Ptests` instead of `--tests`?**
+The `-Ptests` property works consistently across both Test and Exec task types, while `--tests` only works with Test tasks. This ensures a truly unified interface across all platforms.
+
 ### Working with Native Code
 Native compilation is automatic during build. C++ code changes require:
 1. Full rebuild: `/build-and-summarize clean build`
@@ -604,8 +615,56 @@ See `gradle.properties.template` for all options. Key ones:
 
 - Exclude ddprof-lib/build/async-profiler from searches of active usage
 
-- Run tests with 'testdebug' gradle task
-- Use at most Java 21 to build and run tests
+- Run tests with 'testDebug' gradle task
+
+## Build JDK Configuration
+
+The project uses a **two-JDK pattern**:
+- **Build JDK** (`JAVA_HOME`): Used to run Gradle itself. Must be JDK 17+ for Gradle 9.
+- **Test JDK** (`JAVA_TEST_HOME`): Used to run tests against different Java versions.
+
+**Current requirement:** JDK 21 (LTS) for building, targeting Java 8 bytecode via `--release 8`.
+
+### Files to Modify When Changing Build JDK Version
+
+When upgrading the build JDK (e.g., from JDK 21 to JDK 25), update these files:
+
+| File | What to Change |
+|------|----------------|
+| `README.md` | Update "Prerequisites" section with new JDK version |
+| `.github/actions/setup_cached_java/action.yml` | Change `build_jdk=jdk21` to new version (line ~25) |
+| `.github/workflows/ci.yml` | Update `java-version` in `check-formatting` job's Setup Java step |
+| `utils/run-docker-tests.sh` | Update `BUILD_JDK_VERSION="21"` constant |
+| `build-logic/.../JavaConventionsPlugin.kt` | Update documentation comment if minimum changes |
+
+### Files to Modify When Changing Target JDK Version
+
+When changing the target bytecode version (e.g., from Java 8 to Java 11):
+
+| File | What to Change |
+|------|----------------|
+| `build-logic/.../JavaConventionsPlugin.kt` | Change `--release 8` to new version |
+| `ddprof-lib/build.gradle.kts` | Change `sourceCompatibility`/`targetCompatibility` |
+| `README.md` | Update minimum Java runtime version |
+
+### Gradle 9 API Changes Reference
+
+When upgrading Gradle major versions, watch for these breaking changes:
+
+| Old API | New API (Gradle 9+) | Affected Files |
+|---------|---------------------|----------------|
+| `project.exec { }` in task actions | `ProcessBuilder` directly | `GtestPlugin.kt` |
+| `String.capitalize()` | `replaceFirstChar { it.uppercaseChar() }` | Kotlin plugins |
+| `createTempFile()` | `kotlin.io.path.createTempFile()` | `PlatformUtils.kt` |
+| Spotless `userData()` | `editorConfigOverride()` | `SpotlessConventionPlugin.kt` |
+| Spotless `indentWithSpaces()` | `leadingTabsToSpaces()` | `SpotlessConventionPlugin.kt` |
+
+### CI JDK Caching
+
+The CI caches JDKs via `.github/workflows/cache_java.yml`. When adding a new JDK version:
+1. Add version URLs to `cache_java.yml` environment variables
+2. Add to the `java_variant` matrix in cache jobs
+3. Run the `cache_java.yml` workflow manually to populate caches
 
 ## Agentic Work
 
@@ -623,11 +682,11 @@ See `gradle.properties.template` for all options. Key ones:
       ```
     - Instead of:
       ```bash
-      ./gradlew :prof-utils:test --tests "UpscaledMethodSampleEventSinkTest"
+      ./gradlew :ddprof-test:testDebug -Ptests=MuslDetectionTest
       ```
       use:
       ```bash
-      ./.claude/commands/build-and-summarize :prof-utils:test --tests "UpscaledMethodSampleEventSinkTest"
+      ./.claude/commands/build-and-summarize :ddprof-test:testdebug -Ptests=MuslDetectionTest
       ```
 
 - This ensures the full build log is captured to a file and only a summary is shown in the main session.

README.md

@@ -9,8 +9,8 @@ If you need a full-fledged Java profiler head back to [async-profiler](https://g
 ## Build
 
 ### Prerequisites
-1. JDK 8 or later (required for building)
-2. Gradle (included in wrapper)
+1. JDK 21 or later (required for building - Gradle 9 requirement)
+2. Gradle 9.3.1 (included in wrapper)
 3. C++ compiler (clang++ preferred, g++ supported)
    - Build system auto-detects clang++ or g++
    - Override with: `./gradlew build -Pnative.forceCompiler=g++`

build-logic/conventions/build.gradle.kts

@@ -9,7 +9,7 @@ repositories {
 
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-stdlib")
-    implementation("com.diffplug.spotless:spotless-plugin-gradle:6.11.0")
+    implementation("com.diffplug.spotless:spotless-plugin-gradle:7.0.2")
 }
 
 gradlePlugin {

build-logic/conventions/src/main/kotlin/com/datadoghq/native/gtest/GtestPlugin.kt

@@ -142,13 +142,18 @@ class GtestPlugin : Plugin<Project> {
                     val libDir = File("$targetDir/$libName")
                     val libSrcDir = File("$srcDir/$libName")
 
-                    project.exec {
-                        commandLine("sh", "-c", """
-                            echo "Processing library: $libName @ $libSrcDir"
-                            mkdir -p $libDir
-                            cd $libSrcDir
-                            make TARGET_DIR=$libDir
-                        """.trimIndent())
+                    // Use ProcessBuilder directly (Gradle 9 removed project.exec in task actions)
+                    val process = ProcessBuilder("sh", "-c", """
+                        echo "Processing library: $libName @ $libSrcDir"
+                        mkdir -p $libDir
+                        cd $libSrcDir
+                        make TARGET_DIR=$libDir
+                    """.trimIndent())
+                        .inheritIO()
+                        .start()
+                    val exitCode = process.waitFor()
+                    if (exitCode != 0) {
+                        throw org.gradle.api.GradleException("Failed to build native lib: $libName (exit code: $exitCode)")
                     }
                 }
             }

build-logic/conventions/src/main/kotlin/com/datadoghq/native/util/PlatformUtils.kt

@@ -6,6 +6,9 @@ import com.datadoghq.native.model.Platform
 import org.gradle.api.GradleException
 import org.gradle.api.Project
 import java.io.File
+import kotlin.io.path.createTempFile
+import kotlin.io.path.deleteIfExists
+import kotlin.io.path.writeText
 import java.util.concurrent.TimeUnit
 
 object PlatformUtils {
@@ -83,31 +86,43 @@ object PlatformUtils {
             return null
         }
 
-        return try {
-            // Try the specified compiler first, fall back to gcc
-            val compilerToUse = if (isCompilerAvailable(compiler)) {
-                compiler
-            } else if (compiler != "gcc" && isCompilerAvailable("gcc")) {
-                "gcc"
-            } else {
-                return null
+        // Try the specified compiler first
+        if (isCompilerAvailable(compiler)) {
+            try {
+                val process = ProcessBuilder(compiler, "-print-file-name=$libName.so")
+                    .redirectErrorStream(true)
+                    .start()
+
+                val output = process.inputStream.bufferedReader().readText().trim()
+                process.waitFor()
+
+                if (process.exitValue() == 0 && output != "$libName.so") {
+                    return output
+                }
+            } catch (e: Exception) {
+                // Fall through to try gcc
             }
+        }
 
-            val process = ProcessBuilder(compilerToUse, "-print-file-name=$libName.so")
-                .redirectErrorStream(true)
-                .start()
+        // If the specified compiler didn't find it, try gcc as fallback
+        if (compiler != "gcc" && isCompilerAvailable("gcc")) {
+            try {
+                val process = ProcessBuilder("gcc", "-print-file-name=$libName.so")
+                    .redirectErrorStream(true)
+                    .start()
 
-            val output = process.inputStream.bufferedReader().readText().trim()
-            process.waitFor()
+                val output = process.inputStream.bufferedReader().readText().trim()
+                process.waitFor()
 
-            if (process.exitValue() == 0 && !output.endsWith("$libName.so")) {
-                output
-            } else {
-                null
+                if (process.exitValue() == 0 && output != "$libName.so") {
+                    return output
+                }
+            } catch (e: Exception) {
+                // Fall through to return null
             }
-        } catch (e: Exception) {
-            null
         }
+
+        return null
     }
 
     fun locateLibasan(compiler: String = "gcc"): String? = locateLibrary("libasan", compiler)
@@ -124,15 +139,15 @@ object PlatformUtils {
                     "clang++",
                     "-fsanitize=fuzzer",
                     "-c",
-                    testFile.absolutePath,
+                    testFile.toAbsolutePath().toString(),
                     "-o",
                     "/dev/null"
                 ).redirectErrorStream(true).start()
 
                 process.waitFor()
                 process.exitValue() == 0
             } finally {
-                testFile.delete()
+                testFile.deleteIfExists()
             }
         } catch (e: Exception) {
             false

build-logic/conventions/src/main/kotlin/com/datadoghq/profiler/JavaConventionsPlugin.kt

@@ -10,8 +10,9 @@ import org.gradle.api.tasks.compile.JavaCompile
  *
  * Applies standard Java compilation options across all subprojects:
  * - Java 8 release target for broad JVM compatibility
+ * - Suppresses JDK 21+ deprecation warnings for --release 8
  *
- * Requires JDK 9+ for building (uses --release flag).
+ * Requires JDK 21+ for building (Gradle 9 requirement).
  * The compiled bytecode targets Java 8 runtime.
  *
  * Usage:
@@ -23,18 +24,10 @@ import org.gradle.api.tasks.compile.JavaCompile
  */
 class JavaConventionsPlugin : Plugin<Project> {
     override fun apply(project: Project) {
-        val javaVersion = System.getProperty("java.specification.version")?.toDoubleOrNull() ?: 0.0
-
         project.tasks.withType(JavaCompile::class.java).configureEach {
-            if (javaVersion >= 9) {
-                // JDK 9+ supports --release flag which handles source, target, and boot classpath
-                options.compilerArgs.addAll(listOf("--release", "8"))
-            } else {
-                // Fallback for JDK 8 (not recommended for building)
-                sourceCompatibility = "8"
-                targetCompatibility = "8"
-                project.logger.warn("Building with JDK 8 is not recommended. Use JDK 11+ with --release 8 for better compatibility.")
-            }
+            // JDK 21+ deprecated --release 8 with warnings; suppress with -Xlint:-options
+            // The deprecation is informational - Java 8 targeting still works
+            options.compilerArgs.addAll(listOf("--release", "8", "-Xlint:-options"))
         }
     }
 }