Debug freezing test on CI.

.gitlab/collect_reports.sh

@@ -62,6 +62,7 @@ function process_reports () {
       cp -r workspace/$project_to_save/build/reports/* $report_path/ 2>/dev/null || true
       cp workspace/$project_to_save/build/hs_err_pid*.log $report_path/ 2>/dev/null || true
       cp workspace/$project_to_save/build/javacore*.txt $report_path/ 2>/dev/null || true
+      cp workspace/$project_to_save/build/*.* $report_path/ 2>/dev/null || true
     fi
 }
 

dd-java-agent/instrumentation/java-concurrent/java-concurrent-21/build.gradle

@@ -1,3 +1,6 @@
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+
 ext {
   minJavaVersionForTests = JavaVersion.VERSION_21
   // Structured concurrency is a preview feature in Java 21. Methods (e.g. ShutdownOnFailure) used in this instrumentation test are no longer available in Java 25, so we set the max version to 24.
@@ -56,3 +59,75 @@ compileJava.configure {
   sourceCompatibility = JavaVersion.VERSION_1_8
   targetCompatibility = JavaVersion.VERSION_1_8
 }
+
+tasks.withType(Test).configureEach {
+  doFirst {
+    String fullPath = layout.buildDirectory.asFile.get().absolutePath.replace("dd-trace-java/dd-java-agent",
+      "dd-trace-java/workspace/dd-java-agent")
+    println "DEBUG full path: ${fullPath}"
+
+    def outDir = new File(fullPath)
+    outDir.mkdirs()
+    def outFile = new File(outDir, "${System.currentTimeMillis()}-thread-dump.log")
+
+    // single-thread scheduler (daemon)
+    def scheduler = Executors.newSingleThreadScheduledExecutor({ r ->
+      Thread t = new Thread(r, "dump-scheduler")
+      t.setDaemon(true)
+      return t
+    })
+
+    // schedule the dump job 10s later
+    def future = scheduler.schedule({
+      try {
+        println "DEBUG threads dump: ${outFile.absolutePath}"
+
+        new ProcessBuilder("jcmd", "0", "Thread.print", "-l")
+          .redirectErrorStream(true)
+          .redirectOutput(outFile)
+          .start().waitFor()
+
+        println "DEBUG heap dumps"
+        def listOutput = "jcmd -l".execute().text.readLines()
+        listOutput.each { line ->
+          println "DEBUG PID: ${line}"
+
+          if (!line.contains("gradle")) {
+            return
+          }
+
+          def pid = line.substring(0, line.indexOf(' '))
+
+          def dumpFileName = "${fullPath}/${System.currentTimeMillis()}-${pid}.hprof"
+
+          println "DEBUG dump file name: ${dumpFileName}"
+
+          def cmd = "jcmd ${pid} GC.heap_dump ${dumpFileName}"
+
+          println "DEBUG jcmd: ${cmd}"
+
+          def res = cmd.execute().waitFor()
+
+          println "DEBUG dump res: ${res}"
+        }
+      } catch (Throwable t) {
+        logger.warn("Dumping failed: ${t.message}", t)
+      } finally {
+        scheduler.shutdown()
+      }
+    }, 62, TimeUnit.SECONDS)
+
+    // store handles for cancellation in doLast
+    ext.dumpFuture = future
+    ext.dumpScheduler = scheduler
+  }
+
+  doLast {
+    // cancel if task completed in <10s
+    try {
+      ext.dumpFuture?.cancel(false)
+    } finally {
+      ext.dumpScheduler?.shutdownNow()
+    }
+  }
+}

dd-java-agent/instrumentation/java-concurrent/java-concurrent-21/src/previewTest/groovy/StructuredConcurrencyTest.groovy

@@ -1,6 +1,11 @@
+import com.sun.management.HotSpotDiagnosticMXBean
 import datadog.trace.agent.test.AgentTestRunner
 import datadog.trace.api.Trace
 
+import javax.management.MBeanServer
+import java.lang.management.ManagementFactory
+import java.lang.management.ThreadInfo
+import java.lang.management.ThreadMXBean
 import java.util.concurrent.Callable
 import java.util.concurrent.StructuredTaskScope
 
@@ -9,10 +14,18 @@ import static datadog.trace.agent.test.utils.TraceUtils.runnableUnderTrace
 import static java.time.Instant.now
 
 class StructuredConcurrencyTest extends AgentTestRunner {
-  @Override
-  boolean useStrictTraceWrites() {
-    // TODO: Monitor in CI to validate fix effectiveness against freezes.
-    return false
+  ThreadDumpLogger threadDumpLogger
+
+  def setup() {
+    // Use the current feature name as the test name
+    String testName = "${specificationContext?.currentSpec?.name ?: "unknown-spec"} : ${specificationContext?.currentFeature?.name ?: "unknown-test"}"
+
+    threadDumpLogger = new ThreadDumpLogger(testName)
+    threadDumpLogger.start()
+  }
+
+  def cleanup() {
+    threadDumpLogger.stop()
   }
 
   /**
@@ -170,4 +183,72 @@ class StructuredConcurrencyTest extends AgentTestRunner {
       }
     }
   }
+
+  // 🔒 Private helper class for thread dump logging
+  private static class ThreadDumpLogger {
+    private final String testName
+    private Thread task
+
+    ThreadDumpLogger(String testName) {
+      this.testName = testName
+    }
+
+    void start() {
+      task = new Thread() {
+          @Override
+          void run() {
+            sleep(20000)
+
+            File outputDir = new File("build")
+            String fullPath = outputDir.absolutePath.replace("dd-trace-java/dd-java-agent",
+            "dd-trace-java/workspace/dd-java-agent")
+
+            outputDir = new File(fullPath)
+            if (!outputDir.exists()) {
+              println("Folder not found: " + fullPath)
+              outputDir.mkdirs()
+            } else println("Folder found: " + fullPath)
+
+            // Use the current feature name as the test name
+            println("Test name: " + testName)
+
+            heapDump(outputDir, "test_1")
+
+            def reportFile = new File(outputDir, "${System.currentTimeMillis()}-thread-dump.log")
+
+            try (def writer = new FileWriter(reportFile)) {
+              writer.write("=== Test: ${testName} ===\n")
+              writer.write("=== Thread Dump Triggered at ${new Date()} ===\n")
+              writer.write(threadDump(false, false))
+              writer.write("==============================================\n")
+            }
+
+            heapDump(outputDir, "test_2")
+          }
+        }
+      task.start()
+    }
+
+    static void heapDump(File outputDir, String kind) {
+      def heapDumpFile = new File(outputDir, "${System.currentTimeMillis()}-heap-dump-${kind}.hprof").absolutePath
+      MBeanServer server = ManagementFactory.getPlatformMBeanServer()
+      HotSpotDiagnosticMXBean mxBean = ManagementFactory.newPlatformMXBeanProxy(
+        server, "com.sun.management:type=HotSpotDiagnostic", HotSpotDiagnosticMXBean.class)
+      mxBean.dumpHeap(heapDumpFile, true)
+    }
+
+    private static String threadDump(boolean lockedMonitors, boolean lockedSynchronizers) {
+      StringBuffer threadDump = new StringBuffer(System.lineSeparator())
+      ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean()
+      for(ThreadInfo threadInfo : threadMXBean.dumpAllThreads(lockedMonitors, lockedSynchronizers)) {
+        threadDump.append(threadInfo.toString())
+      }
+
+      return threadDump.toString()
+    }
+
+    void stop() {
+      task?.interrupt()
+    }
+  }
 }

dd-java-agent/instrumentation/lettuce-4/build.gradle

@@ -1,3 +1,5 @@
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
 
 muzzle {
   pass {
@@ -20,3 +22,75 @@ dependencies {
 
   latestDepTestImplementation group: 'biz.paluch.redis', name: 'lettuce', version: '4.+'
 }
+
+tasks.withType(Test).configureEach {
+  doFirst {
+    String fullPath = layout.buildDirectory.asFile.get().absolutePath.replace("dd-trace-java/dd-java-agent",
+      "dd-trace-java/workspace/dd-java-agent")
+    println "DEBUG full path: ${fullPath}"
+
+    def outDir = new File(fullPath)
+    outDir.mkdirs()
+    def outFile = new File(outDir, "${System.currentTimeMillis()}-thread-dump.log")
+
+    // single-thread scheduler (daemon)
+    def scheduler = Executors.newSingleThreadScheduledExecutor({ r ->
+      Thread t = new Thread(r, "dump-scheduler")
+      t.setDaemon(true)
+      return t
+    })
+
+    // schedule the dump job 10s later
+    def future = scheduler.schedule({
+      try {
+        println "DEBUG threads dump: ${outFile.absolutePath}"
+
+        new ProcessBuilder("jcmd", "0", "Thread.print", "-l")
+          .redirectErrorStream(true)
+          .redirectOutput(outFile)
+          .start().waitFor()
+
+        println "DEBUG heap dumps"
+        def listOutput = "jcmd -l".execute().text.readLines()
+        listOutput.each { line ->
+          println "DEBUG PID: ${line}"
+
+          if (!line.contains("gradle")) {
+            return
+          }
+
+          def pid = line.substring(0, line.indexOf(' '))
+
+          def dumpFileName = "${fullPath}/${System.currentTimeMillis()}-${pid}.hprof"
+
+          println "DEBUG dump file name: ${dumpFileName}"
+
+          def cmd = "jcmd ${pid} GC.heap_dump ${dumpFileName}"
+
+          println "DEBUG jcmd: ${cmd}"
+
+          def res = cmd.execute().waitFor()
+
+          println "DEBUG dump res: ${res}"
+        }
+      } catch (Throwable t) {
+        logger.warn("Dumping failed: ${t.message}", t)
+      } finally {
+        scheduler.shutdown()
+      }
+    }, 62, TimeUnit.SECONDS)
+
+    // store handles for cancellation in doLast
+    ext.dumpFuture = future
+    ext.dumpScheduler = scheduler
+  }
+
+  doLast {
+    // cancel if task completed in <10s
+    try {
+      ext.dumpFuture?.cancel(false)
+    } finally {
+      ext.dumpScheduler?.shutdownNow()
+    }
+  }
+}