Unified test execution with platform-conditional tasks

Implements platform-conditional test execution to support both glibc/macOS
and musl environments with a unified -Ptests interface.

Changes:
- Add ProfilerTestRunner with JUnit Platform Launcher API
- Create Test tasks on glibc/macOS, Exec tasks on musl
- Fix JDK 11 + musl by removing LD_LIBRARY_PATH (prevents cross-JDK library loading)
- Support both . and # method separators with proper heuristic
- Update all docs to use -Ptests syntax consistently
- Add warning when --tests flag used on Test tasks
- Switch from junit-platform-console to junit-platform-launcher
- Add build-logic to Dependabot monitoring
- Improve error handling in javadocJar task

Verified on musl + JDK 11, musl + JDK 21, and macOS.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: jbachorik

.github/dependabot.yml

@@ -1,6 +1,6 @@
 version: 2
 updates:
-  # Gradle dependencies
+  # Gradle dependencies (root project)
   - package-ecosystem: "gradle"
     directory: "/"
     schedule:
@@ -13,6 +13,19 @@ updates:
           - "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: "/"

AGENTS.md

@@ -274,17 +274,21 @@ Release builds automatically extract debug symbols:
 ## Development Workflow
 
 ### Running Single Tests
-Use Gradle's standard `--tests` flag across all platforms:
+Use the `-Ptests` property across all platforms:
 ```bash
-./gradlew :ddprof-test:testdebug --tests=ClassName.methodName  # Single method
-./gradlew :ddprof-test:testdebug --tests=ClassName              # Entire class
-./gradlew :ddprof-test:testdebug --tests="*.ClassName"          # Pattern matching
+./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 direct `--tests` flag support
-- **musl (Alpine)**: Test tasks delegate to Exec tasks internally (workaround for Gradle 9 toolchain probe issues on musl)
-- **Result**: Unified `--tests` flag works identically across all platforms, no platform-specific syntax required
+- **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:
@@ -678,11 +682,11 @@ The CI caches JDKs via `.github/workflows/cache_java.yml`. When adding a new JDK
       ```
     - Instead of:
       ```bash
-      ./gradlew :ddprof-test:testdebug --tests=MuslDetectionTest
+      ./gradlew :ddprof-test:testdebug -Ptests=MuslDetectionTest
       ```
       use:
       ```bash
-      ./.claude/commands/build-and-summarize :ddprof-test:testdebug --tests=MuslDetectionTest
+      ./.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.

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

@@ -24,21 +24,27 @@ import javax.inject.Inject
  * - Standard JVM arguments for profiler testing (attach self, error files, etc.)
  * - Java executable selection (JAVA_TEST_HOME or JAVA_HOME) on ALL platforms
  * - Common environment variables (CI, rate limiting)
- * - Unified --tests flag support across all platforms
+ * - Unified -Ptests flag support across all platforms
  * - Automatic multi-config test task generation from NativeBuildExtension
  *
  * Implementation:
- * - glibc/macOS: Uses native Test tasks with direct --tests flag support
- * - musl (Alpine): Uses Test tasks that delegate to Exec tasks (workaround for Gradle 9 toolchain probe)
- * - Unified interface: --tests flag works identically on all platforms
+ * - glibc/macOS: Uses native Test tasks with Gradle's JUnit Platform integration
+ * - musl (Alpine): Uses Exec tasks with custom ProfilerTestRunner (bypasses toolchain probe)
+ * - Unified interface: -Ptests property works identically on all platforms
  * - Supports multi-JDK testing via JAVA_TEST_HOME on all platforms
  * - Same task names everywhere (testdebug, testrelease, unwindingReportRelease)
  *
  * Platform Detection:
  * - Uses PlatformUtils.isMusl() at configuration time to select task implementation
- * - musl systems: Test task captures --tests filter, delegates to hidden Exec task
+ * - musl systems: Exec task with ProfilerTestRunner (uses JUnit Platform Launcher API directly)
  * - glibc/macOS: Normal Test task with native JUnit integration
  *
+ * Custom Test Runner:
+ * - ProfilerTestRunner uses JUnit Platform Launcher API directly
+ * - Avoids Console Launcher issues (assertions, JVM args, NoSuchMethodError on musl + JDK 11)
+ * - Same API used by IDEs and Gradle's Test task internally
+ * - Supports test filtering via -Dtest.filter system property
+ *
  * Usage:
  * ```kotlin
  * plugins {
@@ -63,7 +69,9 @@ import javax.inject.Inject
  * }
  *
  * // Run tests (all platforms use same syntax):
