Add testProcess{Config} task to accept user options

AGENTS.md

@@ -94,6 +94,8 @@ Never use 'gradle' or 'gradlew' directly. Instead, use the '/build-and-summarize
 ./gradlew testDebug
 ./gradlew testAsan
 ./gradlew testTsan
+./gradlew -Pprofiler.options=${user options} testProcessRelease
+./gradlew -Pprofiler.options=${user options} testProcessDebug
 
 # Run C++ unit tests only (via GtestPlugin)
 ./gradlew :ddprof-lib:gtestDebug        # All debug tests

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

@@ -356,6 +356,95 @@ class ProfilerTestPlugin : Plugin<Project> {
         }
     }
 
+    /**
+     * Create Exec-based test task that always runs in a separate process.
+     * Available on all platforms. Supports -Pprofiler.options for overriding profiler settings.
+     * Task name: testProcess<Config> (e.g., testProcessDebug, testProcessRelease)
+     */
+    private fun createProcessTestTask(
+        project: Project,
+        extension: ProfilerTestExtension,
+        testConfig: TestTaskConfiguration,
+        testCfg: Configuration,
+        sourceSets: SourceSetContainer
+    ) {
+        val taskName = "testProcess${testConfig.configName.replaceFirstChar { it.uppercase() }}"
+        project.tasks.register(taskName, Exec::class.java) {
+            val execTask = this
+            execTask.description = "Runs tests in separate process with ${testConfig.configName} library (supports -Pprofiler.options)"
+            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 properties
+            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")
+                }
+
+                // Test filter from -Ptests property
+                val testsFilter = project.findProperty("tests") as String?
+                if (testsFilter != null) {
+                    allArgs.add("-Dtest.filter=$testsFilter")
+                }
+
+                // Profiler options from -Pprofiler.options property
+                val profilerOptions = project.findProperty("profiler.options") as String?
+                if (profilerOptions != null) {
+                    allArgs.add("-Dddprof.test.options=$profilerOptions")
+                }
+
+                // Classpath
+                allArgs.add("-cp")
+                allArgs.add(testConfig.testClasspath.asPath)
+
+                // Use custom test runner
+                allArgs.add("com.datadoghq.profiler.test.ProfilerTestRunner")
+
+                execTask.args = allArgs
+            }
+
+            // Environment variables
+            testConfig.environmentVariables.forEach { (key, value) ->
+                execTask.environment(key, value)
+            }
+
+            // Remove LD_LIBRARY_PATH to let RPATH work correctly
+            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 &&
+                    !PlatformUtils.isTestJvmJ9()
+                }
+                "tsan" -> execTask.onlyIf { false }
+            }
+        }
+    }
+
     private fun generateMultiConfigTasks(project: Project, extension: ProfilerTestExtension) {
         val nativeBuildExt = project.rootProject.extensions.findByType(NativeBuildExtension::class.java)
             ?: return  // No native build extension, nothing to generate
@@ -423,6 +512,10 @@ class ProfilerTestPlugin : Plugin<Project> {
                 createTestTask(project, extension, testConfig, testCfg, sourceSets)
             }
 
+            // Create process-based test task (always uses Exec, available on all platforms)
+            // Supports -Pprofiler.options for overriding profiler settings
+            createProcessTestTask(project, extension, testConfig, testCfg, sourceSets)
+
             // Create application tasks for specified configs
             if (configName in applicationConfigs && appMainClass.isNotEmpty()) {
                 // Create main configuration

ddprof-test/src/test/java/com/datadoghq/profiler/AbstractProfilerTest.java

@@ -376,10 +376,67 @@ public final void registerCurrentThreadForWallClockProfiling() {
     profiler.addThread();
   }
 
+  /**
+   * Merges two profiler command strings. Options in overrides take precedence
+   * over options in base for matching keys.
+   *
+   * @param base The base profiler command (from test's getProfilerCommand())
+   * @param overrides The override options (from -Pprofiler.options)
+   * @return Merged command string with overrides taking precedence
+   */
+  private static String mergeProfilerOptions(String base, String overrides) {
+    if (overrides == null || overrides.isEmpty()) {
+      return base;
+    }
+
+    // Parse base options into ordered map
+    Map<String, String> options = new java.util.LinkedHashMap<>();
+    for (String part : base.split(",")) {
+      int eq = part.indexOf('=');
+      if (eq > 0) {
+        options.put(part.substring(0, eq), part.substring(eq + 1));
+      } else if (!part.isEmpty()) {
+        options.put(part, "");
+      }
+    }
+
+    // Apply overrides
+    for (String part : overrides.split(",")) {
+      int eq = part.indexOf('=');
+      if (eq > 0) {
+        options.put(part.substring(0, eq), part.substring(eq + 1));
+      } else if (!part.isEmpty()) {
+        options.put(part, "");
+      }
+    }
+
+    // Rebuild command
+    StringBuilder result = new StringBuilder();
+    for (Map.Entry<String, String> entry : options.entrySet()) {
+      if (result.length() > 0) {
+        result.append(",");
+      }
+      // Skip key with empty value
+      if (!entry.getValue().isEmpty()) {
+        result.append(entry.getKey());
+        result.append("=").append(entry.getValue());
+      }
+    }
+    return result.toString();
+  }
+
   private String getAmendedProfilerCommand() {
     String profilerCommand = getProfilerCommand();
+
+    // Apply user-provided options from -Pprofiler.options (override test defaults)
+    String userOptions = System.getProperty("ddprof.test.options");
+    if (userOptions != null && !userOptions.isEmpty()) {
+      profilerCommand = mergeProfilerOptions(profilerCommand, userOptions);
+      System.out.println("[TEST] Applied profiler.options: " + userOptions);
+    }
+
     String testCstack = (String)testParams.get("cstack");
-    if (testCstack != null) {
+    if (testCstack != null && !profilerCommand.contains("cstack=")) {
       profilerCommand += ",cstack=" + testCstack;
     } else if(!(ALLOW_NATIVE_CSTACKS || profilerCommand.contains("cstack="))) {
       profilerCommand += ",cstack=fp";