fix: emit Thread.sleep TaskBlocks for never-attached threads

Author: kaahos

dd-java-agent/agent-profiling/profiling-ddprof/src/main/java/com/datadog/profiling/ddprof/DatadogProfilingIntegration.java

@@ -34,8 +34,9 @@ public class DatadogProfilingIntegration implements ProfilingContextIntegration
 
   // --- Async TaskBlock recording infrastructure (Thread.sleep deferred path) ---
 
-  // Pre-cached native tid per traced thread; populated in onAttach() to avoid repeated JNI on
-  // the hot path. Reading a ThreadLocal is pure Java once the value is set.
+  // Pre-cached native tid per thread. Traced threads populate this in onAttach(); spanless
+  // Thread.sleep instrumentation lazily resolves it without calling onAttach(), because onAttach()
+  // also changes wall-clock thread filtering state.
   private static final ThreadLocal<Integer> NATIVE_TID = new ThreadLocal<>();
 
   private static final BigInteger NANOS_PER_SECOND = BigInteger.valueOf(1_000_000_000L);
@@ -109,6 +110,18 @@ public int getCurrentThreadId() {
     return tid != null ? tid : -1;
   }
 
+  private static int getOrResolveCurrentThreadId() {
+    Integer tid = NATIVE_TID.get();
+    if (tid != null) {
+      return tid;
+    }
+    int resolvedTid = DDPROF.getCurrentThreadId();
+    if (resolvedTid >= 0) {
+      NATIVE_TID.set(resolvedTid);
+    }
+    return resolvedTid;
+  }
+
   @Override
   public long blockEnter(int state) {
     return DDPROF.blockEnter(state);
@@ -143,7 +156,7 @@ public void enqueueTaskBlock(
     if (spanId != 0L) {
       return;
     }
-    int tid = getCurrentThreadId();
+    int tid = getOrResolveCurrentThreadId();
     if (tid < 0) {
       return;
     }

dd-java-agent/instrumentation/datadog/profiling/thread-sleep/src/main/java/datadog/trace/instrumentation/threadsleep/ThreadSleepProfilingInstrumentation.java

@@ -25,10 +25,10 @@
  * Caller-site rewriting is the Java-level way to bracket direct {@code Thread.sleep} call sites
  * with a TaskBlock interval.
  *
- * <p>Coverage is purely opt-in by the user's bytecode: any supported direct {@code
- * Thread.sleep(...)} call site in a non-JDK class is wrapped. {@code TimeUnit.sleep(long)} is
- * instrumented separately at the bootstrap method boundary. Reflection-driven sleeps and JNI-driven
- * sleeps remain uncovered (intentional: out-of-band call paths).
+ * <p>Coverage is purely opt-in by the user's bytecode: supported direct {@code Thread.sleep(...)}
+ * call sites in non-excluded classes are wrapped. {@code TimeUnit.sleep(long)} is instrumented
+ * separately at the bootstrap method boundary. Reflection-driven sleeps and JNI-driven sleeps
+ * remain uncovered (intentional: out-of-band call paths).
  *
  * <p>Active on every JDK when enabled via {@code profiling.ddprof.wall.precheck=true} (opt-in;
  * default is off). The native JVMTI monitor callbacks cover {@code Object.wait()} and synchronized

dd-smoke-tests/profiling-integration-tests/src/test/java/com/datadog/smoketest/profiling/ThreadSleepTaskBlockForkedApp.java

@@ -18,6 +18,7 @@ public static void main(String[] args) throws Exception {
     app.runSubThresholdSleeps();
     Thread.currentThread().setName("threadsleep-spanless");
     app.runSpanlessSleeps();
+    app.runNeverAttachedSpanlessSleeps();
     Thread.sleep(1500);
   }
 
@@ -44,6 +45,23 @@ private void runSpanlessSleeps() throws InterruptedException {
     }
   }
 
+  private void runNeverAttachedSpanlessSleeps() throws InterruptedException {
+    Thread thread =
+        new Thread(
+            () -> {
+              try {
+                for (int i = 0; i < SLEEP_ITERATIONS; i++) {
+                  Thread.sleep(LONG_SLEEP_MILLIS);
+                }
+              } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+              }
+            },
+            "threadsleep-never-attached");
+    thread.start();
+    thread.join();
+  }
+
   private void runSubThresholdSleeps() throws InterruptedException {
     for (int i = 0; i < SLEEP_ITERATIONS; i++) {
       Span span = tracer.buildSpan("threadsleep.short").start();

dd-smoke-tests/profiling-integration-tests/src/test/java/datadog/smoketest/ThreadSleepTaskBlockProfilingTest.java

@@ -91,6 +91,9 @@ void threadSleepEmitsTaskBlockEvents() throws Exception {
     assertTrue(
         stats.spanlessTaskBlockCount > 0,
         "Expected datadog.TaskBlock events from spanless Thread.sleep call sites");
+    assertTrue(
+        stats.neverAttachedTaskBlockCount > 0,
+        "Expected datadog.TaskBlock events from never-attached spanless Thread.sleep call sites");
     assertFalse(stats.hasActiveSpanTaskBlock, "Active-span sleeps must not emit TaskBlock events");
     assertFalse(stats.hasNonZeroSpanId, "Spanless TaskBlock events must carry zero spanId");
     assertFalse(
@@ -243,6 +246,7 @@ private boolean logHasInstrumentationError() throws IOException {
   /** Aggregate counts/flags collected across all JFR streams produced by the forked process. */
   private static final class JfrStats {
     long spanlessTaskBlockCount;
+    long neverAttachedTaskBlockCount;
     boolean hasActiveSpanTaskBlock;
     boolean hasNonZeroSpanId;
     boolean hasNonZeroLocalRootSpanId;
@@ -264,12 +268,18 @@ void add(IItemCollection events) {
             hasActiveSpanTaskBlock = true;
             continue;
           }
-          if (!"threadsleep-spanless".equals(threadName)) {
+          boolean spanlessThread = "threadsleep-spanless".equals(threadName);
+          boolean neverAttachedThread = "threadsleep-never-attached".equals(threadName);
+          if (!spanlessThread && !neverAttachedThread) {
             continue;
           }
           long spanId = span.getMember(item).longValue();
           long rootSpanId = root.getMember(item).longValue();
-          spanlessTaskBlockCount++;
+          if (spanlessThread) {
+            spanlessTaskBlockCount++;
+          } else {
+            neverAttachedTaskBlockCount++;
+          }
           hasNonZeroSpanId |= spanId != 0L;
           hasNonZeroLocalRootSpanId |= rootSpanId != 0L;
           hasMissingEventThread |= threadName == null || threadName.isEmpty();