- * ./gradlew :ddprof-test:testdebug --tests=ClassName.methodName
+ * ./gradlew :ddprof-test:testdebug -Ptests=ClassName.methodName
+ * ./gradlew :ddprof-test:testdebug -Ptests=ClassName
+ * ./gradlew :ddprof-test:testdebug -Ptests="*.Pattern*"
  * ```
  */
 class ProfilerTestPlugin : Plugin<Project> {
@@ -162,7 +170,7 @@ class ProfilerTestPlugin : Plugin<Project> {
 
     /**
      * Create native Test task for glibc/macOS (normal path).
-     * Uses Gradle's Test task with --tests flag support.
+     * Uses Gradle's Test task with -Ptests property support.
      */
     private fun createTestTask(
         project: Project,
@@ -192,9 +200,7 @@ class ProfilerTestPlugin : Plugin<Project> {
             // Configure Java executable - bypasses toolchain system
             testTask.setExecutable(PlatformUtils.testJavaExecutable())
 
-            // Environment variables
-            testTask.environment("DDPROF_TEST_DISABLE_RATE_LIMIT", "1")
-            testTask.environment("CI", project.hasProperty("CI") || System.getenv("CI")?.toBoolean() ?: false)
+            // Environment variables (from testConfig which already includes DDPROF_TEST_DISABLE_RATE_LIMIT and CI)
             testConfig.environmentVariables.forEach { (key, value) ->
                 testTask.environment(key, value)
             }
@@ -206,6 +212,25 @@ class ProfilerTestPlugin : Plugin<Project> {
                 logging.showStandardStreams = true
             }
 
+            // UNIFIED INTERFACE: Support -Ptests property (same as musl)
+            val testsFilter = project.findProperty("tests") as String?
+            if (testsFilter != null) {
+                // Forward -Ptests to Test task's filter
+                testTask.filter.includeTestsMatching(testsFilter)
+            }
+
+            // Warn if --tests flag was used instead of -Ptests
+            testTask.doFirst {
+                val filterPatterns = testTask.filter.includePatterns
+                if (filterPatterns.isNotEmpty() && testsFilter == null) {
+                    project.logger.warn("")
+                    project.logger.warn("WARNING: --tests flag detected. While it works on glibc/macOS, it will FAIL on musl systems.")
+                    project.logger.warn("For consistent behavior across all platforms, please use -Ptests instead:")
+                    project.logger.warn("  ./gradlew :ddprof-test:${testTask.name} -Ptests=${filterPatterns.first()}")
+                    project.logger.warn("")
+                }
+            }
+
             // JVM arguments and system properties - configure in doFirst like main does
             testTask.doFirst {
                 val allArgs = mutableListOf<String>()
@@ -232,6 +257,90 @@ class ProfilerTestPlugin : Plugin<Project> {
         }
     }
 
+    /**
+     * Create Exec task with custom test runner for musl platforms.
+     * Uses ProfilerTestRunner with JUnit Platform Launcher API directly.
+     * Supports unified -Ptests property interface for test filtering.
+     */
+    private fun createExecTestTask(
+        project: Project,
+        extension: ProfilerTestExtension,
+        testConfig: TestTaskConfiguration,
+        testCfg: Configuration,
+        sourceSets: SourceSetContainer
+    ) {
+        project.tasks.register("test${testConfig.configName}", Exec::class.java) {
+            val execTask = this
+            execTask.description = "Runs unit tests with the ${testConfig.configName} library variant (musl workaround)"
+            execTask.group = "verification"
+            execTask.onlyIf { testConfig.isActive && !project.hasProperty("skip-tests") }
+
+            // Dependencies
+            execTask.dependsOn(project.tasks.named("compileTestJava"))
+            execTask.dependsOn(testCfg)
+            execTask.dependsOn(sourceSets.getByName("test").output)
+
+            // Configure at execution time to capture -Ptests filter
+            execTask.doFirst {
+                execTask.executable = PlatformUtils.testJavaExecutable()
+
+                val allArgs = mutableListOf<String>()
+
+                // JVM args
+                allArgs.addAll(testConfig.standardJvmArgs)
+                if (extension.nativeLibDir.isPresent) {
+                    allArgs.add("-Djava.library.path=${extension.nativeLibDir.get().asFile.absolutePath}")
+                }
+                allArgs.addAll(testConfig.extraJvmArgs)
+
+                // System properties
+                testConfig.systemProperties.forEach { (key, value) ->
+                    allArgs.add("-D$key=$value")
+                }
+
+                // UNIFIED INTERFACE: Test filter from -Ptests property
+                val testsFilter = project.findProperty("tests") as String?
+                if (testsFilter != null) {
+                    allArgs.add("-Dtest.filter=$testsFilter")
+                }
+
+                // Classpath (includes custom test runner)
+                allArgs.add("-cp")
+                allArgs.add(testConfig.testClasspath.asPath)
+
+                // Use custom test runner (NOT ConsoleLauncher)
+                allArgs.add("com.datadoghq.profiler.test.ProfilerTestRunner")
+
+                execTask.args = allArgs
+
+                // Debug logging
+                project.logger.info("Exec task: ${execTask.executable} with ${testConfig.testClasspath.files.size} classpath entries")
+            }
+
+            // Environment variables
+            testConfig.environmentVariables.forEach { (key, value) ->
+                execTask.environment(key, value)
+            }
+
+            // CRITICAL FIX: Remove LD_LIBRARY_PATH to let RPATH work correctly
+            // The test JDK's launcher has RPATH set to find its own libraries ($ORIGIN/../lib/jli)
+            // But LD_LIBRARY_PATH overrides RPATH and causes it to load the wrong libjli.so
+            // Solution: Unset LD_LIBRARY_PATH entirely to let RPATH take precedence
+            execTask.doFirst {
+                val currentLdLibPath = (execTask.environment["LD_LIBRARY_PATH"] as? String) ?: System.getenv("LD_LIBRARY_PATH")
+                if (!currentLdLibPath.isNullOrEmpty()) {
+                    project.logger.info("Removing LD_LIBRARY_PATH to prevent cross-JDK library conflicts (was: $currentLdLibPath)")
+                    execTask.environment.remove("LD_LIBRARY_PATH")
+                }
+            }
+
+            // Sanitizer conditions
+            when (testConfig.configName) {
+                "asan" -> execTask.onlyIf { PlatformUtils.locateLibasan() != null }
+                "tsan" -> execTask.onlyIf { PlatformUtils.locateLibtsan() != null }
+            }
+        }
+    }
 
     private fun generateMultiConfigTasks(project: Project, extension: ProfilerTestExtension) {
         val nativeBuildExt = project.rootProject.extensions.findByType(NativeBuildExtension::class.java)
@@ -289,10 +398,16 @@ class ProfilerTestPlugin : Plugin<Project> {
             // Build shared configuration
             val testConfig = buildTestConfiguration(project, extension, config, testCfg, sourceSets)
 
-            // Use Test tasks on all platforms
-            // Setting executable directly bypasses Gradle's toolchain probing
-            project.logger.info("Creating Test task for $configName")
-            createTestTask(project, extension, testConfig, testCfg, sourceSets)
+            // Platform-conditional task creation
+            // Check both PlatformUtils.isMusl() and LIBC environment variable (set by Docker)
+            val isMuslSystem = PlatformUtils.isMusl() || System.getenv("LIBC") == "musl"
+            if (isMuslSystem) {
+                project.logger.info("Creating Exec task for $configName (musl workaround, LIBC=${System.getenv("LIBC")})")
+                createExecTestTask(project, extension, testConfig, testCfg, sourceSets)
+            } else {
+                project.logger.info("Creating Test task for $configName (glibc/macOS, LIBC=${System.getenv("LIBC")})")
+                createTestTask(project, extension, testConfig, testCfg, sourceSets)
+            }
 
             // Create application tasks for specified configs
             if (configName in applicationConfigs && appMainClass.isNotEmpty()) {

ddprof-lib/build.gradle.kts

@@ -185,7 +185,9 @@ val javadocJar by tasks.registering(Jar::class) {
   archiveBaseName.set(libraryName)
   archiveClassifier.set("javadoc")
   archiveVersion.set(componentVersion)
-  from(tasks.javadoc.map { it.destinationDir!! })
+  from(tasks.javadoc.map {
+    it.destinationDir ?: throw GradleException("Javadoc task destinationDir is null - task may not have been configured properly")
+  })
 }
 
 // Publishing configuration

ddprof-stresstest/README.md

@@ -230,10 +230,10 @@ Use reduced iterations:
 ### Profiler fails to start
 Verify profiler library loads:
 ```bash
-./gradlew :ddprof-test:testdebug --tests=JavaProfilerTest.testGetInstance
+./gradlew :ddprof-test:testdebug -Ptests=JavaProfilerTest.testGetInstance
 ```
 
-**Note**: The `--tests` flag works uniformly across all platforms with config-specific test tasks.
+**Note**: The `-Ptests` property works uniformly across all platforms with config-specific test tasks.
 
 ### Out of memory errors
 - Reduce concurrent thread counts