Also instruments {@link java.util.concurrent.locks.LockSupport#unpark} to capture the span ID + * of the unblocking thread, which is then recorded in the TaskBlock event. + * + *
{@code parkEnter} runs even without an active span (span id 0) so the native wall-clock
+ * precheck can suppress {@code SIGVTALRM} for the whole park interval. TaskBlock JFR emission is
+ * gated by the profiler on duration and span context.
+ */
+@AutoService(InstrumenterModule.class)
+public class LockSupportProfilingInstrumentation extends InstrumenterModule.Profiling
+ implements Instrumenter.ForKnownTypes, Instrumenter.HasMethodAdvice {
+
+ public LockSupportProfilingInstrumentation() {
+ super("lock-support");
+ }
+
+ @Override
+ public String[] knownMatchingTypes() {
+ return new String[] {"java.util.concurrent.locks.LockSupport"};
+ }
+
+ @Override
+ public String[] muzzleIgnoredClassNames() {
+ // Advice references this nested holder; it lives on the instrumentation classpath only.
+ return new String[] {getClass().getName() + "$State"};
+ }
+
+ @Override
+ public void methodAdvice(MethodTransformer transformer) {
+ transformer.applyAdvice(
+ isMethod()
+ .and(isStatic())
+ .and(nameStartsWith("park"))
+ .and(isDeclaredBy(named("java.util.concurrent.locks.LockSupport"))),
+ getClass().getName() + "$ParkAdvice");
+ transformer.applyAdvice(
+ isMethod()
+ .and(isStatic())
+ .and(ElementMatchers.named("unpark"))
+ .and(isDeclaredBy(named("java.util.concurrent.locks.LockSupport"))),
+ getClass().getName() + "$UnparkAdvice");
+ }
+
+ /** Holds shared state accessible from both {@link ParkAdvice} and {@link UnparkAdvice}. */
+ public static final class State {
+ /** Maps target thread to the span ID of the thread that called {@code unpark()} on it. */
+ public static final ConcurrentHashMap These tests exercise the {@link State} map directly, verifying the mechanism used to
+ * communicate the unblocking span ID from {@code UnparkAdvice} to {@code ParkAdvice}.
+ */
+class LockSupportProfilingInstrumentationTest {
+
+ @BeforeEach
+ void clearState() {
+ State.UNPARKING_SPAN.clear();
+ }
+
+ @AfterEach
+ void cleanupState() {
+ State.UNPARKING_SPAN.clear();
+ }
+
+ // -------------------------------------------------------------------------
+ // State map — basic contract
+ // -------------------------------------------------------------------------
+
+ @Test
+ void state_put_and_remove() {
+ Thread t = Thread.currentThread();
+ long spanId = 12345L;
+
+ State.UNPARKING_SPAN.put(t, spanId);
+ Long retrieved = State.UNPARKING_SPAN.remove(t);
+
+ assertNotNull(retrieved);
+ assertEquals(spanId, (long) retrieved);
+ // After removal the entry should be gone
+ assertNull(State.UNPARKING_SPAN.get(t));
+ }
+
+ @Test
+ void state_remove_returns_null_when_absent() {
+ Thread t = new Thread(() -> {});
+ assertNull(State.UNPARKING_SPAN.remove(t));
+ }
+
+ @Test
+ void state_is_initially_empty() {
+ assertTrue(State.UNPARKING_SPAN.isEmpty());
+ }
+
+ // -------------------------------------------------------------------------
+ // Multithreaded: unpark thread populates map, parked thread reads it
+ // -------------------------------------------------------------------------
+
+ /**
+ * Simulates the UnparkAdvice → ParkAdvice handoff:
+ *
+ * If {@code unpark(t)} is called (inserting an entry into {@code UNPARKING_SPAN}) and thread
+ * {@code t} then parks without an active span ({@code state == null}), the entry must still be
+ * drained. Without the fix, it would linger and be incorrectly attributed to the next {@code
+ * TaskBlock} emitted on that thread.
+ */
+ @Test
+ void stale_entry_is_drained_when_park_fires_without_active_span() {
+ Thread t = Thread.currentThread();
+ State.UNPARKING_SPAN.put(t, 99L);
+
+ // Simulate park() returning with no active span (state == null)
+ LockSupportProfilingInstrumentation.ParkAdvice.after(null);
+
+ assertNull(
+ State.UNPARKING_SPAN.get(t),
+ "Stale UNPARKING_SPAN entry must be drained even when state is null");
+ }
+
+ /**
+ * If multiple unpark calls race for the same parked thread, the latest span ID should be consumed
+ * and the entry must still be drained exactly once by ParkAdvice.after().
+ */
+ @Test
+ void latest_unparking_span_wins_and_entry_is_drained() {
+ Thread t = Thread.currentThread();
+ State.UNPARKING_SPAN.put(t, 101L);
+ State.UNPARKING_SPAN.put(t, 202L);
+
+ Long consumed = State.UNPARKING_SPAN.remove(t);
+ assertNotNull(consumed);
+ assertEquals(202L, consumed.longValue());
+ assertNull(State.UNPARKING_SPAN.get(t), "Entry must be removed after consumption");
+ }
+}
diff --git a/dd-java-agent/instrumentation/datadog/profiling/object-wait/build.gradle b/dd-java-agent/instrumentation/datadog/profiling/object-wait/build.gradle
new file mode 100644
index 00000000000..d61e8bd6155
--- /dev/null
+++ b/dd-java-agent/instrumentation/datadog/profiling/object-wait/build.gradle
@@ -0,0 +1,16 @@
+apply from: "$rootDir/gradle/java.gradle"
+
+testJvmConstraints {
+ minJavaVersion = JavaVersion.VERSION_21
+}
+
+muzzle {
+ pass {
+ coreJdk('21')
+ }
+}
+
+dependencies {
+ testImplementation libs.bundles.junit5
+ testImplementation libs.bundles.mockito
+}
diff --git a/dd-java-agent/instrumentation/datadog/profiling/object-wait/src/main/java/datadog/trace/instrumentation/objectwait/ObjectWaitProfilingInstrumentation.java b/dd-java-agent/instrumentation/datadog/profiling/object-wait/src/main/java/datadog/trace/instrumentation/objectwait/ObjectWaitProfilingInstrumentation.java
new file mode 100644
index 00000000000..a96357fe4a9
--- /dev/null
+++ b/dd-java-agent/instrumentation/datadog/profiling/object-wait/src/main/java/datadog/trace/instrumentation/objectwait/ObjectWaitProfilingInstrumentation.java
@@ -0,0 +1,142 @@
+package datadog.trace.instrumentation.objectwait;
+
+import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.isDeclaredBy;
+import static net.bytebuddy.matcher.ElementMatchers.isMethod;
+import static net.bytebuddy.matcher.ElementMatchers.takesArgument;
+import static net.bytebuddy.matcher.ElementMatchers.takesArguments;
+
+import com.google.auto.service.AutoService;
+import datadog.environment.JavaVirtualMachine;
+import datadog.trace.agent.tooling.Instrumenter;
+import datadog.trace.agent.tooling.InstrumenterModule;
+import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
+import datadog.trace.bootstrap.instrumentation.api.AgentTracer;
+import datadog.trace.bootstrap.instrumentation.api.ProfilerContext;
+import datadog.trace.bootstrap.instrumentation.api.ProfilingContextIntegration;
+import net.bytebuddy.asm.Advice;
+
+/**
+ * Instruments {@link Object#wait(long)} in JDK 21+ to emit {@code datadog.TaskBlock} JFR events.
+ *
+ * In JDK 21+, {@code wait(long)} is a pure-Java wrapper around the native {@code wait0(long)},
+ * so ByteBuddy can add advice to it. In JDK 8-20 the method is declared {@code native} and is not
+ * instrumented by this class (Approach 1 osThreadState precheck already suppresses SIGVTALRM for
+ * threads in OBJECT_WAIT state on all JDK versions).
+ *
+ * Only {@code wait(long)} is instrumented: {@code wait()} delegates to {@code wait(0L)} and
+ * {@code wait(long, int)} delegates to {@code wait(long)}, so all wait variants are covered.
+ *
+ * {@code unblockingSpanId} is always 0 because {@code notify()} and {@code notifyAll()} remain
+ * {@code native} in JDK 21+ and the notifying thread cannot be identified via BCI.
+ */
+@AutoService(InstrumenterModule.class)
+public class ObjectWaitProfilingInstrumentation extends InstrumenterModule.Profiling
+ implements Instrumenter.ForBootstrap, Instrumenter.ForKnownTypes, Instrumenter.HasMethodAdvice {
+
+ public ObjectWaitProfilingInstrumentation() {
+ super("object-wait");
+ }
+
+ @Override
+ public boolean isEnabled() {
+ return JavaVirtualMachine.isJavaVersionAtLeast(21) && super.isEnabled();
+ }
+
+ @Override
+ public String[] knownMatchingTypes() {
+ return new String[] {"java.lang.Object"};
+ }
+
+ @Override
+ public String[] muzzleIgnoredClassNames() {
+ // Static helpers on the advice class produce intra-class references that core-JDK muzzle
+ // cannot resolve against an empty application classpath.
+ return new String[] {getClass().getName() + "$WaitAdvice"};
+ }
+
+ @Override
+ public void methodAdvice(MethodTransformer transformer) {
+ transformer.applyAdvice(
+ isMethod()
+ .and(named("wait"))
+ .and(takesArguments(1))
+ .and(takesArgument(0, long.class))
+ .and(isDeclaredBy(named("java.lang.Object"))),
+ getClass().getName() + "$WaitAdvice");
+ }
+
+ public static final class WaitAdvice {
+
+ // 1 ms — matches the default LockSupport park threshold in parkExit0
+ static final long MIN_WAIT_NANOS = 1_000_000L;
+
+ // State array indices — package-private for readability in tests
+ static final int IDX_BLOCKER = 0;
+ static final int IDX_SPAN_ID = 1;
+ static final int IDX_ROOT_SPAN_ID = 2;
+ static final int IDX_START_TICKS = 3;
+ static final int IDX_START_NANOS = 4;
+
+ @Advice.OnMethodEnter(suppress = Throwable.class)
+ public static long[] before(@Advice.This Object monitor) {
+ return captureState(
+ monitor, AgentTracer.get().getProfilingContext(), AgentTracer.activeSpan());
+ }
+
+ @Advice.OnMethodExit(suppress = Throwable.class, onThrowable = Throwable.class)
+ public static void after(@Advice.Enter long[] state) {
+ if (state == null) {
+ return;
+ }
+ ProfilingContextIntegration profiling = AgentTracer.get().getProfilingContext();
+ if (profiling == null) {
+ return;
+ }
+ emitIfLongEnough(state, profiling);
+ }
+
+ /**
+ * Captures wait-entry state. Package-private to allow direct unit-testing without a live agent.
+ *
+ * @return a 5-element {@code long[]} on success, or {@code null} when the preconditions are not
+ * met (no profiling context, no active span, or span context is not a {@link
+ * ProfilerContext})
+ */
+ static long[] captureState(
+ Object monitor, ProfilingContextIntegration profiling, AgentSpan span) {
+ if (profiling == null) {
+ return null;
+ }
+ if (span == null || !(span.context() instanceof ProfilerContext)) {
+ return null;
+ }
+ ProfilerContext ctx = (ProfilerContext) span.context();
+ return new long[] {
+ System.identityHashCode(monitor), // [IDX_BLOCKER] monitor identity
+ ctx.getSpanId(), // [IDX_SPAN_ID]
+ ctx.getRootSpanId(), // [IDX_ROOT_SPAN_ID]
+ profiling.getCurrentTicks(), // [IDX_START_TICKS] TSC ticks for event timing
+ System.nanoTime() // [IDX_START_NANOS] wall-clock nanos for duration filter
+ };
+ }
+
+ /**
+ * Emits a TaskBlock event if the elapsed wall time since entry exceeds {@link #MIN_WAIT_NANOS}.
+ * Package-private to allow direct unit-testing without a live agent.
+ */
+ static void emitIfLongEnough(long[] state, ProfilingContextIntegration profiling) {
+ if (System.nanoTime() - state[IDX_START_NANOS] < MIN_WAIT_NANOS) {
+ return;
+ }
+ // unblockingSpanId = 0: notify/notifyAll are native in JDK 21+,
+ // so the notifying thread cannot be identified via BCI.
+ profiling.recordTaskBlock(
+ state[IDX_START_TICKS],
+ state[IDX_SPAN_ID],
+ state[IDX_ROOT_SPAN_ID],
+ state[IDX_BLOCKER],
+ 0L);
+ }
+ }
+}
diff --git a/dd-java-agent/instrumentation/datadog/profiling/object-wait/src/test/java/datadog/trace/instrumentation/objectwait/ObjectWaitProfilingInstrumentationTest.java b/dd-java-agent/instrumentation/datadog/profiling/object-wait/src/test/java/datadog/trace/instrumentation/objectwait/ObjectWaitProfilingInstrumentationTest.java
new file mode 100644
index 00000000000..e1e4f158fa2
--- /dev/null
+++ b/dd-java-agent/instrumentation/datadog/profiling/object-wait/src/test/java/datadog/trace/instrumentation/objectwait/ObjectWaitProfilingInstrumentationTest.java
@@ -0,0 +1,204 @@
+package datadog.trace.instrumentation.objectwait;
+
+import static datadog.trace.instrumentation.objectwait.ObjectWaitProfilingInstrumentation.WaitAdvice.IDX_BLOCKER;
+import static datadog.trace.instrumentation.objectwait.ObjectWaitProfilingInstrumentation.WaitAdvice.IDX_ROOT_SPAN_ID;
+import static datadog.trace.instrumentation.objectwait.ObjectWaitProfilingInstrumentation.WaitAdvice.IDX_SPAN_ID;
+import static datadog.trace.instrumentation.objectwait.ObjectWaitProfilingInstrumentation.WaitAdvice.IDX_START_NANOS;
+import static datadog.trace.instrumentation.objectwait.ObjectWaitProfilingInstrumentation.WaitAdvice.IDX_START_TICKS;
+import static datadog.trace.instrumentation.objectwait.ObjectWaitProfilingInstrumentation.WaitAdvice.MIN_WAIT_NANOS;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+
+import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
+import datadog.trace.bootstrap.instrumentation.api.AgentSpanContext;
+import datadog.trace.bootstrap.instrumentation.api.ProfilerContext;
+import datadog.trace.bootstrap.instrumentation.api.ProfilingContextIntegration;
+import datadog.trace.instrumentation.objectwait.ObjectWaitProfilingInstrumentation.WaitAdvice;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+// Combining both interfaces as span.context() return type is AgentSpanContext,
+// but production code casts it to ProfilerContext — both must be satisfied by the mock.
+// AgentSpanContext is the declared return type; ProfilerContext provides getSpanId/getRootSpanId.
+
+/**
+ * Unit tests for {@link ObjectWaitProfilingInstrumentation}.
+ *
+ * These tests exercise the two package-private helpers ({@code captureState} and {@code
+ * emitIfLongEnough}) directly, bypassing the {@code AgentTracer.get()} call that would require a
+ * live agent. The {@link WaitAdvice#after(long[])} null-guard is tested separately.
+ */
+@ExtendWith(MockitoExtension.class)
+class ObjectWaitProfilingInstrumentationTest {
+
+ private static final long SPAN_ID = 0xDEADBEEFL;
+ private static final long ROOT_SPAN_ID = 0xCAFEBABEL;
+ private static final long START_TICKS = 42_000_000L;
+
+ /**
+ * Implements both interfaces: span.context() returns AgentSpanContext but is cast to
+ * ProfilerContext.
+ */
+ private interface ProfilerSpanContext extends AgentSpanContext, ProfilerContext {}
+
+ @Mock private ProfilingContextIntegration profiling;
+ @Mock private AgentSpan span;
+ @Mock private ProfilerSpanContext ctx;
+ @Mock private AgentSpanContext nonProfilerCtx;
+
+ private final Object monitor = new Object();
+
+ @BeforeEach
+ void setUp() {
+ lenient().when(span.context()).thenReturn(ctx);
+ lenient().when(ctx.getSpanId()).thenReturn(SPAN_ID);
+ lenient().when(ctx.getRootSpanId()).thenReturn(ROOT_SPAN_ID);
+ lenient().when(profiling.getCurrentTicks()).thenReturn(START_TICKS);
+ }
+
+ // ---------------------------------------------------------------------------
+ // WaitAdvice.after — null state guard
+ // ---------------------------------------------------------------------------
+
+ @Test
+ void after_nullState_doesNotThrow() {
+ // before() returns null when profiling is absent or no active span;
+ // after() must be a safe no-op in that case.
+ WaitAdvice.after(null);
+ }
+
+ // ---------------------------------------------------------------------------
+ // captureState — precondition gates
+ // ---------------------------------------------------------------------------
+
+ @Test
+ void captureState_nullProfiling_returnsNull() {
+ assertNull(WaitAdvice.captureState(monitor, null, span));
+ }
+
+ @Test
+ void captureState_nullSpan_returnsNull() {
+ assertNull(WaitAdvice.captureState(monitor, profiling, null));
+ }
+
+ @Test
+ void captureState_spanContextNotProfilerContext_returnsNull() {
+ lenient().when(span.context()).thenReturn(nonProfilerCtx);
+ assertNull(WaitAdvice.captureState(monitor, profiling, span));
+ }
+
+ // ---------------------------------------------------------------------------
+ // captureState — happy path
+ // ---------------------------------------------------------------------------
+
+ @Test
+ void captureState_validSpan_returnsCorrectState() {
+ long before = System.nanoTime();
+ long[] state = WaitAdvice.captureState(monitor, profiling, span);
+ long after = System.nanoTime();
+
+ assertNotNull(state);
+ assertEquals(5, state.length);
+ assertEquals(System.identityHashCode(monitor), state[IDX_BLOCKER]);
+ assertEquals(SPAN_ID, state[IDX_SPAN_ID]);
+ assertEquals(ROOT_SPAN_ID, state[IDX_ROOT_SPAN_ID]);
+ assertEquals(START_TICKS, state[IDX_START_TICKS]);
+ // startNanos must be within the window captured around the call
+ org.junit.jupiter.api.Assertions.assertTrue(
+ state[IDX_START_NANOS] >= before && state[IDX_START_NANOS] <= after,
+ "startNanos should be captured during captureState()");
+ }
+
+ @Test
+ void captureState_differentMonitors_produceDifferentBlockerHashes() {
+ Object monitorA = new Object();
+ Object monitorB = new Object();
+
+ long[] stateA = WaitAdvice.captureState(monitorA, profiling, span);
+ long[] stateB = WaitAdvice.captureState(monitorB, profiling, span);
+
+ assertNotNull(stateA);
+ assertNotNull(stateB);
+ // Different object identities must produce different blocker hashes
+ // (identity hash codes can collide, but for freshly allocated objects this holds
+ // in all current JVM implementations — and what matters is they use identityHashCode)
+ assertEquals(System.identityHashCode(monitorA), stateA[IDX_BLOCKER]);
+ assertEquals(System.identityHashCode(monitorB), stateB[IDX_BLOCKER]);
+ }
+
+ // ---------------------------------------------------------------------------
+ // emitIfLongEnough — duration filter
+ // ---------------------------------------------------------------------------
+
+ @Test
+ void emitIfLongEnough_shortWait_doesNotEmit() {
+ // Set startNanos to "just now" so elapsed < MIN_WAIT_NANOS
+ long[] state = buildState(System.nanoTime());
+
+ WaitAdvice.emitIfLongEnough(state, profiling);
+
+ verifyNoInteractions(profiling);
+ }
+
+ @Test
+ void emitIfLongEnough_longWait_emitsTaskBlock() {
+ // Set startNanos to 2 ms ago — comfortably above the 1 ms threshold
+ long twoMsAgo = System.nanoTime() - 2 * MIN_WAIT_NANOS;
+ long[] state = buildState(twoMsAgo);
+
+ WaitAdvice.emitIfLongEnough(state, profiling);
+
+ verify(profiling)
+ .recordTaskBlock(
+ START_TICKS, // startTicks
+ SPAN_ID, // spanId
+ ROOT_SPAN_ID, // rootSpanId
+ System.identityHashCode(monitor), // blocker
+ 0L); // unblockingSpanId always 0 (notify is native)
+ }
+
+ @Test
+ void emitIfLongEnough_exactlyAtThreshold_emitsTaskBlock() {
+ // nanos exactly at the boundary — elapsed == MIN_WAIT_NANOS is NOT < threshold, so it emits
+ long atThreshold = System.nanoTime() - MIN_WAIT_NANOS;
+ long[] state = buildState(atThreshold);
+
+ WaitAdvice.emitIfLongEnough(state, profiling);
+
+ verify(profiling)
+ .recordTaskBlock(START_TICKS, SPAN_ID, ROOT_SPAN_ID, System.identityHashCode(monitor), 0L);
+ }
+
+ @Test
+ void emitIfLongEnough_unblockingSpanIdIsAlwaysZero() {
+ long twoMsAgo = System.nanoTime() - 2 * MIN_WAIT_NANOS;
+ long[] state = buildState(twoMsAgo);
+
+ WaitAdvice.emitIfLongEnough(state, profiling);
+
+ // The 5th argument (unblockingSpanId) must always be 0 because notify/notifyAll
+ // are native in JDK 21+ — the notifying thread cannot be identified via BCI.
+ verify(profiling).recordTaskBlock(START_TICKS, SPAN_ID, ROOT_SPAN_ID, state[IDX_BLOCKER], 0L);
+ }
+
+ // ---------------------------------------------------------------------------
+ // Helpers
+ // ---------------------------------------------------------------------------
+
+ private long[] buildState(long startNanos) {
+ return new long[] {
+ System.identityHashCode(monitor), // IDX_BLOCKER
+ SPAN_ID, // IDX_SPAN_ID
+ ROOT_SPAN_ID, // IDX_ROOT_SPAN_ID
+ START_TICKS, // IDX_START_TICKS
+ startNanos // IDX_START_NANOS
+ };
+ }
+}
diff --git a/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/ProfilingContextIntegration.java b/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/ProfilingContextIntegration.java
index 4accced983a..3e67cf48fa3 100644
--- a/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/ProfilingContextIntegration.java
+++ b/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/ProfilingContextIntegration.java
@@ -34,6 +34,36 @@ default int encodeResourceName(CharSequence constant) {
return 0;
}
+ /** Returns the current TSC tick count for the calling thread. */
+ default long getCurrentTicks() {
+ return 0L;
+ }
+
+ /**
+ * Emits a TaskBlock event covering a blocking interval on the current thread.
+ *
+ * @param startTicks TSC tick at block entry
+ * @param spanId the span ID active when blocking began
+ * @param rootSpanId the local root span ID active when blocking began
+ * @param blocker identity hash code of the blocking object, or 0 if none
+ * @param unblockingSpanId the span ID of the thread that unblocked this thread, or 0 if unknown
+ */
+ default void recordTaskBlock(
+ long startTicks, long spanId, long rootSpanId, long blocker, long unblockingSpanId) {}
+
+ /**
+ * Called when the current thread is about to enter {@code LockSupport.park*}. Native code can
+ * suppress wall-clock signals for the park interval and record the start tick for off-CPU
+ * analysis.
+ */
+ default void parkEnter(long spanId, long rootSpanId) {}
+
+ /**
+ * Called when the current thread has returned from {@code LockSupport.park*}. Clears the park
+ * state and may emit a TaskBlock JFR event.
+ */
+ default void parkExit(long blocker, long unblockingSpanId) {}
+
String name();
final class NoOp implements ProfilingContextIntegration {
diff --git a/metadata/supported-configurations.json b/metadata/supported-configurations.json
index d77b600b2f6..7ac7866be94 100644
--- a/metadata/supported-configurations.json
+++ b/metadata/supported-configurations.json
@@ -7865,6 +7865,14 @@
"aliases": ["DD_TRACE_INTEGRATION_LIBERTY_ENABLED", "DD_INTEGRATION_LIBERTY_ENABLED"]
}
],
+ "DD_TRACE_LOCK_SUPPORT_ENABLED": [
+ {
+ "version": "A",
+ "type": "boolean",
+ "default": "true",
+ "aliases": ["DD_TRACE_INTEGRATION_LOCK_SUPPORT_ENABLED", "DD_INTEGRATION_LOCK_SUPPORT_ENABLED"]
+ }
+ ],
"DD_TRACE_LOG4J_1_ENABLED": [
{
"version": "A",
@@ -8289,6 +8297,14 @@
"aliases": ["DD_OBFUSCATION_QUERY_STRING_REGEXP"]
}
],
+ "DD_TRACE_OBJECT_WAIT_ENABLED": [
+ {
+ "version": "A",
+ "type": "boolean",
+ "default": "true",
+ "aliases": ["DD_TRACE_INTEGRATION_OBJECT_WAIT_ENABLED", "DD_INTEGRATION_OBJECT_WAIT_ENABLED"]
+ }
+ ],
"DD_TRACE_OGNL_ENABLED": [
{
"version": "A",
diff --git a/settings.gradle.kts b/settings.gradle.kts
index bd5aaceffaa..6716528fb8b 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -328,6 +328,8 @@ include(
":dd-java-agent:instrumentation:datadog:dynamic-instrumentation:span-origin",
":dd-java-agent:instrumentation:datadog:profiling:enable-wallclock-profiling",
":dd-java-agent:instrumentation:datadog:profiling:exception-profiling",
+ ":dd-java-agent:instrumentation:datadog:profiling:lock-support",
+ ":dd-java-agent:instrumentation:datadog:profiling:object-wait",
":dd-java-agent:instrumentation:datadog:tracing:trace-annotation",
":dd-java-agent:instrumentation:datanucleus-4.0.5",
":dd-java-agent:instrumentation:datastax-cassandra:datastax-cassandra-3.0",
+ *
+ */
+ @Test
+ void unparking_spanId_is_visible_to_parked_thread() throws InterruptedException {
+ long unparkingSpanId = 99887766L;
+
+ CountDownLatch ready = new CountDownLatch(1);
+ CountDownLatch go = new CountDownLatch(1);
+ AtomicLong capturedSpanId = new AtomicLong(-1L);
+ AtomicReference