From 884c1a4b0477b31fd39f1d73a0e4dc2d6e5798b0 Mon Sep 17 00:00:00 2001 From: Bruce Bujon Date: Mon, 22 Jun 2026 15:37:15 +0200 Subject: [PATCH 1/3] feat(context): Add listener assertion methods This will help with readability when building complex sequence of events --- .../context/ContextContinuationTest.java | 104 +++++++-------- .../context/ContextListenerEventTest.java | 71 +++++----- .../context/ContextProvidersForkedTest.java | 16 +-- .../java/datadog/context/ContextTestBase.java | 121 +++++++++++------- 4 files changed, 165 insertions(+), 147 deletions(-) diff --git a/components/context/src/test/java/datadog/context/ContextContinuationTest.java b/components/context/src/test/java/datadog/context/ContextContinuationTest.java index 0b6508220bf..1b132717ac7 100644 --- a/components/context/src/test/java/datadog/context/ContextContinuationTest.java +++ b/components/context/src/test/java/datadog/context/ContextContinuationTest.java @@ -2,14 +2,14 @@ import static datadog.context.Context.current; import static datadog.context.Context.root; -import static java.util.Arrays.asList; +import static java.util.Collections.singletonList; +import static java.util.Collections.synchronizedList; import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.ArrayList; -import java.util.Collections; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; @@ -46,16 +46,16 @@ void testCaptureStoresContext() { @Test void testCaptureFiresOnCaptureEvent() { - List events = new ArrayList<>(); - ContextManager.register(trackingListener(events)); + TrackingListener listener = trackingListener(); + ContextManager.register(listener); Context context = root().with(CONTINUATION_KEY, "value"); try (ContextScope scope = context.attach()) { ContextContinuation continuation = context.capture(); // capture while active (recommended pattern) - assertEquals(asList("attach", "capture"), events); + listener.assertNewEvents("attach", "capture"); continuation.release(); } - assertEquals(asList("attach", "capture", "release", "detach"), events); + listener.assertNewEvents("release", "detach"); } @Test @@ -75,25 +75,25 @@ void testResumeAttachesContextAndRestoresPreviousOnClose() { @Test void testResumeAndScopeCloseFiresLifecycleEvents() { - List events = new ArrayList<>(); - ContextManager.register(trackingListener(events)); + TrackingListener listener = trackingListener(); + ContextManager.register(listener); Context context = root().with(CONTINUATION_KEY, "value"); ContextContinuation continuation; try (ContextScope scope = context.attach()) { continuation = context.capture(); // capture while active } - assertEquals(asList("attach", "capture", "detach"), events); + listener.assertNewEvents("attach", "capture", "detach"); try (ContextScope scope = continuation.resume()) { - assertEquals(asList("attach", "capture", "detach", "attach"), events); + listener.assertNewEvents("attach"); } // release fires before detach (continuation is released first inside ContextScopeImpl.close) - assertEquals(asList("attach", "capture", "detach", "attach", "release", "detach"), events); + listener.assertNewEvents("release", "detach"); } @Test void testHoldPreventsAutoReleaseOnScopeClose() { - List events = new ArrayList<>(); - ContextManager.register(trackingListener(events)); + TrackingListener listener = trackingListener(); + ContextManager.register(listener); Context context = root().with(CONTINUATION_KEY, "value"); ContextContinuation continuation; try (ContextScope scope = context.attach()) { @@ -104,26 +104,24 @@ void testHoldPreventsAutoReleaseOnScopeClose() { assertEquals(context, current()); } assertEquals(root(), current()); - assertEquals( - asList("attach", "capture", "detach", "attach", "detach"), - events, - "release should not fire while hold is active"); + // release should not fire while hold is active + listener.assertNewEvents("attach", "capture", "detach", "attach", "detach"); continuation.release(); - assertEquals(asList("attach", "capture", "detach", "attach", "detach", "release"), events); + listener.assertNewEvents("release"); } @Test void testExplicitReleaseWithoutResumeFiresReleaseEvent() { - List events = new ArrayList<>(); - ContextManager.register(trackingListener(events)); + TrackingListener listener = trackingListener(); + ContextManager.register(listener); Context context = root().with(CONTINUATION_KEY, "value"); ContextContinuation continuation; try (ContextScope scope = context.attach()) { continuation = context.capture(); // capture while active } - assertEquals(asList("attach", "capture", "detach"), events); + listener.assertNewEvents("attach", "capture", "detach"); continuation.release(); - assertEquals(asList("attach", "capture", "detach", "release"), events); + listener.assertNewEvents("release"); } @Test @@ -168,7 +166,7 @@ void testResumeOnDifferentThread() { @Test void testMultipleResumesReleaseAfterLastScopeCloses() throws InterruptedException { - List events = Collections.synchronizedList(new ArrayList<>()); + List events = synchronizedList(new ArrayList<>()); ContextManager.register( new ContextListener() { @Override @@ -217,7 +215,7 @@ public void onRelease(Context c) { closeSecond.countDown(); assertDoesNotThrow(() -> f1.get()); assertDoesNotThrow(() -> f2.get()); - assertEquals(asList("release"), events); + assertEquals(singletonList("release"), events); } finally { executor.shutdown(); } @@ -225,19 +223,19 @@ public void onRelease(Context c) { @Test void testSameContextResumeReleasesImmediately() { - List events = new ArrayList<>(); - ContextManager.register(trackingListener(events)); + TrackingListener listener = trackingListener(); + ContextManager.register(listener); Context context = root().with(CONTINUATION_KEY, "value"); try (ContextScope outer = context.attach()) { // Context is already current; resume is a noop and continuation is released immediately ContextContinuation continuation = context.capture(); try (ContextScope noop = continuation.resume()) { assertEquals(context, current()); - assertEquals(asList("attach", "capture", "release"), events); // released synchronously + listener.assertNewEvents("attach", "capture", "release"); // released synchronously } assertEquals(context, current()); // outer scope still holds context } - assertEquals(asList("attach", "capture", "release", "detach"), events); + listener.assertNewEvents("detach"); } @Test @@ -249,8 +247,8 @@ void testOutOfOrderScopeCloseReleasesImmediately() { continuation = contextC.capture(); } - List events = new ArrayList<>(); - ContextManager.register(keyedTrackingListener(events, CONTINUATION_KEY)); + TrackingListener listener = keyedTrackingListener(CONTINUATION_KEY); + ContextManager.register(listener); Context contextD = root().with(CONTINUATION_KEY, "D"); try (ContextScope scopeR = continuation.resume()) { @@ -261,17 +259,14 @@ void testOutOfOrderScopeCloseReleasesImmediately() { // close the resume scope out-of-order while D is still nested on top; // release fires immediately, but detach:C does not (C is not current) scopeR.close(); - assertEquals(asList("attach:C", "detach:C", "attach:D", "release:C"), events); + listener.assertNewEvents("attach:C", "detach:C", "attach:D", "release:C"); assertEquals(contextD, current()); // D is still current } // scopeD closes here: unwind D normally, restores C - assertEquals( - asList("attach:C", "detach:C", "attach:D", "release:C", "detach:D", "attach:C"), events); + listener.assertNewEvents("detach:D", "attach:C"); } // try-with-resources closes scopeR again; no second release, C unwinds to root assertEquals(root(), current()); - assertEquals( - asList("attach:C", "detach:C", "attach:D", "release:C", "detach:D", "attach:C", "detach:C"), - events); + listener.assertNewEvents("detach:C"); } @Test @@ -285,8 +280,8 @@ void testHoldWithOutOfOrderScopeCloseFiresReleaseOnExplicitRelease() { continuation.hold(); } - List events = new ArrayList<>(); - ContextManager.register(keyedTrackingListener(events, CONTINUATION_KEY)); + TrackingListener listener = keyedTrackingListener(CONTINUATION_KEY); + ContextManager.register(listener); Context contextD = root().with(CONTINUATION_KEY, "D"); try (ContextScope scopeR = continuation.resume()) { @@ -295,26 +290,23 @@ void testHoldWithOutOfOrderScopeCloseFiresReleaseOnExplicitRelease() { assertEquals(contextD, current()); scopeR.close(); // out-of-order close while D is still on top; hold prevents auto-release - assertEquals(asList("attach:C", "detach:C", "attach:D"), events); + listener.assertNewEvents("attach:C", "detach:C", "attach:D"); assertEquals(contextD, current()); } // scopeD closes here: unwind D, restores C } // TWR closes scopeR again (now in-order); detach:C, no release yet (hold is active) assertEquals(root(), current()); - assertEquals( - asList("attach:C", "detach:C", "attach:D", "detach:D", "attach:C", "detach:C"), events); + listener.assertNewEvents("detach:D", "attach:C", "detach:C"); continuation.release(); // explicit release must fire release:C - assertEquals( - asList("attach:C", "detach:C", "attach:D", "detach:D", "attach:C", "detach:C", "release:C"), - events); + listener.assertNewEvents("release:C"); } @Test void testMultipleHoldCallsAreIdempotent() { // Calling hold() more than once should not require more than one explicit release(). - List events = new ArrayList<>(); - ContextManager.register(trackingListener(events)); + TrackingListener listener = trackingListener(); + ContextManager.register(listener); Context context = root().with(CONTINUATION_KEY, "value"); ContextContinuation continuation; try (ContextScope scope = context.attach()) { @@ -324,36 +316,36 @@ void testMultipleHoldCallsAreIdempotent() { } // One explicit release() is enough — no extra releases needed for the second hold(). continuation.release(); - assertEquals(asList("attach", "capture", "detach", "release"), events); + listener.assertNewEvents("attach", "capture", "detach", "release"); continuation.release(); // still idempotent after the final release - assertEquals(asList("attach", "capture", "detach", "release"), events); + listener.assertNoNewEvents(); } @Test void testHoldAfterReleaseIsIgnored() { // hold() on an already-released continuation must not resurrect it. - List events = new ArrayList<>(); - ContextManager.register(trackingListener(events)); + TrackingListener listener = trackingListener(); + ContextManager.register(listener); Context context = root().with(CONTINUATION_KEY, "value"); ContextContinuation continuation; try (ContextScope scope = context.attach()) { continuation = context.capture(); } continuation.release(); - assertEquals(asList("attach", "capture", "detach", "release"), events); + listener.assertNewEvents("attach", "capture", "detach", "release"); continuation.hold(); // must be silently ignored // resume() after release is already a noop, even with the spurious hold() try (ContextScope scope = continuation.resume()) { assertEquals(root(), current()); } continuation.release(); // must not fire a second release event - assertEquals(asList("attach", "capture", "detach", "release"), events); + listener.assertNoNewEvents(); } @Test void testHoldAllowsMultipleReleaseCalls() { - List events = new ArrayList<>(); - ContextManager.register(trackingListener(events)); + TrackingListener listener = trackingListener(); + ContextManager.register(listener); Context context = root().with(CONTINUATION_KEY, "value"); ContextContinuation continuation; try (ContextScope scope = context.attach()) { @@ -361,8 +353,8 @@ void testHoldAllowsMultipleReleaseCalls() { continuation.hold(); } continuation.release(); - assertEquals(asList("attach", "capture", "detach", "release"), events); + listener.assertNewEvents("attach", "capture", "detach", "release"); continuation.release(); // second release is a no-op - assertEquals(asList("attach", "capture", "detach", "release"), events); + listener.assertNoNewEvents(); } } diff --git a/components/context/src/test/java/datadog/context/ContextListenerEventTest.java b/components/context/src/test/java/datadog/context/ContextListenerEventTest.java index cce5d10f167..4c26d230db5 100644 --- a/components/context/src/test/java/datadog/context/ContextListenerEventTest.java +++ b/components/context/src/test/java/datadog/context/ContextListenerEventTest.java @@ -3,102 +3,97 @@ import static datadog.context.Context.current; import static datadog.context.Context.root; import static datadog.context.ContextTest.STRING_KEY; -import static java.util.Arrays.asList; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; -import java.util.ArrayList; -import java.util.List; import org.junit.jupiter.api.Test; class ContextListenerEventTest extends ContextTestBase { @Test void testListenersNotifiedOnAttachAndDetach() { - List events = new ArrayList<>(); - ContextManager.register(keyedTrackingListener(events, STRING_KEY)); + TrackingListener listener = keyedTrackingListener(STRING_KEY); + ContextManager.register(listener); Context context = root().with(STRING_KEY, "value"); try (ContextScope scope = context.attach()) { - assertEquals(asList("attach:value"), events); + listener.assertNewEvents("attach:value"); } - assertEquals(asList("attach:value", "detach:value"), events); + listener.assertNewEvents("detach:value"); } @Test void testListenersNotNotifiedForRootContext() { - List events = new ArrayList<>(); - ContextManager.register(trackingListener(events)); + TrackingListener listener = trackingListener(); + ContextManager.register(listener); root().attach(); // current is already root, no events - assertTrue(events.isEmpty(), "root attach should not trigger listeners"); + listener.assertNoEvents(); // root attach should not trigger listeners root().swap(); // current is already root, no events - assertTrue(events.isEmpty(), "root swap should not trigger listeners"); + listener.assertNoEvents(); // root swap should not trigger listeners Context context = root().with(STRING_KEY, "value"); try (ContextScope scope = context.attach()) { - assertEquals(1, events.size()); // attach:non-root only + listener.assertNewEvents("attach"); // attach:non-root only } - assertEquals(2, events.size()); // detach:non-root but not attach:root + listener.assertNewEvents("detach"); // detach:non-root but not attach:root } @Test void testListenersNotNotifiedOnSameContextAttach() { - List events = new ArrayList<>(); - ContextManager.register(trackingListener(events)); + TrackingListener listener = trackingListener(); + ContextManager.register(listener); Context context = root().with(STRING_KEY, "same"); try (ContextScope outer = context.attach()) { - assertEquals(asList("attach"), events); + listener.assertNewEvents("attach"); try (ContextScope noop = context.attach()) { assertEquals(context, current()); - assertEquals(asList("attach"), events); // no new events on same-context attach + listener.assertNoNewEvents(); // no new events on same-context attach } - assertEquals(asList("attach"), events); // noop close fires no events either + listener.assertNoNewEvents(); // noop close fires no events either } - assertEquals(asList("attach", "detach"), events); + listener.assertNewEvents("detach"); } @Test void testListenersNotNotifiedOnSameContextSwap() { - List events = new ArrayList<>(); - ContextManager.register(trackingListener(events)); + TrackingListener listener = trackingListener(); + ContextManager.register(listener); Context context = root().with(STRING_KEY, "same"); context.swap(); - assertEquals(asList("attach"), events); + listener.assertNewEvents("attach"); context.swap(); // same context again, no events - assertEquals(asList("attach"), events); + listener.assertNoNewEvents(); root().swap(); - assertEquals(asList("attach", "detach"), events); + listener.assertNewEvents("detach"); } @Test void testDuplicateListenerIgnored() { - List events = new ArrayList<>(); - ContextListener listener = trackingListener(events); + TrackingListener listener = trackingListener(); ContextManager.register(listener); ContextManager.register(listener); // should be ignored try (ContextScope scope = root().with(STRING_KEY, "value").attach()) {} - assertEquals(asList("attach", "detach"), events); + listener.assertEvents("attach", "detach"); } @Test void testMultipleListenersAllNotified() { - List events1 = new ArrayList<>(); - List events2 = new ArrayList<>(); - ContextManager.register(trackingListener(events1)); - ContextManager.register(trackingListener(events2)); + TrackingListener listener1 = trackingListener(); + TrackingListener listener2 = trackingListener(); + ContextManager.register(listener1); + ContextManager.register(listener2); try (ContextScope scope = root().with(STRING_KEY, "value").attach()) {} - assertEquals(asList("attach", "detach"), events1); - assertEquals(asList("attach", "detach"), events2); + listener1.assertEvents("attach", "detach"); + listener2.assertEvents("attach", "detach"); } @Test void testSwapNotifiesListeners() { - List events = new ArrayList<>(); - ContextManager.register(keyedTrackingListener(events, STRING_KEY)); + TrackingListener listener = keyedTrackingListener(STRING_KEY); + ContextManager.register(listener); Context context = root().with(STRING_KEY, "value"); Context previous = context.swap(); assertSame(root(), previous); - assertEquals(asList("attach:value"), events); + listener.assertNewEvents("attach:value"); previous = root().swap(); assertSame(context, previous); - assertEquals(asList("attach:value", "detach:value"), events); + listener.assertNewEvents("detach:value"); } } diff --git a/components/context/src/test/java/datadog/context/ContextProvidersForkedTest.java b/components/context/src/test/java/datadog/context/ContextProvidersForkedTest.java index 47e6287ea36..73c55a28c6f 100644 --- a/components/context/src/test/java/datadog/context/ContextProvidersForkedTest.java +++ b/components/context/src/test/java/datadog/context/ContextProvidersForkedTest.java @@ -7,8 +7,6 @@ import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertTrue; -import java.util.ArrayList; -import java.util.List; import javax.annotation.Nonnull; import org.junit.jupiter.api.Test; @@ -85,26 +83,26 @@ public Context current() { } @Override - public ContextScope attach(Context context) { + public ContextScope attach(@Nonnull Context context) { return new NoopContextScope(root()); } @Override - public Context swap(Context context) { + public Context swap(@Nonnull Context context) { return root(); } @Override - public ContextContinuation capture(Context context) { + public ContextContinuation capture(@Nonnull Context context) { return new NoopContextContinuation(root()); } @Override - public void addListener(ContextListener listener) {} + public void addListener(@Nonnull ContextListener listener) {} }); - List events = new ArrayList<>(); - ContextManager.register(trackingListener(events)); + ContextTestBase.TrackingListener listener = trackingListener(); + ContextManager.register(listener); // NOOP manager, context will always be root try (ContextScope scope = context.attach()) { @@ -123,6 +121,6 @@ public void addListener(ContextListener listener) {} assertSame(root(), Context.current()); // NOOP manager, no events emitted - assertTrue(events.isEmpty()); + listener.assertNoEvents(); } } diff --git a/components/context/src/test/java/datadog/context/ContextTestBase.java b/components/context/src/test/java/datadog/context/ContextTestBase.java index ecb0183e635..9fd2a4452cd 100644 --- a/components/context/src/test/java/datadog/context/ContextTestBase.java +++ b/components/context/src/test/java/datadog/context/ContextTestBase.java @@ -2,9 +2,12 @@ import static datadog.context.Context.current; import static datadog.context.Context.root; +import static java.util.Arrays.asList; import static org.junit.jupiter.api.Assertions.assertEquals; +import java.util.ArrayList; import java.util.List; +import javax.annotation.Nullable; import javax.annotation.ParametersAreNonnullByDefault; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; @@ -22,51 +25,81 @@ void verifyNoContextAfter() { assertEquals(root(), current()); } - static ContextListener trackingListener(List events) { - return new ContextListener() { - @Override - public void onAttach(Context c) { - events.add("attach"); - } - - @Override - public void onDetach(Context c) { - events.add("detach"); - } - - @Override - public void onCapture(Context c) { - events.add("capture"); - } - - @Override - public void onRelease(Context c) { - events.add("release"); - } - }; + static TrackingListener trackingListener() { + return new TrackingListener(null); } - static ContextListener keyedTrackingListener(List events, ContextKey key) { - return new ContextListener() { - @Override - public void onAttach(Context c) { - events.add("attach:" + c.get(key)); - } - - @Override - public void onDetach(Context c) { - events.add("detach:" + c.get(key)); - } - - @Override - public void onCapture(Context c) { - events.add("capture:" + c.get(key)); - } - - @Override - public void onRelease(Context c) { - events.add("release:" + c.get(key)); - } - }; + static TrackingListener keyedTrackingListener(ContextKey key) { + return new TrackingListener(key); + } + + /** + * A {@link ContextListener} that records the events it receives so tests can assert on them. + * + *

With a {@link ContextKey}, each event is suffixed with that key's context value; otherwise + * only the event name is recorded (e.g. {@code "attach"}). + */ + static final class TrackingListener implements ContextListener { + private final List events; + @Nullable private final ContextKey key; + private int checkpoint; + + private TrackingListener(@Nullable ContextKey key) { + this.events = new ArrayList<>(); + this.key = key; + } + + @Override + public void onAttach(Context context) { + record("attach", context); + } + + @Override + public void onDetach(Context context) { + record("detach", context); + } + + @Override + public void onCapture(Context context) { + record("capture", context); + } + + @Override + public void onRelease(Context context) { + record("release", context); + } + + private void record(String event, Context context) { + this.events.add(this.key == null ? event : event + ":" + context.get(this.key)); + } + + /** Asserts the full sequence of recorded events equals {@code expected}. */ + void assertEvents(String... expected) { + assertEquals(asList(expected), new ArrayList<>(this.events)); + } + + /** Asserts that no events have been recorded at all. */ + void assertNoEvents() { + assertEvents(); + } + + /** + * Asserts the events recorded since the previous {@link #assertNewEvents} call equal {@code + * expected}, then advances the checkpoint past them. + */ + void assertNewEvents(String... expected) { + List snapshot = new ArrayList<>(this.events); + List newEvents = new ArrayList<>(snapshot.subList(this.checkpoint, snapshot.size())); + assertEquals(asList(expected), newEvents); + this.checkpoint = snapshot.size(); + } + + /** + * Asserts that no events have been recorded since the previous {@link #assertNewEvents} or + * {@link #assertNoNewEvents} call. + */ + void assertNoNewEvents() { + assertNewEvents(); + } } } From 11080378ba42ee765befba6a47c9d6155c67f4e2 Mon Sep 17 00:00:00 2001 From: Bruce Bujon Date: Thu, 2 Jul 2026 10:13:56 +0200 Subject: [PATCH 2/3] refactor(core): Add null annotations for context manager implementation --- .../trace/core/scopemanager/ContinuableScopeManager.java | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/dd-trace-core/src/main/java/datadog/trace/core/scopemanager/ContinuableScopeManager.java b/dd-trace-core/src/main/java/datadog/trace/core/scopemanager/ContinuableScopeManager.java index d278097b053..04fbd637bb3 100644 --- a/dd-trace-core/src/main/java/datadog/trace/core/scopemanager/ContinuableScopeManager.java +++ b/dd-trace-core/src/main/java/datadog/trace/core/scopemanager/ContinuableScopeManager.java @@ -30,6 +30,7 @@ import datadog.trace.bootstrap.instrumentation.api.ProfilingContextIntegration; import datadog.trace.core.monitor.HealthMetrics; import datadog.trace.util.AgentTaskScheduler; +import edu.umd.cs.findbugs.annotations.NonNull; import java.util.Iterator; import java.util.List; import java.util.Map; @@ -376,12 +377,12 @@ public Context current() { } @Override - public ContextScope attach(Context context) { + public ContextScope attach(@NonNull Context context) { return activate(context); } @Override - public Context swap(Context context) { + public Context swap(@NonNull Context context) { ScopeStack oldStack = tlsScopeStack.get(); ContinuableScope oldScope = oldStack.top; @@ -412,7 +413,7 @@ public Context swap(Context context) { } @Override - public ContextContinuation capture(Context context) { + public ContextContinuation capture(@NonNull Context context) { // respect async propagation flag for Context.current().capture() ContinuableScope activeScope = scopeStack().active(); if (activeScope != null @@ -431,7 +432,7 @@ public ContextContinuation capture(Context context) { } @Override - public void addListener(ContextListener unused) { + public void addListener(@NonNull ContextListener unused) { // this new API is not expected to be used in legacy mode... log.warn("Unexpected call to ContextManager.addListener(...)"); } From 726b66e373c9b0bf4f98ddfd1a6e25b0cf4c7469 Mon Sep 17 00:00:00 2001 From: Bruce Bujon Date: Thu, 2 Jul 2026 10:27:55 +0200 Subject: [PATCH 3/3] refactoring(junit): Fix variable name following #11763 --- .../instrumentation/junit5/BeforeAfterOperationsTracer.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dd-java-agent/instrumentation/junit/junit-5/junit-5.8/src/main/java/datadog/trace/instrumentation/junit5/BeforeAfterOperationsTracer.java b/dd-java-agent/instrumentation/junit/junit-5/junit-5.8/src/main/java/datadog/trace/instrumentation/junit5/BeforeAfterOperationsTracer.java index b20b1a7d3f5..99448382196 100644 --- a/dd-java-agent/instrumentation/junit/junit-5/junit-5.8/src/main/java/datadog/trace/instrumentation/junit5/BeforeAfterOperationsTracer.java +++ b/dd-java-agent/instrumentation/junit/junit-5/junit-5.8/src/main/java/datadog/trace/instrumentation/junit5/BeforeAfterOperationsTracer.java @@ -51,7 +51,7 @@ private static void traceInvocation( Invocation invocation, Method executable, String operationName) throws Throwable { AgentSpan agentSpan = AgentTracer.startSpan("junit", executable.getName()); agentSpan.setTag(Tags.TEST_CALLBACK, operationName); - try (ContextScope agentScope = AgentTracer.activateSpan(agentSpan)) { + try (ContextScope scope = AgentTracer.activateSpan(agentSpan)) { invocation.proceed(); } catch (Throwable t) { agentSpan.addThrowable(t);