diff --git a/dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/domain/ContextActivation.java b/dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/domain/ContextActivation.java new file mode 100644 index 00000000000..d7b34870b82 --- /dev/null +++ b/dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/domain/ContextActivation.java @@ -0,0 +1,53 @@ +package datadog.trace.civisibility.domain; + +import datadog.context.Context; +import datadog.context.ContextHandle; + +/** Keeps nested test and suite contexts restorable when they end out of order. */ +final class ContextActivation { + private static final ThreadLocal CURRENT = new ThreadLocal<>(); + + private ContextActivation parent; + private ContextHandle previousContext; + private boolean ended; + + private ContextActivation(Context context) { + parent = CURRENT.get(); + previousContext = context.swap(); + CURRENT.set(this); + } + + static ContextActivation enter(Context context) { + return new ContextActivation(context); + } + + boolean isCurrent() { + return CURRENT.get() == this; + } + + void exit() { + ended = true; + if (!isCurrent()) { + return; + } + + ContextHandle restoreContext; + ContextActivation activation = this; + do { + restoreContext = activation.previousContext; + ContextActivation parent = activation.parent; + activation.previousContext = null; + activation.parent = null; + activation = parent; + } while (activation != null && activation.ended); + + if (activation == null) { + CURRENT.remove(); + } else { + CURRENT.set(activation); + } + if (restoreContext != null) { + restoreContext.swap(); + } + } +} diff --git a/dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/domain/TestImpl.java b/dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/domain/TestImpl.java index 7cc327adb3e..153c1f692d9 100644 --- a/dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/domain/TestImpl.java +++ b/dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/domain/TestImpl.java @@ -1,11 +1,11 @@ package datadog.trace.civisibility.domain; import static datadog.json.JsonMapper.toJson; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpanWithoutScope; import static datadog.trace.civisibility.Constants.CI_VISIBILITY_INSTRUMENTATION_NAME; import datadog.trace.api.Config; import datadog.trace.api.DDTraceId; +import datadog.trace.api.InstrumenterConfig; import datadog.trace.api.civisibility.CIConstants; import datadog.trace.api.civisibility.DDTest; import datadog.trace.api.civisibility.InstrumentationTestBridge; @@ -63,6 +63,8 @@ public class TestImpl implements DDTest { private final ExecutionResults executionResults; private final TestFrameworkInstrumentation instrumentation; private final AgentSpan span; + private final ContextActivation contextActivation; + private boolean ended; private final DDTraceId sessionId; private final long suiteId; private final Consumer onSpanFinish; @@ -125,7 +127,12 @@ public TestImpl( span = spanBuilder.start(); - activateSpanWithoutScope(span); + if (InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + AgentTracer.get().activateSpanWithoutScope(span); + contextActivation = null; + } else { + contextActivation = ContextActivation.enter(span); + } span.setSpanType(InternalSpanTypes.TEST); span.setTag(Tags.SPAN_KIND, Tags.SPAN_KIND_TEST); @@ -256,6 +263,11 @@ public TestContext getContext() { @Override public void end(@Nullable Long endTime) { + if (!InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + endWithContext(endTime); + return; + } + closeOutstandingSpans(); final AgentSpan activeSpan = AgentTracer.activeSpan(); @@ -277,9 +289,42 @@ public void end(@Nullable Long endTime) { } InstrumentationTestBridge.fireBeforeTestEnd(context); - CoveragePerTestBridge.removeThreadLocalCoverageProbes(); + reportCoverage(); + AgentTracer.get().closeActive(); + finishTest(endTime); + } + /** + * Finishes the test and restores its saved context without finishing outstanding application + * spans. + */ + private void endWithContext(@Nullable Long endTime) { + if (ended) { + return; + } + ended = true; + boolean cleanupCurrentContext = contextActivation.isCurrent(); + try { + if (cleanupCurrentContext) { + span.swap(); + // Listeners such as Selenium cleanup require this test to be current. + try { + InstrumentationTestBridge.fireBeforeTestEnd(context); + } finally { + if (contextActivation.isCurrent()) { + CoveragePerTestBridge.removeThreadLocalCoverageProbes(); + } + } + } + reportCoverage(); + } finally { + contextActivation.exit(); + finishTest(endTime); + } + } + + private void reportCoverage() { // do not process coverage reports for skipped tests if (span.getTag(Tags.TEST_STATUS) != TestStatus.skip) { CoverageStore coverageStore = context.getCoverageStore(); @@ -289,14 +334,14 @@ public void end(@Nullable Long endTime) { metricCollector.add(CiVisibilityCountMetric.CODE_COVERAGE_IS_EMPTY, 1); } } + } + private void finishTest(@Nullable Long endTime) { boolean debugInfoCaptured = span.getTag(Tags.ERROR_DEBUG_INFO_CAPTURED) != null; if (debugInfoCaptured) { executionResults.setHasFailedTestReplayTests(); } - AgentTracer.closeActive(); - onSpanFinish.accept(span); if (endTime != null) { @@ -340,8 +385,8 @@ public void end(@Nullable Long endTime) { * finalizing an operation properly usually results in its span remaining open. This is something * that we have no control over, since this happens in the clients' codebase. * - *

This method attempts to finalize such "dangling" spans: it closes whatever is on top of the - * spans stack until it encounters a CI Visibility span or the stack is empty. + *

In legacy mode, this method attempts to finalize such "dangling" spans: it closes whatever + * is on top of the spans stack until it encounters a CI Visibility span or the stack is empty. */ private void closeOutstandingSpans() { AgentSpan activeSpan; @@ -353,7 +398,7 @@ private void closeOutstandingSpans() { } log.debug("Closing outstanding span: {}", activeSpan); - AgentTracer.closeActive(); + AgentTracer.get().closeActive(); activeSpan.finish(); } } diff --git a/dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/domain/TestSuiteImpl.java b/dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/domain/TestSuiteImpl.java index 3c4a6dc4242..300571feb1e 100644 --- a/dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/domain/TestSuiteImpl.java +++ b/dd-java-agent/agent-ci-visibility/src/main/java/datadog/trace/civisibility/domain/TestSuiteImpl.java @@ -1,10 +1,10 @@ package datadog.trace.civisibility.domain; import static datadog.json.JsonMapper.toJson; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpanWithoutScope; import static datadog.trace.civisibility.Constants.CI_VISIBILITY_INSTRUMENTATION_NAME; import datadog.trace.api.Config; +import datadog.trace.api.InstrumenterConfig; import datadog.trace.api.civisibility.DDTestSuite; import datadog.trace.api.civisibility.config.LibraryCapability; import datadog.trace.api.civisibility.coverage.CoverageStore; @@ -38,6 +38,8 @@ public class TestSuiteImpl implements DDTestSuite { private final AgentSpanContext moduleSpanContext; private final AgentSpan span; + private final ContextActivation contextActivation; + private boolean ended; private final String moduleName; private final String testSuiteName; private final String itrCorrelationId; @@ -144,7 +146,14 @@ public TestSuiteImpl( configurationErrors.applyTags(span); if (!parallelized) { - activateSpanWithoutScope(span); + if (InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + AgentTracer.get().activateSpanWithoutScope(span); + contextActivation = null; + } else { + contextActivation = ContextActivation.enter(span); + } + } else { + contextActivation = null; } metricCollector.add(CiVisibilityCountMetric.EVENT_CREATED, 1, instrumentation, EventType.SUITE); @@ -206,26 +215,36 @@ public void setSkipReason(String skipReason) { @Override public void end(@Nullable Long endTime) { - if (!parallelized) { - final AgentSpan activeSpan = AgentTracer.activeSpan(); - if (activeSpan == null) { - throw new IllegalStateException( - "No active span present, it is possible that end() was called multiple times"); + if (InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + if (!parallelized) { + final AgentSpan activeSpan = AgentTracer.activeSpan(); + if (activeSpan == null) { + throw new IllegalStateException( + "No active span present, it is possible that end() was called multiple times"); + } + + if (activeSpan != this.span) { + throw new IllegalStateException( + "Active span does not correspond to the finished suite, " + + "it is possible that end() was called multiple times " + + "or an operation that was started by the suite is still in progress; " + + "active span is: " + + activeSpan + + "; " + + "expected span is: " + + this.span); + } + + AgentTracer.get().closeActive(); } - - if (activeSpan != this.span) { - throw new IllegalStateException( - "Active span does not correspond to the finished suite, " - + "it is possible that end() was called multiple times " - + "or an operation that was started by the suite is still in progress; " - + "active span is: " - + activeSpan - + "; " - + "expected span is: " - + this.span); + } else { + if (ended) { + return; + } + ended = true; + if (contextActivation != null) { + contextActivation.exit(); } - - AgentTracer.closeActive(); } onSpanFinish.accept(span); diff --git a/dd-java-agent/agent-ci-visibility/src/test/java/datadog/trace/civisibility/domain/ContextRestorationTest.java b/dd-java-agent/agent-ci-visibility/src/test/java/datadog/trace/civisibility/domain/ContextRestorationTest.java new file mode 100644 index 00000000000..5a724f3ea99 --- /dev/null +++ b/dd-java-agent/agent-ci-visibility/src/test/java/datadog/trace/civisibility/domain/ContextRestorationTest.java @@ -0,0 +1,541 @@ +package datadog.trace.civisibility.domain; + +import static java.util.Collections.emptyList; +import static java.util.Collections.emptyMap; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.when; + +import datadog.context.Context; +import datadog.context.ContextHandle; +import datadog.trace.api.Config; +import datadog.trace.api.civisibility.DDTest; +import datadog.trace.api.civisibility.DDTestSuite; +import datadog.trace.api.civisibility.InstrumentationTestBridge; +import datadog.trace.api.civisibility.coverage.CoveragePerTestBridge; +import datadog.trace.api.civisibility.coverage.CoverageProbes; +import datadog.trace.api.civisibility.coverage.CoverageStore; +import datadog.trace.api.civisibility.coverage.NoOpCoverageStore; +import datadog.trace.api.civisibility.domain.TestContext; +import datadog.trace.api.civisibility.telemetry.CiVisibilityMetricCollector; +import datadog.trace.api.civisibility.telemetry.tag.TestFrameworkInstrumentation; +import datadog.trace.bootstrap.ContextStore; +import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.civisibility.codeowners.NoCodeowners; +import datadog.trace.civisibility.config.ConfigurationErrors; +import datadog.trace.civisibility.decorator.TestDecoratorImpl; +import datadog.trace.civisibility.events.TestEventsHandlerImpl; +import datadog.trace.civisibility.source.LinesResolver; +import datadog.trace.civisibility.source.NoOpSourcePathResolver; +import datadog.trace.civisibility.test.ExecutionResults; +import datadog.trace.civisibility.utils.StrongMapContextStore; +import datadog.trace.common.writer.ListWriter; +import datadog.trace.core.CoreTracer; +import datadog.trace.core.DDSpan; +import datadog.trace.test.junit.utils.config.WithConfig; +import datadog.trace.test.util.DDJavaSpecification; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Consumer; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.tabletest.junit.TableTest; + +@WithConfig(key = "legacy.context-manager.enabled", value = "false") +class ContextRestorationTest extends DDJavaSpecification { + private CoreTracer tracer; + private AgentTracer.TracerAPI previousTracer; + private ContextHandle previousContext; + private AgentSpan moduleSpan; + + @BeforeEach + void setUpTracer() { + previousTracer = AgentTracer.get(); + tracer = CoreTracer.builder().writer(new ListWriter()).build(); + AgentTracer.forceRegister(tracer); + // The current tracer still uses the Context API shim. + AgentTracer.installLegacyContextManager(); + previousContext = Context.current().checkpoint(); + moduleSpan = tracer.startSpan("test", "module"); + } + + @AfterEach + void restoreTracer() { + previousContext.swap(); + moduleSpan.finish(); + tracer.close(); + AgentTracer.forceRegister(previousTracer); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void testsAndSuitesRestoreTheEnclosingContext(boolean parallelized) { + moduleSpan.swap(); + Context parent = Context.current(); + Context.setCaptureEnabled(false); + TestSuiteImpl suite = suite(parallelized); + Context suiteContext = Context.current(); + TestImpl outer = suite.testStart("outer", null, null); + Context outerContext = Context.current(); + TestImpl inner = suite.testStart("inner", null, null); + inner.end(null); + assertSame(outerContext, Context.current()); + assertDoesNotThrow(() -> inner.end(null)); + outer.end(null); + assertSame(suiteContext, Context.current()); + suite.end(null); + assertSame(parent, Context.current()); + assertFalse(Context.isCaptureEnabled()); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void endingATestDiscardsOutstandingContextsInOneRestore(boolean parallelized) { + TestSuiteImpl suite = suite(parallelized); + Context suiteContext = Context.current(); + TestImpl test = suite.testStart("test", null, null); + DDSpan testSpan = (DDSpan) AgentTracer.activeSpan(); + DDSpan first = (DDSpan) tracer.startSpan("test", "first"); + first.swap(); + DDSpan second = (DDSpan) tracer.startSpan("test", "second"); + second.swap(); + try { + test.end(null); + assertSame(suiteContext, Context.current()); + assertTrue(testSpan.isFinished()); + assertFalse(first.isFinished()); + assertFalse(second.isFinished()); + } finally { + second.finish(); + first.finish(); + test.end(null); + suite.end(null); + } + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void listenerFailureRestoresTheEnclosingTestAndFinishesTheInnerTest(boolean parallelized) { + TestSuiteImpl suite = suite(parallelized); + Context suiteContext = Context.current(); + TestImpl outer = suite.testStart("outer", null, null); + Context enclosingContext = Context.current(); + TestImpl test = suite.testStart("listener-failure", null, null); + DDSpan testSpan = (DDSpan) AgentTracer.activeSpan(); + CoverageProbes probes = mock(CoverageProbes.class); + CoveragePerTestBridge.setThreadLocalCoverageProbes(probes); + RuntimeException failure = new RuntimeException("browser command failed"); + AtomicReference failingContext = new AtomicReference<>(test.getContext()); + InstrumentationTestBridge.registerListener(context -> { + if (failingContext.compareAndSet(context, null)) { + throw failure; + } + }); + ContextStore tests = new StrongMapContextStore<>(); + Object testKey = new Object(); + tests.put(testKey, test); + TestEventsHandlerImpl handler = handler(new StrongMapContextStore<>(), tests); + try { + assertSame( + failure, + assertThrows(RuntimeException.class, () -> handler.onTestFinish(testKey, null, null))); + + assertNull(tests.get(testKey)); + assertTrue(testSpan.isFinished()); + assertSame(enclosingContext, Context.current()); + CoveragePerTestBridge.recordCoverage(getClass()); + verifyNoInteractions(probes); + assertDoesNotThrow(() -> test.end(null)); + } finally { + failingContext.set(null); + outer.end(null); + assertSame(suiteContext, Context.current()); + suite.end(null); + handler.close(); + } + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void coverageFailureStillRestoresContextAndFinishesTheTest(boolean parallelized) { + RuntimeException failure = new RuntimeException("coverage report failed"); + CoverageStore store = mock(CoverageStore.class); + when(store.report(any(), any(), anyLong())).thenThrow(failure); + CoverageStore.Factory factory = mock(CoverageStore.Factory.class); + when(factory.create(any())).thenReturn(store); + TestSuiteImpl suite = suite(parallelized, SpanTagsPropagator.NOOP_PROPAGATOR, factory); + Context suiteContext = Context.current(); + TestImpl test = suite.testStart("coverage-failure", null, null); + DDSpan testSpan = (DDSpan) AgentTracer.activeSpan(); + + assertSame(failure, assertThrows(RuntimeException.class, () -> test.end(null))); + + assertTrue(testSpan.isFinished()); + assertSame(suiteContext, Context.current()); + suite.end(null); + } + + @TableTest({ + "Scenario | parallelized | applicationSpanActive", + "serial suite | false | false ", + "parallel suite | true | false ", + "serial with application | false | true ", + "parallel with application | true | true " + }) + void finishEventCompletesAnOutOfOrderTestWithoutDiscardingTheInnerTest( + boolean parallelized, boolean applicationSpanActive) throws Exception { + moduleSpan.swap(); + Context parent = Context.current(); + Context.setCaptureEnabled(false); + TestSuiteImpl suite = suite(parallelized); + Context suiteContext = Context.current(); + TestImpl outer = suite.testStart("outer", null, null); + DDSpan outerSpan = (DDSpan) AgentTracer.activeSpan(); + TestImpl inner = suite.testStart("inner", null, null); + AgentSpan applicationSpan = null; + if (applicationSpanActive) { + applicationSpan = tracer.startSpan("test", "application"); + applicationSpan.swap(); + } + Context innerContext = Context.current(); + CoverageProbes innerProbes = mock(CoverageProbes.class); + CoveragePerTestBridge.setThreadLocalCoverageProbes(innerProbes); + ContextStore tests = new StrongMapContextStore<>(); + Object testKey = new Object(); + tests.put(testKey, outer); + TestEventsHandlerImpl handler = handler(new StrongMapContextStore<>(), tests); + AtomicInteger outerCallbacks = new AtomicInteger(); + + try (AutoCloseable ignored = onTestEnd(outer, outerCallbacks::incrementAndGet)) { + handler.onTestFinish(testKey, null, null); + assertEquals(0, outerCallbacks.get()); + + assertNull(tests.get(testKey)); + assertTrue(outerSpan.isFinished()); + assertSame(innerContext, Context.current()); + CoveragePerTestBridge.recordCoverage(getClass()); + verify(innerProbes).record(getClass()); + inner.end(null); + assertEquals(0, outerCallbacks.get()); + assertSame(suiteContext, Context.current()); + suite.end(null); + assertSame(parent, Context.current()); + assertFalse(Context.isCaptureEnabled()); + } finally { + inner.end(null); + outer.end(null); + suite.end(null); + if (applicationSpan != null) { + applicationSpan.finish(); + } + handler.close(); + } + } + + @TableTest({ + "Order | first | second | third", + "outer middle inner | 0 | 1 | 2 ", + "outer inner middle | 0 | 2 | 1 ", + "middle outer inner | 1 | 0 | 2 ", + "middle inner outer | 1 | 2 | 0 ", + "inner outer middle | 2 | 0 | 1 ", + "inner middle outer | 2 | 1 | 0 " + }) + void nestedTestsRestoreLiveContextsInAnyTeardownOrder(int first, int second, int third) { + moduleSpan.swap(); + Context parent = Context.current(); + Context.setCaptureEnabled(false); + TestSuiteImpl suite = suite(false); + Context suiteContext = Context.current(); + boolean suiteCaptureEnabled = Context.isCaptureEnabled(); + TestImpl[] tests = new TestImpl[3]; + DDSpan[] spans = new DDSpan[3]; + boolean[] ended = new boolean[3]; + try { + for (int i = 0; i < tests.length; i++) { + tests[i] = suite.testStart("test-" + i, null, null); + spans[i] = (DDSpan) AgentTracer.activeSpan(); + Context.setCaptureEnabled(i % 2 == 0); + } + + for (int index : new int[] {first, second, third}) { + tests[index].end(null); + ended[index] = true; + assertTrue(spans[index].isFinished()); + int current = tests.length - 1; + while (current >= 0 && ended[current]) { + current--; + } + Context expected = current >= 0 ? spans[current] : suiteContext; + boolean captureEnabled = current >= 0 ? current % 2 == 0 : suiteCaptureEnabled; + assertSame(expected, Context.current()); + assertEquals(captureEnabled, Context.isCaptureEnabled()); + tests[index].end(null); + assertSame(expected, Context.current()); + assertEquals(captureEnabled, Context.isCaptureEnabled()); + } + suite.end(null); + assertSame(parent, Context.current()); + assertFalse(Context.isCaptureEnabled()); + } finally { + for (int i = tests.length - 1; i >= 0; i--) { + if (tests[i] != null) { + tests[i].end(null); + } + } + suite.end(null); + } + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void testsCanStartWhileAnEndedOuterFrameIsWaitingForItsChildren(boolean parallelized) { + TestSuiteImpl suite = suite(parallelized); + Context parent = Context.current(); + TestImpl outer = suite.testStart("outer", null, null); + TestImpl middle = suite.testStart("middle", null, null); + outer.end(null); + TestImpl inner = suite.testStart("inner", null, null); + Context innerContext = Context.current(); + try { + middle.end(null); + assertSame(innerContext, Context.current()); + inner.end(null); + assertSame(parent, Context.current()); + } finally { + inner.end(null); + middle.end(null); + outer.end(null); + suite.end(null); + } + } + + @Test + void testEndCallbacksCanStartAndFinishNestedTests() throws Exception { + Context parent = Context.current(); + TestSuiteImpl suite = suite(false); + Context suiteContext = Context.current(); + TestImpl outer = suite.testStart("outer", null, null); + Context outerContext = Context.current(); + try (AutoCloseable ignored = + onTestEnd( + outer, + () -> { + TestImpl inner = suite.testStart("inner", null, null); + inner.end(null); + assertSame(outerContext, Context.current()); + })) { + outer.end(null); + assertSame(suiteContext, Context.current()); + } finally { + outer.end(null); + suite.end(null); + } + assertSame(parent, Context.current()); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void testEndCallbacksCanLeaveANestedTestRunning(boolean callbackFails) throws Exception { + Context parent = Context.current(); + TestSuiteImpl suite = suite(false); + Context suiteContext = Context.current(); + TestImpl outer = suite.testStart("outer", null, null); + DDSpan outerSpan = (DDSpan) AgentTracer.activeSpan(); + AtomicReference inner = new AtomicReference<>(); + AtomicReference innerContext = new AtomicReference<>(); + CoverageProbes probes = mock(CoverageProbes.class); + RuntimeException failure = new RuntimeException("test-end callback failed"); + try (AutoCloseable ignored = + onTestEnd( + outer, + () -> { + inner.set(suite.testStart("inner", null, null)); + innerContext.set(Context.current()); + CoveragePerTestBridge.setThreadLocalCoverageProbes(probes); + if (callbackFails) { + throw failure; + } + })) { + if (callbackFails) { + assertSame(failure, assertThrows(RuntimeException.class, () -> outer.end(null))); + } else { + outer.end(null); + } + assertNotNull(inner.get()); + assertTrue(outerSpan.isFinished()); + assertSame(innerContext.get(), Context.current()); + CoveragePerTestBridge.recordCoverage(getClass()); + verify(probes).record(getClass()); + inner.get().end(null); + assertSame(suiteContext, Context.current()); + } finally { + if (inner.get() != null) { + inner.get().end(null); + } + outer.end(null); + suite.end(null); + } + assertSame(parent, Context.current()); + } + + @Test + void repeatedTestEndDoesNotRepeatCallbacksOrChangeTheCallerContext() throws Exception { + TestSuiteImpl suite = suite(false); + TestImpl test = suite.testStart("test", null, null); + DDSpan testSpan = (DDSpan) AgentTracer.activeSpan(); + AtomicInteger callbacks = new AtomicInteger(); + try (AutoCloseable ignored = onTestEnd(test, callbacks::incrementAndGet)) { + test.end(null); + moduleSpan.swap(); + Context callerContext = Context.current(); + test.end(null); + assertTrue(testSpan.isFinished()); + assertSame(callerContext, Context.current()); + assertEquals(1, callbacks.get()); + } finally { + test.end(null); + suite.end(null); + } + } + + @Test + void reentrantTestEndWaitsForTheCallbackBeforeFinishing() throws Exception { + TestSuiteImpl suite = suite(false); + Context suiteContext = Context.current(); + TestImpl test = suite.testStart("test", null, null); + DDSpan testSpan = (DDSpan) AgentTracer.activeSpan(); + try (AutoCloseable ignored = + onTestEnd( + test, + () -> { + test.end(null); + assertFalse(testSpan.isFinished()); + assertSame(testSpan, AgentTracer.activeSpan()); + })) { + test.end(null); + assertTrue(testSpan.isFinished()); + assertSame(suiteContext, Context.current()); + } finally { + test.end(null); + suite.end(null); + } + } + + @Test + void finishEventCompletesASuiteWithoutDiscardingTheActiveTest() { + moduleSpan.swap(); + Context parent = Context.current(); + Context.setCaptureEnabled(false); + AtomicInteger callbacks = new AtomicInteger(); + TestSuiteImpl suite = suite(false, span -> callbacks.incrementAndGet()); + DDSpan suiteSpan = (DDSpan) AgentTracer.activeSpan(); + TestImpl test = suite.testStart("test", null, null); + Context testContext = Context.current(); + ContextStore suites = new StrongMapContextStore<>(); + Object suiteKey = new Object(); + suites.put(suiteKey, suite); + TestEventsHandlerImpl handler = handler(suites, new StrongMapContextStore<>()); + + handler.onTestSuiteFinish(suiteKey, null); + + assertNull(suites.get(suiteKey)); + assertTrue(suiteSpan.isFinished()); + assertEquals(1, callbacks.get()); + assertSame(testContext, Context.current()); + test.end(null); + assertSame(parent, Context.current()); + assertFalse(Context.isCaptureEnabled()); + suite.end(null); + assertEquals(1, callbacks.get()); + handler.close(); + } + + @Test + void repeatedSuiteEndDoesNotRepeatTheCallbackOrChangeTheCallerContext() { + AtomicInteger callbacks = new AtomicInteger(); + TestSuiteImpl suite = suite(false, span -> callbacks.incrementAndGet()); + suite.end(null); + moduleSpan.swap(); + Context callerContext = Context.current(); + assertDoesNotThrow(() -> suite.end(null)); + assertSame(callerContext, Context.current()); + assertEquals(1, callbacks.get()); + } + + private static AutoCloseable onTestEnd(TestImpl test, Runnable callback) { + AtomicReference target = new AtomicReference<>(test.getContext()); + AtomicReference action = new AtomicReference<>(callback); + InstrumentationTestBridge.registerListener(context -> { + if (target.compareAndSet(context, null)) { + Runnable current = action.getAndSet(null); + if (current != null) { + current.run(); + } + } + }); + return () -> { + target.set(null); + action.set(null); + }; + } + + private static TestEventsHandlerImpl handler( + ContextStore suites, ContextStore tests) { + TestFrameworkSession session = mock(TestFrameworkSession.class); + when(session.testModuleStart("module", null)).thenReturn(mock(TestFrameworkModule.class)); + return new TestEventsHandlerImpl<>( + mock(CiVisibilityMetricCollector.class), () -> session, "module", false, suites, tests); + } + + private TestSuiteImpl suite(boolean parallelized) { + return suite(parallelized, SpanTagsPropagator.NOOP_PROPAGATOR); + } + + private TestSuiteImpl suite(boolean parallelized, Consumer onSpanFinish) { + return suite(parallelized, onSpanFinish, new NoOpCoverageStore.Factory()); + } + + private TestSuiteImpl suite( + boolean parallelized, + Consumer onSpanFinish, + CoverageStore.Factory coverageStoreFactory) { + return new TestSuiteImpl( + moduleSpan.spanContext(), + "module", + "suite", + null, + false, + null, + null, + parallelized, + InstrumentationType.BUILD, + TestFrameworkInstrumentation.OTHER, + Config.get(), + mock(CiVisibilityMetricCollector.class), + new TestDecoratorImpl("component", "session", "command", emptyMap()), + NoOpSourcePathResolver.INSTANCE, + NoCodeowners.INSTANCE, + mock(LinesResolver.class), + coverageStoreFactory, + new ExecutionResults(), + ConfigurationErrors.NONE, + emptyList(), + onSpanFinish); + } +} diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/main/java/datadog/trace/instrumentation/aws/v0/AWSHttpClientInstrumentation.java b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/main/java/datadog/trace/instrumentation/aws/v0/AWSHttpClientInstrumentation.java index 0d773ee49df..9cd23d793fa 100644 --- a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/main/java/datadog/trace/instrumentation/aws/v0/AWSHttpClientInstrumentation.java +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/main/java/datadog/trace/instrumentation/aws/v0/AWSHttpClientInstrumentation.java @@ -2,7 +2,7 @@ import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.closeActive; +import static datadog.trace.bootstrap.instrumentation.api.Java8BytecodeBridge.currentContext; import static datadog.trace.bootstrap.instrumentation.api.Java8BytecodeBridge.spanFromContext; import static datadog.trace.instrumentation.aws.v0.OnErrorDecorator.CONTEXT_CONTEXT_KEY; import static datadog.trace.instrumentation.aws.v0.OnErrorDecorator.DECORATE; @@ -12,8 +12,11 @@ import com.amazonaws.Request; import com.amazonaws.handlers.RequestHandler2; import datadog.context.Context; +import datadog.context.ContextHandle; import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.api.InstrumenterConfig; import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; import net.bytebuddy.asm.Advice; /** @@ -42,17 +45,29 @@ public void methodAdvice(MethodTransformer transformer) { } public static class HttpClientAdvice { + @Advice.OnMethodEnter(suppress = Throwable.class) + public static ContextHandle methodEnter() { + return InstrumenterConfig.get().isLegacyContextManagerEnabled() + ? null + : currentContext().checkpoint(); + } + @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) public static void methodExit( + @Advice.Enter final ContextHandle previousContext, @Advice.Argument(value = 0, optional = true) final Request request, @Advice.Thrown final Throwable throwable) { - final AgentSpan activeSpan = activeSpan(); - // check name in case TracingRequestHandler failed to activate the span - if (activeSpan != null - && (AwsNameCache.spanName(request).equals(activeSpan.getSpanName()) - || !activeSpan.isValid())) { - closeActive(); + if (InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + final AgentSpan activeSpan = activeSpan(); + // check name in case TracingRequestHandler failed to activate the span + if (activeSpan != null + && (AwsNameCache.spanName(request).equals(activeSpan.getSpanName()) + || !activeSpan.isValid())) { + AgentTracer.get().closeActive(); + } + } else if (previousContext != null) { + previousContext.swap(); } if (throwable != null && request != null) { diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/main/java/datadog/trace/instrumentation/aws/v0/RequestExecutorInstrumentation.java b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/main/java/datadog/trace/instrumentation/aws/v0/RequestExecutorInstrumentation.java index ab0344047d8..ca3c8f57ff9 100644 --- a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/main/java/datadog/trace/instrumentation/aws/v0/RequestExecutorInstrumentation.java +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/main/java/datadog/trace/instrumentation/aws/v0/RequestExecutorInstrumentation.java @@ -2,7 +2,7 @@ import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.closeActive; +import static datadog.trace.bootstrap.instrumentation.api.Java8BytecodeBridge.currentContext; import static datadog.trace.bootstrap.instrumentation.api.Java8BytecodeBridge.spanFromContext; import static datadog.trace.instrumentation.aws.v0.OnErrorDecorator.CONTEXT_CONTEXT_KEY; import static datadog.trace.instrumentation.aws.v0.OnErrorDecorator.DECORATE; @@ -10,8 +10,11 @@ import com.amazonaws.Request; import datadog.context.Context; +import datadog.context.ContextHandle; import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.api.InstrumenterConfig; import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; import net.bytebuddy.asm.Advice; /** @@ -39,17 +42,29 @@ public void methodAdvice(MethodTransformer transformer) { } public static class RequestExecutorAdvice { + @Advice.OnMethodEnter(suppress = Throwable.class) + public static ContextHandle methodEnter() { + return InstrumenterConfig.get().isLegacyContextManagerEnabled() + ? null + : currentContext().checkpoint(); + } + @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) public static void methodExit( + @Advice.Enter final ContextHandle previousContext, @Advice.FieldValue("request") final Request request, @Advice.Thrown final Throwable throwable) { - final AgentSpan activeSpan = activeSpan(); - // check name in case TracingRequestHandler failed to activate the span - if (activeSpan != null - && (AwsNameCache.spanName(request).equals(activeSpan.getSpanName()) - || !activeSpan.isValid())) { - closeActive(); + if (InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + final AgentSpan activeSpan = activeSpan(); + // check name in case TracingRequestHandler failed to activate the span + if (activeSpan != null + && (AwsNameCache.spanName(request).equals(activeSpan.getSpanName()) + || !activeSpan.isValid())) { + AgentTracer.get().closeActive(); + } + } else if (previousContext != null) { + previousContext.swap(); } if (throwable != null) { diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/main/java/datadog/trace/instrumentation/aws/v0/TracingRequestHandler.java b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/main/java/datadog/trace/instrumentation/aws/v0/TracingRequestHandler.java index 3282f0f9a7d..4ecb03d20e3 100644 --- a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/main/java/datadog/trace/instrumentation/aws/v0/TracingRequestHandler.java +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/main/java/datadog/trace/instrumentation/aws/v0/TracingRequestHandler.java @@ -4,7 +4,6 @@ import static datadog.trace.api.datastreams.DataStreamsTags.Direction.INBOUND; import static datadog.trace.api.datastreams.DataStreamsTags.create; import static datadog.trace.bootstrap.instrumentation.api.AgentPropagation.XRAY_TRACING_CONCERN; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpanWithoutScope; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.blackholeSpan; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.startSpan; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.traceConfig; @@ -20,6 +19,7 @@ import datadog.context.Context; import datadog.context.propagation.Propagators; import datadog.trace.api.Config; +import datadog.trace.api.InstrumenterConfig; import datadog.trace.api.datastreams.AgentDataStreamsMonitoring; import datadog.trace.api.datastreams.DataStreamsContext; import datadog.trace.api.datastreams.DataStreamsTags; @@ -55,7 +55,7 @@ public void beforeRequest(final Request request) { if (!AWS_LEGACY_TRACING && isPollingRequest(request.getOriginalRequest())) { // SQS messages spans are created by aws-java-sqs-1.0 - replace client scope with no-op, // so we can tell when receive call is complete without affecting the rest of the trace - activateSpanWithoutScope(blackholeSpan()); + enterRequest(blackholeSpan()); } else { Context context = requestContextStore.remove(request.getOriginalRequest()); AgentSpan span = AgentSpan.fromContext(context); @@ -78,15 +78,23 @@ public void beforeRequest(final Request request) { log.warn("Unable to inject trace header", e); } } - // This scope will be closed by AwsHttpClientInstrumentation + // AwsHttpClientInstrumentation restores the caller's context when request execution ends. if (AWS_LEGACY_TRACING) { - activateSpanWithoutScope(span); + enterRequest(span); } else { - activateSpanWithoutScope(blackholeSpan()); + enterRequest(blackholeSpan()); } } } + private static void enterRequest(AgentSpan span) { + if (InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + AgentTracer.get().activateSpanWithoutScope(span); + } else { + span.swap(); + } + } + @Override public void afterResponse(final Request request, final Response response) { final Context context = request.getHandlerContext(CONTEXT_CONTEXT_KEY); diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/test/groovy/AWS1ClientTest.groovy b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/test/groovy/AWS1ClientTest.groovy index 31dfa891461..a8f2eba7e3c 100644 --- a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/test/groovy/AWS1ClientTest.groovy +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/test/groovy/AWS1ClientTest.groovy @@ -591,3 +591,10 @@ class AWS1ClientV1ForkedTest extends AWS1ClientTest { } } +class ContextSwapAWS1ClientForkedTest extends AWS1ClientV0Test { + @Override + void configurePreAgent() { + super.configurePreAgent() + injectSysConfig("legacy.context-manager.enabled", "false") + } +} diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/test/groovy/LegacyAWS1ClientForkedTest.groovy b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/test/groovy/LegacyAWS1ClientForkedTest.groovy index 74168681d3d..9a8e0c7b4c2 100644 --- a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/test/groovy/LegacyAWS1ClientForkedTest.groovy +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/test/groovy/LegacyAWS1ClientForkedTest.groovy @@ -451,3 +451,11 @@ class LegacyAWS1ClientForkedTest extends InstrumentationSpecification { server.close() } } + +class ContextSwapLegacyAWS1ClientForkedTest extends LegacyAWS1ClientForkedTest { + @Override + void configurePreAgent() { + super.configurePreAgent() + injectSysConfig("legacy.context-manager.enabled", "false") + } +} diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/test/java/datadog/trace/instrumentation/aws/v0/AwsContextRestorationTest.java b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/test/java/datadog/trace/instrumentation/aws/v0/AwsContextRestorationTest.java new file mode 100644 index 00000000000..c3c0f87f8ff --- /dev/null +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/test/java/datadog/trace/instrumentation/aws/v0/AwsContextRestorationTest.java @@ -0,0 +1,160 @@ +package datadog.trace.instrumentation.aws.v0; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.amazonaws.AmazonWebServiceRequest; +import com.amazonaws.DefaultRequest; +import com.amazonaws.Request; +import com.amazonaws.services.s3.model.GetObjectRequest; +import datadog.context.Context; +import datadog.context.ContextHandle; +import datadog.context.ContextManager; +import datadog.trace.agent.tooling.WeakMaps; +import datadog.trace.bootstrap.ContextStore; +import datadog.trace.bootstrap.FieldBackedContextStores; +import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.common.writer.ListWriter; +import datadog.trace.core.CoreTracer; +import datadog.trace.core.DDSpan; +import datadog.trace.test.junit.utils.config.WithConfig; +import datadog.trace.test.util.DDJavaSpecification; +import java.net.URI; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +@WithConfig(key = "legacy.context-manager.enabled", value = "false") +class AwsContextRestorationTest extends DDJavaSpecification { + private CoreTracer tracer; + private AgentTracer.TracerAPI previousTracer; + private ContextHandle previousContext; + private TracingRequestHandler handler; + private AgentSpan parentSpan; + + @BeforeEach + @SuppressWarnings("unchecked") + void setUpTracer() { + WeakMaps.registerAsSupplier(); + previousTracer = AgentTracer.get(); + tracer = CoreTracer.builder().writer(new ListWriter()).build(); + AgentTracer.forceRegister(tracer); + configureContextManager(); + previousContext = Context.current().checkpoint(); + parentSpan = tracer.startSpan("test", "parent"); + parentSpan.swap(); + handler = + new TracingRequestHandler( + null, + (ContextStore) + FieldBackedContextStores.getContextStore( + FieldBackedContextStores.getContextStoreId( + AmazonWebServiceRequest.class.getName(), Context.class.getName()))); + } + + void configureContextManager() { + ContextManager.allowTesting(); + } + + @AfterEach + void restoreTracer() { + previousContext.swap(); + parentSpan.finish(); + tracer.close(); + AgentTracer.forceRegister(previousTracer); + AgentTracer.installLegacyContextManager(); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void nestedRequestsRestoreTheirOwnContexts(boolean requestExecutor) { + Context parent = Context.current(); + Context.setCaptureEnabled(false); + Request outer = request(); + Request inner = request(); + ContextHandle outerContext = enter(requestExecutor); + handler.beforeRequest(outer); + Context outerRequestContext = Context.current(); + ContextHandle innerContext = enter(requestExecutor); + handler.beforeRequest(inner); + + exit(requestExecutor, innerContext, inner, null); + assertSame(outerRequestContext, Context.current()); + exit(requestExecutor, outerContext, outer, null); + assertSame(parent, Context.current()); + assertFalse(Context.isCaptureEnabled()); + finish(outer); + finish(inner); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void requestFailureRestoresTheParentAndFinishesTheRequestSpan(boolean requestExecutor) { + Context parent = Context.current(); + Request request = request(); + ContextHandle previous = enter(requestExecutor); + handler.beforeRequest(request); + DDSpan span = + (DDSpan) + AgentSpan.fromContext( + request.getHandlerContext(TracingRequestHandler.CONTEXT_CONTEXT_KEY)); + exit(requestExecutor, previous, request, new IllegalStateException("request handler failed")); + assertSame(parent, Context.current()); + assertNull(request.getHandlerContext(TracingRequestHandler.CONTEXT_CONTEXT_KEY)); + assertTrue(span.isFinished()); + assertTrue(span.isError()); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void failureBeforeTheHandlerLeavesTheCallerContextIntact(boolean requestExecutor) { + Context parent = Context.current(); + Context.setCaptureEnabled(false); + ContextHandle previous = enter(requestExecutor); + exit(requestExecutor, previous, request(), new IllegalStateException("before handler")); + assertSame(parent, Context.current()); + assertFalse(Context.isCaptureEnabled()); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void restorationDoesNotRequireARequest(boolean requestExecutor) { + Context parent = Context.current(); + Context.setCaptureEnabled(false); + ContextHandle previous = enter(requestExecutor); + AgentTracer.blackholeSpan().swap(); + exit(requestExecutor, previous, null, null); + assertSame(parent, Context.current()); + assertFalse(Context.isCaptureEnabled()); + } + + private static ContextHandle enter(boolean requestExecutor) { + return requestExecutor + ? RequestExecutorInstrumentation.RequestExecutorAdvice.methodEnter() + : AWSHttpClientInstrumentation.HttpClientAdvice.methodEnter(); + } + + private static void exit( + boolean requestExecutor, ContextHandle previous, Request request, Throwable error) { + if (requestExecutor) { + RequestExecutorInstrumentation.RequestExecutorAdvice.methodExit(previous, request, error); + } else { + AWSHttpClientInstrumentation.HttpClientAdvice.methodExit(previous, request, error); + } + } + + private static Request request() { + Request request = new DefaultRequest<>(new GetObjectRequest("bucket", "key"), "AmazonS3"); + request.setEndpoint(URI.create("http://localhost")); + return request; + } + + private static void finish(Request request) { + AgentSpan.fromContext(request.getHandlerContext(TracingRequestHandler.CONTEXT_CONTEXT_KEY)) + .finish(); + } +} diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/test/java/datadog/trace/instrumentation/aws/v0/LegacyAdapterAwsContextRestorationTest.java b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/test/java/datadog/trace/instrumentation/aws/v0/LegacyAdapterAwsContextRestorationTest.java new file mode 100644 index 00000000000..c8d6983d0d3 --- /dev/null +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-1.11/src/test/java/datadog/trace/instrumentation/aws/v0/LegacyAdapterAwsContextRestorationTest.java @@ -0,0 +1,13 @@ +package datadog.trace.instrumentation.aws.v0; + +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.test.junit.utils.config.WithConfig; + +@WithConfig(key = "legacy.context-manager.enabled", value = "false") +class LegacyAdapterAwsContextRestorationTest extends AwsContextRestorationTest { + @Override + void configureContextManager() { + super.configureContextManager(); + AgentTracer.installLegacyContextManager(); + } +} diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/build.gradle b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/build.gradle index 90db5cce669..5d171a34673 100644 --- a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/build.gradle +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/build.gradle @@ -15,6 +15,7 @@ muzzle { // TODO APMLP-2196: no latestDepForkedTest until the tests handle S3 moving the bucket name to the hostname (somebucket.localhost) addTestSuiteForDir('latestDepTest', 'test', false) +sourceSets.latestDepTest.java.srcDir('src/latestDepTest/java') addTestSuite('dsmTest') addTestSuiteForDir('latestDsmTest', 'dsmTest') diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/latestDepTest/java/datadog/trace/instrumentation/aws/v2/AsyncSigningContextRestorationTest.java b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/latestDepTest/java/datadog/trace/instrumentation/aws/v2/AsyncSigningContextRestorationTest.java new file mode 100644 index 00000000000..82414e35706 --- /dev/null +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/latestDepTest/java/datadog/trace/instrumentation/aws/v2/AsyncSigningContextRestorationTest.java @@ -0,0 +1,127 @@ +package datadog.trace.instrumentation.aws.v2; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import datadog.context.Context; +import datadog.context.ContextHandle; +import datadog.trace.agent.test.AbstractInstrumentationTest; +import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.test.junit.utils.config.WithConfig; +import java.net.URI; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import software.amazon.awssdk.auth.credentials.AwsBasicCredentials; +import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider; +import software.amazon.awssdk.core.async.AsyncRequestBody; +import software.amazon.awssdk.core.client.config.SdkAdvancedClientOption; +import software.amazon.awssdk.core.interceptor.ExecutionAttributes; +import software.amazon.awssdk.core.retry.RetryPolicy; +import software.amazon.awssdk.core.signer.AsyncSigner; +import software.amazon.awssdk.core.signer.Signer; +import software.amazon.awssdk.http.SdkHttpFullRequest; +import software.amazon.awssdk.http.async.AsyncExecuteRequest; +import software.amazon.awssdk.http.async.SdkAsyncHttpClient; +import software.amazon.awssdk.regions.Region; +import software.amazon.awssdk.services.s3.S3AsyncClient; +import software.amazon.awssdk.services.s3.model.HeadObjectRequest; + +@WithConfig(key = "legacy.context-manager.enabled", value = "false") +class AsyncSigningContextRestorationTest extends AbstractInstrumentationTest { + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void signingAndHttpFailureRestoreTheSubmittingThread(boolean delayedSigning) throws Exception { + DelayedSigner signer = new DelayedSigner(delayedSigning); + AtomicReference submissionContext = new AtomicReference<>(); + SdkAsyncHttpClient httpClient = + new SdkAsyncHttpClient() { + @Override + public CompletableFuture execute(AsyncExecuteRequest request) { + submissionContext.set(Context.current()); + RuntimeException failure = new IllegalStateException("HTTP transport failed"); + request.responseHandler().onError(failure); + CompletableFuture result = new CompletableFuture<>(); + result.completeExceptionally(failure); + return result; + } + + @Override + public void close() {} + }; + ExecutorService executor = Executors.newSingleThreadExecutor(); + AgentSpan parent = tracer.startSpan("test", "parent"); + ContextHandle original = parent.swap(); + try (S3AsyncClient client = + S3AsyncClient.builder() + .httpClient(httpClient) + .region(Region.US_EAST_1) + .endpointOverride(URI.create("http://localhost")) + .credentialsProvider( + StaticCredentialsProvider.create(AwsBasicCredentials.create("key", "secret"))) + .overrideConfiguration(c -> + c.retryPolicy(RetryPolicy.none()) + .putAdvancedOption(SdkAdvancedClientOption.SIGNER, signer)) + .build()) { + CompletableFuture operation = + client.headObject(HeadObjectRequest.builder().bucket("bucket").key("key").build()); + if (delayedSigning) { + assertFalse(operation.isDone(), "request must wait for the asynchronous signer"); + AtomicReference before = new AtomicReference<>(); + AtomicReference after = new AtomicReference<>(); + executor + .submit(() -> { + before.set(Context.current()); + signer.signed.complete(signer.request); + after.set(Context.current()); + }) + .get(10, TimeUnit.SECONDS); + assertSame( + before.get(), after.get(), "the signing thread must regain its original context"); + } + assertThrows(ExecutionException.class, () -> operation.get(10, TimeUnit.SECONDS)); + assertNotNull(submissionContext.get(), "request must reach the HTTP transport"); + assertSame( + AgentTracer.noopSpan(), + submissionContext.get(), + "HTTP submission must suppress Netty scope capture"); + assertSame(parent, Context.current()); + } finally { + original.swap(); + parent.finish(); + executor.shutdownNow(); + assertTrue(executor.awaitTermination(10, TimeUnit.SECONDS)); + } + } + + private static final class DelayedSigner implements Signer, AsyncSigner { + final CompletableFuture signed = new CompletableFuture<>(); + final boolean delayed; + SdkHttpFullRequest request; + + DelayedSigner(boolean delayed) { + this.delayed = delayed; + } + + @Override + public SdkHttpFullRequest sign(SdkHttpFullRequest request, ExecutionAttributes attributes) { + throw new AssertionError("SDK must use the asynchronous signer"); + } + + @Override + public CompletableFuture sign( + SdkHttpFullRequest request, AsyncRequestBody body, ExecutionAttributes attributes) { + this.request = request; + return delayed ? signed : CompletableFuture.completedFuture(request); + } + } +} diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/main/java/datadog/trace/instrumentation/aws/v2/AwsHttpClientInstrumentation.java b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/main/java/datadog/trace/instrumentation/aws/v2/AwsHttpClientInstrumentation.java index 7d8df3683cb..e0d26386162 100644 --- a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/main/java/datadog/trace/instrumentation/aws/v2/AwsHttpClientInstrumentation.java +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/main/java/datadog/trace/instrumentation/aws/v2/AwsHttpClientInstrumentation.java @@ -6,24 +6,30 @@ import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.namedOneOf; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.closeActive; +import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.blackholeSpan; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.noopSpan; +import static datadog.trace.instrumentation.aws.v2.AwsSdkClientDecorator.AWS_LEGACY_TRACING; +import static net.bytebuddy.matcher.ElementMatchers.isDeclaredBy; import static net.bytebuddy.matcher.ElementMatchers.isMethod; import static net.bytebuddy.matcher.ElementMatchers.isPublic; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; +import datadog.context.Context; +import datadog.context.ContextHandle; import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.api.InstrumenterConfig; import datadog.trace.bootstrap.instrumentation.api.AgentSpan; import datadog.trace.bootstrap.instrumentation.api.AgentTracer; import net.bytebuddy.asm.Advice; +import net.bytebuddy.description.method.MethodDescription; import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.matcher.ElementMatcher; import software.amazon.awssdk.core.internal.http.RequestExecutionContext; import software.amazon.awssdk.core.internal.http.pipeline.stages.MakeAsyncHttpRequestStage; /** - * Separate instrumentation class to close aws request scope right after request has been submitted - * for execution for Sync clients. + * Pairs AWS request context activation and restoration around synchronous HTTP calls and + * asynchronous submission. */ public final class AwsHttpClientInstrumentation implements Instrumenter.ForTypeHierarchy, Instrumenter.HasMethodAdvice { @@ -45,14 +51,37 @@ public ElementMatcher hierarchyMatcher() { @Override public void methodAdvice(MethodTransformer transformer) { - transformer.applyAdvice( + ElementMatcher.Junction execute = isMethod() .and(isPublic()) .and(named("execute")) .and( takesArgument( - 1, named("software.amazon.awssdk.core.internal.http.RequestExecutionContext"))), - AwsHttpClientInstrumentation.class.getName() + "$AwsHttpClientAdvice"); + 1, named("software.amazon.awssdk.core.internal.http.RequestExecutionContext"))); + + if (InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + transformer.applyAdvice( + execute, AwsHttpClientInstrumentation.class.getName() + "$AwsHttpClientAdvice"); + } else { + transformer.applyAdvice( + execute.and( + isDeclaredBy( + named( + "software.amazon.awssdk.core.internal.http.pipeline.stages.MakeHttpRequestStage"))), + AwsHttpClientInstrumentation.class.getName() + "$SyncHttpRequestAdvice"); + transformer.applyAdvice( + isMethod() + .and(named("executeHttpRequest")) + .and( + isDeclaredBy( + named( + "software.amazon.awssdk.core.internal.http.pipeline.stages.MakeAsyncHttpRequestStage"))) + .and( + takesArgument( + 1, + named("software.amazon.awssdk.core.internal.http.RequestExecutionContext"))), + AwsHttpClientInstrumentation.class.getName() + "$AsyncHttpRequestAdvice"); + } } public static class AwsHttpClientAdvice { @@ -80,10 +109,10 @@ public static AutoCloseable methodEnter( .equals(activeSpan.getSpanName()))) { if (thiz instanceof MakeAsyncHttpRequestStage) { // close async legacy HTTP span to avoid Netty leak... - closeActive(); // then drop-through and activate no-op span + AgentTracer.get().closeActive(); // then drop-through and activate no-op span } else { // keep sync legacy HTTP span alive for duration of call - return AgentTracer::closeActive; + return TracingExecutionInterceptor::closeActiveScope; } } return activateSpan(noopSpan()); @@ -91,7 +120,9 @@ public static AutoCloseable methodEnter( @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) public static void methodExit(@Advice.Enter final AutoCloseable scope) throws Exception { - scope.close(); + if (scope != null) { + scope.close(); + } } /** @@ -102,4 +133,44 @@ public static void muzzleCheck() { TracingExecutionInterceptor.muzzleCheck(); } } + + public static class SyncHttpRequestAdvice { + @Advice.OnMethodEnter(suppress = Throwable.class) + public static ContextHandle methodEnter( + @Advice.Argument(1) final RequestExecutionContext requestExecutionContext) { + Context context = + AWS_LEGACY_TRACING + ? requestExecutionContext + .executionAttributes() + .getAttribute(TracingExecutionInterceptor.CONTEXT_ATTRIBUTE) + : blackholeSpan(); + return (context != null ? context : noopSpan()).swap(); + } + + @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) + public static void methodExit(@Advice.Enter final ContextHandle previousContext) { + if (previousContext != null) { + previousContext.swap(); + } + } + + public static void muzzleCheck() { + TracingExecutionInterceptor.muzzleCheck(); + } + } + + public static class AsyncHttpRequestAdvice { + @Advice.OnMethodEnter(suppress = Throwable.class) + public static ContextHandle methodEnter() { + // This method runs after signing completes, on the thread that submits the HTTP request. + return noopSpan().swap(); + } + + @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) + public static void methodExit(@Advice.Enter final ContextHandle previousContext) { + if (previousContext != null) { + previousContext.swap(); + } + } + } } diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/main/java/datadog/trace/instrumentation/aws/v2/TracingExecutionInterceptor.java b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/main/java/datadog/trace/instrumentation/aws/v2/TracingExecutionInterceptor.java index b698b0fea07..acd875d21b7 100644 --- a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/main/java/datadog/trace/instrumentation/aws/v2/TracingExecutionInterceptor.java +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/main/java/datadog/trace/instrumentation/aws/v2/TracingExecutionInterceptor.java @@ -3,7 +3,6 @@ import static datadog.trace.bootstrap.instrumentation.api.AgentPropagation.XRAY_TRACING_CONCERN; import static datadog.trace.bootstrap.instrumentation.api.AgentSpan.fromContext; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpanWithoutScope; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.blackholeSpan; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.startSpan; import static datadog.trace.instrumentation.aws.v2.AwsSdkClientDecorator.AWS_LEGACY_TRACING; @@ -14,9 +13,11 @@ import datadog.context.ContextScope; import datadog.context.propagation.Propagators; import datadog.trace.api.Config; +import datadog.trace.api.InstrumenterConfig; import datadog.trace.bootstrap.ContextStore; import datadog.trace.bootstrap.InstanceStore; import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; import java.util.Optional; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -98,6 +99,10 @@ public SdkHttpRequest modifyHttpRequest( @Override public void beforeTransmission( final BeforeTransmission context, final ExecutionAttributes executionAttributes) { + if (!InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + // Non-legacy activation is paired with restoration in the HTTP stage advice. + return; + } final AgentSpan span; if (!AWS_LEGACY_TRACING) { span = blackholeSpan(); @@ -108,7 +113,7 @@ public void beforeTransmission( if (span != null) { // This scope will be closed by AwsHttpClientInstrumentation since ExecutionInterceptor API // doesn't provide a way to run code in same thread after transmission has been scheduled. - activateSpanWithoutScope(span); + AgentTracer.get().activateSpanWithoutScope(span); } } @@ -181,6 +186,11 @@ private static boolean isPollingResponse(SdkResponse response) { .equals(response.getClass().getName()); } + /** Closes the legacy scope activated in {@link #beforeTransmission}. */ + public static void closeActiveScope() { + AgentTracer.get().closeActive(); + } + public static void muzzleCheck() { // Noop } diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/test/groovy/Aws2ClientTest.groovy b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/test/groovy/Aws2ClientTest.groovy index bab61052a0c..87886b09761 100644 --- a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/test/groovy/Aws2ClientTest.groovy +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/test/groovy/Aws2ClientTest.groovy @@ -784,3 +784,11 @@ class Aws2ClientV1ForkedTest extends Aws2ClientTest { 1 } } + +class ContextSwapAws2ClientForkedTest extends Aws2ClientV0ForkedTest { + @Override + void configurePreAgent() { + super.configurePreAgent() + injectSysConfig("legacy.context-manager.enabled", "false") + } +} diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/test/groovy/LegacyAws2ClientForkedTest.groovy b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/test/groovy/LegacyAws2ClientForkedTest.groovy index ef906f2fc64..b9fe81b99cf 100644 --- a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/test/groovy/LegacyAws2ClientForkedTest.groovy +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/test/groovy/LegacyAws2ClientForkedTest.groovy @@ -447,3 +447,11 @@ class LegacyAws2ClientForkedTest extends InstrumentationSpecification { server.close() } } + +class ContextSwapLegacyAws2ClientForkedTest extends LegacyAws2ClientForkedTest { + @Override + void configurePreAgent() { + super.configurePreAgent() + injectSysConfig("legacy.context-manager.enabled", "false") + } +} diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/test/java/datadog/trace/instrumentation/aws/v2/AwsContextRestorationTest.java b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/test/java/datadog/trace/instrumentation/aws/v2/AwsContextRestorationTest.java new file mode 100644 index 00000000000..175e41ad1d2 --- /dev/null +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/test/java/datadog/trace/instrumentation/aws/v2/AwsContextRestorationTest.java @@ -0,0 +1,125 @@ +package datadog.trace.instrumentation.aws.v2; + +import static java.util.Collections.emptyList; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertSame; + +import datadog.context.Context; +import datadog.context.ContextHandle; +import datadog.context.ContextKey; +import datadog.context.ContextManager; +import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.common.writer.ListWriter; +import datadog.trace.core.CoreTracer; +import datadog.trace.test.junit.utils.config.WithConfig; +import datadog.trace.test.util.DDJavaSpecification; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import software.amazon.awssdk.core.http.ExecutionContext; +import software.amazon.awssdk.core.interceptor.ExecutionAttributes; +import software.amazon.awssdk.core.interceptor.ExecutionInterceptorChain; +import software.amazon.awssdk.core.interceptor.InterceptorContext; +import software.amazon.awssdk.core.internal.http.RequestExecutionContext; +import software.amazon.awssdk.services.s3.model.GetObjectRequest; + +@WithConfig(key = "legacy.context-manager.enabled", value = "false") +class AwsContextRestorationTest extends DDJavaSpecification { + private AgentTracer.TracerAPI previousTracer; + private ContextHandle previousContext; + private AgentSpan span; + private CoreTracer tracer; + private TracingExecutionInterceptor interceptor; + + @BeforeEach + void setUpContext() { + ContextManager.allowTesting(); + previousContext = Context.current().checkpoint(); + previousTracer = AgentTracer.get(); + tracer = CoreTracer.builder().writer(new ListWriter()).build(); + span = tracer.startSpan("test", "request"); + AgentTracer.forceRegister(tracer); + interceptor = new TracingExecutionInterceptor(null); + } + + @AfterEach + void restoreContext() { + previousContext.swap(); + AgentTracer.forceRegister(previousTracer); + span.finish(); + tracer.close(); + AgentTracer.installLegacyContextManager(); + } + + @Test + void synchronousRequestSwapsAndRestoresTheOriginalContext() { + Context parent = Context.root().with(ContextKey.named("aws-parent"), "parent"); + parent.swap(); + Context.setCaptureEnabled(false); + ExecutionAttributes attributes = new ExecutionAttributes(); + attributes.putAttribute(TracingExecutionInterceptor.CONTEXT_ATTRIBUTE, span); + interceptor.beforeTransmission(null, attributes); + assertSame(parent, Context.current()); + + ContextHandle previous = + AwsHttpClientInstrumentation.SyncHttpRequestAdvice.methodEnter(requestContext(attributes)); + assertNotSame(parent, Context.current()); + AwsHttpClientInstrumentation.SyncHttpRequestAdvice.methodExit(previous); + assertSame(parent, Context.current()); + assertFalse(Context.isCaptureEnabled()); + } + + @Test + void nestedRequestsRestoreTheEnclosingTransmission() { + Context parent = Context.root().with(ContextKey.named("aws-nested"), "parent"); + parent.swap(); + ExecutionAttributes outerAttributes = new ExecutionAttributes(); + outerAttributes.putAttribute(TracingExecutionInterceptor.CONTEXT_ATTRIBUTE, span); + interceptor.beforeTransmission(null, outerAttributes); + ContextHandle outer = + AwsHttpClientInstrumentation.SyncHttpRequestAdvice.methodEnter( + requestContext(outerAttributes)); + + Context enclosingTransmission = Context.current(); + ExecutionAttributes innerAttributes = new ExecutionAttributes(); + innerAttributes.putAttribute(TracingExecutionInterceptor.CONTEXT_ATTRIBUTE, span); + interceptor.beforeTransmission(null, innerAttributes); + ContextHandle inner = + AwsHttpClientInstrumentation.SyncHttpRequestAdvice.methodEnter( + requestContext(innerAttributes)); + AwsHttpClientInstrumentation.SyncHttpRequestAdvice.methodExit(inner); + assertSame(enclosingTransmission, Context.current()); + AwsHttpClientInstrumentation.SyncHttpRequestAdvice.methodExit(outer); + assertSame(parent, Context.current()); + } + + @Test + void asyncSubmissionRestoresContextEvenIfTheTransportLeavesAnotherSpanActive() { + Context parent = Context.root().with(ContextKey.named("aws-async"), "parent"); + parent.swap(); + Context.setCaptureEnabled(false); + ContextHandle previous = AwsHttpClientInstrumentation.AsyncHttpRequestAdvice.methodEnter(); + span.swap(); + + AwsHttpClientInstrumentation.AsyncHttpRequestAdvice.methodExit(previous); + + assertSame(parent, Context.current()); + assertFalse(Context.isCaptureEnabled()); + } + + static RequestExecutionContext requestContext(ExecutionAttributes attributes) { + GetObjectRequest request = GetObjectRequest.builder().bucket("bucket").key("key").build(); + return RequestExecutionContext.builder() + .originalRequest(request) + .executionContext( + ExecutionContext.builder() + .signer((httpRequest, executionAttributes) -> httpRequest) + .interceptorContext(InterceptorContext.builder().request(request).build()) + .interceptorChain(new ExecutionInterceptorChain(emptyList())) + .executionAttributes(attributes) + .build()) + .build(); + } +} diff --git a/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/test/java/datadog/trace/instrumentation/aws/v2/MissingContextRestorationForkedTest.java b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/test/java/datadog/trace/instrumentation/aws/v2/MissingContextRestorationForkedTest.java new file mode 100644 index 00000000000..25c5fb096e2 --- /dev/null +++ b/dd-java-agent/instrumentation/aws-java/aws-java-sdk-2.2/src/test/java/datadog/trace/instrumentation/aws/v2/MissingContextRestorationForkedTest.java @@ -0,0 +1,47 @@ +package datadog.trace.instrumentation.aws.v2; + +import static datadog.trace.instrumentation.aws.v2.AwsContextRestorationTest.requestContext; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import datadog.context.Context; +import datadog.context.ContextHandle; +import datadog.context.ContextKey; +import datadog.context.ContextManager; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.test.junit.utils.config.WithConfig; +import datadog.trace.test.util.DDJavaSpecification; +import org.junit.jupiter.api.Test; +import software.amazon.awssdk.core.interceptor.ExecutionAttributes; + +@WithConfig(key = "legacy.context-manager.enabled", value = "false") +@WithConfig(key = "aws-sdk.legacy.tracing.enabled", value = "true") +class MissingContextRestorationForkedTest extends DDJavaSpecification { + @Test + void missingAwsContextSuppressesHttpTracingAndRestoresTheCaller() { + ContextManager.allowTesting(); + ContextHandle original = Context.current().checkpoint(); + try { + assertTrue(AwsSdkClientDecorator.AWS_LEGACY_TRACING); + Context caller = Context.root().with(ContextKey.named("aws-caller"), "caller"); + caller.swap(); + Context.setCaptureEnabled(false); + + ContextHandle previous = + AwsHttpClientInstrumentation.SyncHttpRequestAdvice.methodEnter( + requestContext(new ExecutionAttributes())); + try { + assertSame(AgentTracer.noopSpan(), Context.current()); + } finally { + AwsHttpClientInstrumentation.SyncHttpRequestAdvice.methodExit(previous); + } + + assertSame(caller, Context.current()); + assertFalse(Context.isCaptureEnabled()); + } finally { + original.swap(); + AgentTracer.installLegacyContextManager(); + } + } +} diff --git a/dd-java-agent/instrumentation/karate/karate-1.0/build.gradle b/dd-java-agent/instrumentation/karate/karate-1.0/build.gradle index d8adcbb11cd..89bc3224b0c 100644 --- a/dd-java-agent/instrumentation/karate/karate-1.0/build.gradle +++ b/dd-java-agent/instrumentation/karate/karate-1.0/build.gradle @@ -114,9 +114,13 @@ sourceSets { // karate 1.4.0+ requires Java 11: https://github.com/karatelabs/karate/releases/tag/v1.4.0 tasks.named("karate141Test", Test) { - onlyIf { javaVersion.isJava11Compatible() } + testJvmConstraints { + minJavaVersion = JavaVersion.VERSION_11 + } } tasks.named("latestDepTest", Test) { - onlyIf { javaVersion >= JavaVersion.VERSION_17 } + testJvmConstraints { + minJavaVersion = JavaVersion.VERSION_17 + } } diff --git a/dd-java-agent/instrumentation/karate/karate-1.0/src/main/java/datadog/trace/instrumentation/karate/KarateInstrumentation.java b/dd-java-agent/instrumentation/karate/karate-1.0/src/main/java/datadog/trace/instrumentation/karate/KarateInstrumentation.java index 481e4602a0a..e2522c8fbfd 100644 --- a/dd-java-agent/instrumentation/karate/karate-1.0/src/main/java/datadog/trace/instrumentation/karate/KarateInstrumentation.java +++ b/dd-java-agent/instrumentation/karate/karate-1.0/src/main/java/datadog/trace/instrumentation/karate/KarateInstrumentation.java @@ -6,11 +6,12 @@ import com.intuit.karate.Runner; import com.intuit.karate.RuntimeHook; import com.intuit.karate.core.FeatureRuntime; +import com.intuit.karate.core.ScenarioRuntime; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.ContextStore; import datadog.trace.bootstrap.InstrumentationContext; -import java.util.Collections; +import java.util.HashMap; import java.util.Map; import net.bytebuddy.asm.Advice; @@ -29,7 +30,11 @@ public String instrumentedType() { @Override public Map contextStore() { - return Collections.singletonMap("com.intuit.karate.core.FeatureRuntime", "java.lang.Boolean"); + Map stores = new HashMap<>(); + stores.put("com.intuit.karate.core.FeatureRuntime", "java.lang.Boolean"); + stores.put( + "com.intuit.karate.core.ScenarioRuntime", packageName + ".KarateTracingHook$StepContext"); + return stores; } @Override @@ -44,7 +49,11 @@ public static void onRunnerBuilderConstructorExit( @Advice.This Runner.Builder runnerBuilder) { ContextStore featureRuntimeContextStore = InstrumentationContext.get(FeatureRuntime.class, Boolean.class); - runnerBuilder.hook(new KarateTracingHook(featureRuntimeContextStore)); + runnerBuilder.hook( + new KarateTracingHook( + featureRuntimeContextStore, + InstrumentationContext.get( + ScenarioRuntime.class, KarateTracingHook.StepContext.class))); } // Karate 1.0.0 and above diff --git a/dd-java-agent/instrumentation/karate/karate-1.0/src/main/java/datadog/trace/instrumentation/karate/KarateTracingHook.java b/dd-java-agent/instrumentation/karate/karate-1.0/src/main/java/datadog/trace/instrumentation/karate/KarateTracingHook.java index 710418789ba..cf0da11edbe 100644 --- a/dd-java-agent/instrumentation/karate/karate-1.0/src/main/java/datadog/trace/instrumentation/karate/KarateTracingHook.java +++ b/dd-java-agent/instrumentation/karate/karate-1.0/src/main/java/datadog/trace/instrumentation/karate/KarateTracingHook.java @@ -12,7 +12,9 @@ import com.intuit.karate.core.ScenarioRuntime; import com.intuit.karate.core.Step; import com.intuit.karate.core.StepResult; +import datadog.context.ContextHandle; import datadog.trace.api.Config; +import datadog.trace.api.InstrumenterConfig; import datadog.trace.api.civisibility.CIConstants; import datadog.trace.api.civisibility.config.TestIdentifier; import datadog.trace.api.civisibility.config.TestSourceData; @@ -35,9 +37,23 @@ public class KarateTracingHook implements RuntimeHook { public static final String KARATE_STEP_SPAN_NAME = "karate.step"; private final ContextStore manualFeatureHooks; + private final ContextStore stepContexts; - public KarateTracingHook(ContextStore manualFeatureHooks) { + public static final class StepContext { + final AgentSpan span; + final ContextHandle previousContext; + + StepContext(AgentSpan span) { + this.span = span; + this.previousContext = span.swap(); + } + } + + public KarateTracingHook( + ContextStore manualFeatureHooks, + ContextStore stepContexts) { this.manualFeatureHooks = manualFeatureHooks; + this.stepContexts = stepContexts; } @Override @@ -156,6 +172,9 @@ public boolean beforeScenario(ScenarioRuntime sr) { @Override public void afterScenario(ScenarioRuntime sr) { + if (!InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + finishStep(sr); + } if (skipTracking(sr)) { return; } @@ -199,11 +218,19 @@ private Throwable getFailedReason(ScenarioResult result) { @Override public boolean beforeStep(Step step, ScenarioRuntime sr) { + if (!InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + // A veto from another hook skips afterStep, leaving the previous step attached. + finishStep(sr); + } if (skipTracking(step)) { return true; } AgentSpan span = AgentTracer.startSpan("karate", KARATE_STEP_SPAN_NAME); - AgentTracer.activateSpanWithoutScope(span); + if (InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + AgentTracer.get().activateSpanWithoutScope(span); + } else { + stepContexts.put(sr, new StepContext(span)); + } String stepName = step.getPrefix() + " " + step.getText(); span.setResourceName(stepName); span.setTag(Tags.COMPONENT, "karate"); @@ -217,17 +244,27 @@ public boolean beforeStep(Step step, ScenarioRuntime sr) { @Override public void afterStep(StepResult result, ScenarioRuntime sr) { - if (skipTracking(result.getStep())) { - return; + if (InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + if (skipTracking(result.getStep())) { + return; + } + AgentSpan span = AgentTracer.activeSpan(); + if (span == null) { + return; + } + AgentTracer.get().closeActive(); + span.finish(); + } else { + finishStep(sr); } + } - AgentSpan span = AgentTracer.activeSpan(); - if (span == null) { - return; + private void finishStep(ScenarioRuntime sr) { + StepContext stepContext = stepContexts.remove(sr); + if (stepContext != null) { + stepContext.previousContext.swap(); + stepContext.span.finish(); } - - AgentTracer.closeActive(); - span.finish(); } private static boolean skipTracking(FeatureRuntime fr) { diff --git a/dd-java-agent/instrumentation/karate/karate-1.0/src/test/groovy/KarateTest.groovy b/dd-java-agent/instrumentation/karate/karate-1.0/src/test/groovy/KarateTest.groovy index 1c28f3a90dd..35a5a89fac5 100644 --- a/dd-java-agent/instrumentation/karate/karate-1.0/src/test/groovy/KarateTest.groovy +++ b/dd-java-agent/instrumentation/karate/karate-1.0/src/test/groovy/KarateTest.groovy @@ -283,3 +283,15 @@ class KarateTest extends CiVisibilityInstrumentationTest { } } } + +@IgnoreIf(reason = "Karate does not support Java 24+ yet", value = { + JavaVirtualMachine.isJavaVersionAtLeast(24) +}) +@DisableTestTrace(reason = "avoid self-tracing") +class ContextSwapKarateForkedTest extends KarateTest { + @Override + void configurePreAgent() { + super.configurePreAgent() + injectSysConfig("legacy.context-manager.enabled", "false") + } +} diff --git a/dd-java-agent/instrumentation/karate/karate-1.0/src/test/java/datadog/trace/instrumentation/karate/StepContextRestorationTest.java b/dd-java-agent/instrumentation/karate/karate-1.0/src/test/java/datadog/trace/instrumentation/karate/StepContextRestorationTest.java new file mode 100644 index 00000000000..a5e1925f6b6 --- /dev/null +++ b/dd-java-agent/instrumentation/karate/karate-1.0/src/test/java/datadog/trace/instrumentation/karate/StepContextRestorationTest.java @@ -0,0 +1,81 @@ +package datadog.trace.instrumentation.karate; + +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.condition.JRE.JAVA_23; + +import com.intuit.karate.core.Feature; +import com.intuit.karate.core.FeatureRuntime; +import com.intuit.karate.core.Scenario; +import com.intuit.karate.core.ScenarioRuntime; +import com.intuit.karate.core.Step; +import com.intuit.karate.core.StepResult; +import datadog.context.Context; +import datadog.context.ContextHandle; +import datadog.trace.bootstrap.ContextStore; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.bootstrap.instrumentation.api.InternalSpanTypes; +import datadog.trace.civisibility.utils.StrongMapContextStore; +import datadog.trace.common.writer.ListWriter; +import datadog.trace.core.CoreTracer; +import datadog.trace.core.DDSpan; +import datadog.trace.test.junit.utils.config.WithConfig; +import datadog.trace.test.util.DDJavaSpecification; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.condition.EnabledForJreRange; + +@WithConfig(key = "legacy.context-manager.enabled", value = "false") +@EnabledForJreRange(max = JAVA_23) +class StepContextRestorationTest extends DDJavaSpecification { + private CoreTracer tracer; + private AgentTracer.TracerAPI previousTracer; + private ContextHandle previousContext; + DDSpan parent; + + @BeforeEach + void setUpTracer() { + previousTracer = AgentTracer.get(); + tracer = CoreTracer.builder().writer(new ListWriter()).build(); + AgentTracer.forceRegister(tracer); + AgentTracer.installLegacyContextManager(); + previousContext = Context.current().checkpoint(); + parent = (DDSpan) tracer.startSpan("test", "parent"); + parent.setSpanType(InternalSpanTypes.TEST); + parent.swap(); + } + + @AfterEach + void restoreTracer() { + previousContext.swap(); + parent.finish(); + tracer.close(); + AgentTracer.forceRegister(previousTracer); + } + + @Test + void savedStepIsFinishedEvenWhenAnApplicationSpanIsLeftActive() { + Feature feature = Feature.read("classpath:org/example/test_succeed_one_case.feature"); + Scenario scenario = feature.getSections().get(0).getScenario(); + ScenarioRuntime runtime = new ScenarioRuntime(FeatureRuntime.of(feature), scenario); + Step step = scenario.getSteps().get(0); + ContextStore steps = + new StrongMapContextStore<>(); + KarateTracingHook hook = new KarateTracingHook(new StrongMapContextStore<>(), steps); + hook.beforeStep(step, runtime); + DDSpan stepSpan = (DDSpan) AgentTracer.activeSpan(); + DDSpan applicationSpan = (DDSpan) tracer.startSpan("test", "application"); + applicationSpan.swap(); + + hook.afterStep(new StepResult(step, null), runtime); + + assertTrue(stepSpan.isFinished()); + assertSame(parent, Context.current()); + assertNull(steps.get(runtime)); + hook.afterStep(new StepResult(step, null), runtime); + assertSame(parent, Context.current()); + applicationSpan.finish(); + } +} diff --git a/dd-java-agent/instrumentation/karate/karate-1.0/src/test/java/datadog/trace/instrumentation/karate/StepVetoForkedTest.java b/dd-java-agent/instrumentation/karate/karate-1.0/src/test/java/datadog/trace/instrumentation/karate/StepVetoForkedTest.java new file mode 100644 index 00000000000..f1950138f57 --- /dev/null +++ b/dd-java-agent/instrumentation/karate/karate-1.0/src/test/java/datadog/trace/instrumentation/karate/StepVetoForkedTest.java @@ -0,0 +1,112 @@ +package datadog.trace.instrumentation.karate; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.condition.JRE.JAVA_23; + +import com.intuit.karate.Results; +import com.intuit.karate.Runner; +import com.intuit.karate.RuntimeHook; +import com.intuit.karate.core.Feature; +import com.intuit.karate.core.ScenarioRuntime; +import com.intuit.karate.core.Step; +import datadog.context.Context; +import datadog.context.ContextHandle; +import datadog.trace.api.civisibility.InstrumentationBridge; +import datadog.trace.api.civisibility.events.TestDescriptor; +import datadog.trace.api.civisibility.events.TestSuiteDescriptor; +import datadog.trace.api.civisibility.execution.TestExecutionTracker; +import datadog.trace.bootstrap.ContextStore; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.civisibility.events.NoOpTestEventsHandler; +import datadog.trace.civisibility.utils.StrongMapContextStore; +import datadog.trace.core.DDSpan; +import datadog.trace.test.junit.utils.config.WithConfig; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.condition.EnabledForJreRange; + +@WithConfig(key = "legacy.context-manager.enabled", value = "false") +@EnabledForJreRange(max = JAVA_23) +class StepVetoForkedTest extends StepContextRestorationTest { + @BeforeAll + static void setUpHandlerFactory() { + // This fork owns the handler factory; scenario events do not create additional test spans. + InstrumentationBridge.registerTestEventsHandlerFactory(new NoOpTestEventsHandler.Factory()); + } + + @AfterEach + void stopHandler() { + TestEventsHandlerHolder.stop(); + } + + @Test + void vetoedMiddleAndFinalStepsAreFinishedBeforeTheTestEnds() { + Context.setCaptureEnabled(false); + Feature feature = Feature.read("classpath:org/example/test_vetoed_steps.feature"); + ContextStore steps = + new StrongMapContextStore<>(); + KarateTracingHook hook = new KarateTracingHook(new StrongMapContextStore<>(), steps); + List stepSpans = new ArrayList<>(); + AtomicInteger testEnds = new AtomicInteger(); + TestEventsHandlerHolder.TEST_EVENTS_HANDLER = + new NoOpTestEventsHandler() { + @Override + public void onTestFinish( + TestDescriptor descriptor, Long endTime, TestExecutionTracker executionTracker) { + assertSame(parent, Context.current()); + assertFalse(Context.isCaptureEnabled()); + assertEquals(4, stepSpans.size()); + assertTrue(stepSpans.stream().allMatch(DDSpan::isFinished)); + testEnds.incrementAndGet(); + } + }; + AtomicReference scenario = new AtomicReference<>(); + RuntimeHook veto = + new RuntimeHook() { + private ContextHandle previous; + + @Override + public boolean beforeScenario(ScenarioRuntime runtime) { + scenario.set(runtime); + previous = parent.swap(); + Context.setCaptureEnabled(false); + return true; + } + + @Override + public void afterScenario(ScenarioRuntime runtime) { + previous.swap(); + } + + @Override + public boolean beforeStep(Step step, ScenarioRuntime runtime) { + DDSpan span = (DDSpan) AgentTracer.activeSpan(); + assertEquals(KarateTracingHook.KARATE_STEP_SPAN_NAME, span.getSpanName().toString()); + assertEquals(parent.getSpanId(), span.getParentId()); + if (stepSpans.size() == 2) { + assertTrue(stepSpans.get(1).isFinished()); + } + stepSpans.add(span); + return !step.getText().startsWith("def veto"); + } + }; + Results result = Runner.builder().features(feature).hook(hook).hook(veto).parallel(1); + + assertEquals(0, result.getFailCount()); + assertEquals(1, testEnds.get()); + assertNull(steps.get(scenario.get())); + assertSame(parent, Context.current()); + assertFalse(Context.isCaptureEnabled()); + assertEquals(4, stepSpans.size()); + assertTrue(stepSpans.stream().allMatch(DDSpan::isFinished)); + } +} diff --git a/dd-java-agent/instrumentation/karate/karate-1.0/src/test/java/org/example/test_vetoed_steps.feature b/dd-java-agent/instrumentation/karate/karate-1.0/src/test/java/org/example/test_vetoed_steps.feature new file mode 100644 index 00000000000..1062fc7dd48 --- /dev/null +++ b/dd-java-agent/instrumentation/karate/karate-1.0/src/test/java/org/example/test_vetoed_steps.feature @@ -0,0 +1,7 @@ +Feature: vetoed steps + + Scenario: veto a middle and final step + * def first = true + * def vetoMiddle = true + * match first == true + * def vetoFinal = true diff --git a/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java/datadog/trace/instrumentation/karate2/KarateExecutionInstrumentation.java b/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java/datadog/trace/instrumentation/karate2/KarateExecutionInstrumentation.java index f1329621fcb..327cc8835b1 100644 --- a/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java/datadog/trace/instrumentation/karate2/KarateExecutionInstrumentation.java +++ b/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java/datadog/trace/instrumentation/karate2/KarateExecutionInstrumentation.java @@ -47,7 +47,8 @@ public String[] helperClassNames() { packageName + ".KarateUtils", packageName + ".TestEventsHandlerHolder", packageName + ".ExecutionContext", - packageName + ".KarateTracingListener" + packageName + ".KarateTracingListener", + packageName + ".KarateTracingListener$StepContext" }; } diff --git a/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java/datadog/trace/instrumentation/karate2/KarateInstrumentation.java b/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java/datadog/trace/instrumentation/karate2/KarateInstrumentation.java index c7f1abc0725..69137d418c5 100644 --- a/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java/datadog/trace/instrumentation/karate2/KarateInstrumentation.java +++ b/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java/datadog/trace/instrumentation/karate2/KarateInstrumentation.java @@ -5,7 +5,7 @@ import com.google.auto.service.AutoService; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; -import java.util.Collections; +import java.util.HashMap; import java.util.Map; /** @@ -35,14 +35,18 @@ public String[] helperClassNames() { packageName + ".KarateUtils", packageName + ".TestEventsHandlerHolder", packageName + ".ExecutionContext", - packageName + ".KarateTracingListener" + packageName + ".KarateTracingListener", + packageName + ".KarateTracingListener$StepContext" }; } @Override public Map contextStore() { - return Collections.singletonMap( - "io.karatelabs.gherkin.Scenario", packageName + ".ExecutionContext"); + Map stores = new HashMap<>(); + stores.put("io.karatelabs.gherkin.Scenario", packageName + ".ExecutionContext"); + stores.put( + "io.karatelabs.core.ScenarioRuntime", packageName + ".KarateTracingListener$StepContext"); + return stores; } @Override diff --git a/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java21/datadog/trace/instrumentation/karate2/KarateBuilderAdvice.java b/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java21/datadog/trace/instrumentation/karate2/KarateBuilderAdvice.java index 54bda255b9c..ef16fd5812f 100644 --- a/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java21/datadog/trace/instrumentation/karate2/KarateBuilderAdvice.java +++ b/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java21/datadog/trace/instrumentation/karate2/KarateBuilderAdvice.java @@ -15,7 +15,13 @@ public class KarateBuilderAdvice { public static void onRunnerBuilderConstructorExit(@Advice.This Runner.Builder builder) { ContextStore scenarioContext = InstrumentationContext.get(Scenario.class, ExecutionContext.class); - builder.listener(new KarateTracingListener(scenarioContext)); + // Keep ScenarioRuntime unloaded until its retry advice can be applied on first use. + builder.listener( + new KarateTracingListener( + scenarioContext, + InstrumentationContext.get( + "io.karatelabs.core.ScenarioRuntime", + "datadog.trace.instrumentation.karate2.KarateTracingListener$StepContext"))); } // Karate 2.0.0 and above diff --git a/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java21/datadog/trace/instrumentation/karate2/KarateTracingListener.java b/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java21/datadog/trace/instrumentation/karate2/KarateTracingListener.java index ead16307d1f..3a621ab43db 100644 --- a/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java21/datadog/trace/instrumentation/karate2/KarateTracingListener.java +++ b/dd-java-agent/instrumentation/karate/karate-2.0/src/main/java21/datadog/trace/instrumentation/karate2/KarateTracingListener.java @@ -1,6 +1,8 @@ package datadog.trace.instrumentation.karate2; +import datadog.context.ContextHandle; import datadog.trace.api.Config; +import datadog.trace.api.InstrumenterConfig; import datadog.trace.api.civisibility.CIConstants; import datadog.trace.api.civisibility.config.TestIdentifier; import datadog.trace.api.civisibility.config.TestSourceData; @@ -37,9 +39,23 @@ public class KarateTracingListener implements RunListener { public static final String KARATE_STEP_SPAN_NAME = "karate.step"; private final ContextStore scenarioContext; + private final ContextStore stepContexts; - public KarateTracingListener(ContextStore scenarioContext) { + public static final class StepContext { + final AgentSpan span; + final ContextHandle previousContext; + + StepContext(AgentSpan span) { + this.span = span; + this.previousContext = span.swap(); + } + } + + public KarateTracingListener( + ContextStore scenarioContext, + ContextStore stepContexts) { this.scenarioContext = scenarioContext; + this.stepContexts = stepContexts; } @Override @@ -63,6 +79,9 @@ public boolean onEvent(RunEvent event) { private void afterScenario(ScenarioRunEvent event) { ScenarioRuntime sr = event.source(); + if (!InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + finishStep(sr); + } Scenario scenario = sr.getScenario(); // A context means call advice will finish the test after scenario post-processing. if (scenarioContext.get(scenario) == null) { @@ -190,12 +209,20 @@ public static void afterScenario( } private void beforeStep(StepRunEvent event) { + if (!InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + // A veto from another listener skips STEP_EXIT, leaving the previous step attached. + finishStep(event.scenarioRuntime()); + } Step step = event.step(); if (skipTracking(step)) { return; } AgentSpan span = AgentTracer.startSpan("karate", KARATE_STEP_SPAN_NAME); - AgentTracer.activateSpanWithoutScope(span); + if (InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + AgentTracer.get().activateSpanWithoutScope(span); + } else { + stepContexts.put(event.scenarioRuntime(), new StepContext(span)); + } String stepName = step.getPrefix() + " " + step.getText(); span.setResourceName(stepName); span.setTag(Tags.COMPONENT, "karate"); @@ -207,17 +234,27 @@ private void beforeStep(StepRunEvent event) { } private void afterStep(StepRunEvent event) { - if (skipTracking(event.step())) { - return; + if (InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + if (skipTracking(event.step())) { + return; + } + AgentSpan span = AgentTracer.activeSpan(); + if (span == null) { + return; + } + AgentTracer.get().closeActive(); + span.finish(); + } else { + finishStep(event.scenarioRuntime()); } + } - AgentSpan span = AgentTracer.activeSpan(); - if (span == null) { - return; + private void finishStep(ScenarioRuntime sr) { + StepContext stepContext = stepContexts.remove(sr); + if (stepContext != null) { + stepContext.previousContext.swap(); + stepContext.span.finish(); } - - AgentTracer.closeActive(); - span.finish(); } private static Throwable getFailedReason(ScenarioResult result, Throwable suppressedError) { diff --git a/dd-java-agent/instrumentation/karate/karate-2.0/src/test/groovy/KarateV2Test.groovy b/dd-java-agent/instrumentation/karate/karate-2.0/src/test/groovy/KarateV2Test.groovy index b4f02ca2d69..74122283dc9 100644 --- a/dd-java-agent/instrumentation/karate/karate-2.0/src/test/groovy/KarateV2Test.groovy +++ b/dd-java-agent/instrumentation/karate/karate-2.0/src/test/groovy/KarateV2Test.groovy @@ -261,3 +261,12 @@ class KarateV2Test extends CiVisibilityInstrumentationTest { } } } + +@DisableTestTrace(reason = "avoid self-tracing") +class ContextSwapKarateV2ForkedTest extends KarateV2Test { + @Override + void configurePreAgent() { + super.configurePreAgent() + injectSysConfig("legacy.context-manager.enabled", "false") + } +} diff --git a/dd-java-agent/instrumentation/karate/karate-2.0/src/test/java/datadog/trace/instrumentation/karate2/LegacyColdStartRetryForkedTest.java b/dd-java-agent/instrumentation/karate/karate-2.0/src/test/java/datadog/trace/instrumentation/karate2/LegacyColdStartRetryForkedTest.java new file mode 100644 index 00000000000..2479c7c0060 --- /dev/null +++ b/dd-java-agent/instrumentation/karate/karate-2.0/src/test/java/datadog/trace/instrumentation/karate2/LegacyColdStartRetryForkedTest.java @@ -0,0 +1,127 @@ +package datadog.trace.instrumentation.karate2; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import datadog.trace.agent.test.AbstractInstrumentationTest; +import datadog.trace.api.DisableTestTrace; +import datadog.trace.api.civisibility.DDTest; +import datadog.trace.api.civisibility.DDTestSuite; +import datadog.trace.api.civisibility.InstrumentationBridge; +import datadog.trace.api.civisibility.config.LibraryCapability; +import datadog.trace.api.civisibility.config.TestIdentifier; +import datadog.trace.api.civisibility.config.TestSourceData; +import datadog.trace.api.civisibility.events.TestDescriptor; +import datadog.trace.api.civisibility.events.TestEventsHandler; +import datadog.trace.api.civisibility.events.TestSuiteDescriptor; +import datadog.trace.api.civisibility.execution.TestExecutionPolicy; +import datadog.trace.api.civisibility.execution.TestExecutionTracker; +import datadog.trace.api.civisibility.execution.TestStatus; +import datadog.trace.bootstrap.ContextStore; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.bootstrap.instrumentation.api.InternalSpanTypes; +import datadog.trace.civisibility.events.NoOpTestEventsHandler; +import datadog.trace.civisibility.execution.AutoTestRetry; +import datadog.trace.core.DDSpan; +import datadog.trace.test.junit.utils.config.WithConfig; +import io.karatelabs.core.Runner; +import io.karatelabs.core.SuiteResult; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.List; +import java.util.concurrent.atomic.AtomicInteger; +import net.bytebuddy.agent.ByteBuddyAgent; +import org.junit.jupiter.api.Test; + +@DisableTestTrace( + reason = "exercise the first Karate scenario without tracing the outer JUnit test") +@WithConfig(key = "legacy.context-manager.enabled", value = "true") +@WithConfig(key = "civisibility.enabled", value = "true") +class LegacyColdStartRetryForkedTest extends AbstractInstrumentationTest { + @Test + void firstScenarioIsRetriedWithoutPreloadingItsRuntime() { + assertFalse( + Arrays.stream(ByteBuddyAgent.getInstrumentation().getAllLoadedClasses()) + .anyMatch(type -> "io.karatelabs.core.ScenarioRuntime".equals(type.getName())), + "The test must start before ScenarioRuntime has been loaded"); + RetryHandler handler = new RetryHandler(); + InstrumentationBridge.registerTestEventsHandlerFactory( + new TestEventsHandler.Factory() { + @Override + @SuppressWarnings("unchecked") + public TestEventsHandler create( + String component, + ContextStore suites, + ContextStore tests, + Collection capabilities) { + return (TestEventsHandler) handler; + } + }); + + SuiteResult result = + Runner.path("classpath:org/example/test_failed_then_succeed.feature").parallel(1); + + assertEquals( + 1, handler.policyRequests, "Retry advice must request a policy for the first scenario"); + assertEquals(0, result.getScenarioFailedCount(), () -> result.getErrors().toString()); + assertEquals(3, handler.attempts.size()); + assertEquals(2, handler.retries.get()); + assertTrue(handler.attempts.get(0).isError()); + assertTrue(handler.attempts.get(1).isError()); + assertFalse(handler.attempts.get(2).isError()); + assertTrue(handler.attempts.stream().allMatch(DDSpan::isFinished)); + assertNull(AgentTracer.activeSpan()); + } + + private static final class RetryHandler + extends NoOpTestEventsHandler { + private final AtomicInteger retries = new AtomicInteger(); + private final TestExecutionPolicy policy = new AutoTestRetry(3, false, retries); + private final List attempts = new ArrayList<>(); + private int policyRequests; + private DDSpan current; + + @Override + public TestExecutionPolicy executionPolicy( + TestIdentifier test, TestSourceData source, Collection tags) { + policyRequests++; + return policy; + } + + @Override + public void onTestStart( + TestSuiteDescriptor suite, + TestDescriptor test, + String name, + String framework, + String version, + String parameters, + Collection tags, + TestSourceData source, + Long startTime, + TestExecutionTracker tracker) { + assertSame(policy, tracker, "Retry advice must apply to the first scenario invocation"); + current = (DDSpan) AgentTracer.get().startSpan("test", "karate.test"); + current.setSpanType(InternalSpanTypes.TEST); + attempts.add(current); + AgentTracer.get().activateSpanWithoutScope(current); + } + + @Override + public void onTestFailure(TestDescriptor test, Throwable error) { + current.addThrowable(error); + } + + @Override + public void onTestFinish(TestDescriptor test, Long endTime, TestExecutionTracker tracker) { + assertSame(current, AgentTracer.activeSpan()); + tracker.registerExecution(current.isError() ? TestStatus.fail : TestStatus.pass, 0); + AgentTracer.get().closeActive(); + current.finish(); + } + } +} diff --git a/dd-java-agent/instrumentation/karate/karate-2.0/src/test/java/datadog/trace/instrumentation/karate2/StepContextRestorationTest.java b/dd-java-agent/instrumentation/karate/karate-2.0/src/test/java/datadog/trace/instrumentation/karate2/StepContextRestorationTest.java new file mode 100644 index 00000000000..6668437064b --- /dev/null +++ b/dd-java-agent/instrumentation/karate/karate-2.0/src/test/java/datadog/trace/instrumentation/karate2/StepContextRestorationTest.java @@ -0,0 +1,81 @@ +package datadog.trace.instrumentation.karate2; + +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import datadog.context.Context; +import datadog.context.ContextHandle; +import datadog.trace.bootstrap.ContextStore; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.bootstrap.instrumentation.api.InternalSpanTypes; +import datadog.trace.civisibility.utils.StrongMapContextStore; +import datadog.trace.common.writer.ListWriter; +import datadog.trace.core.CoreTracer; +import datadog.trace.core.DDSpan; +import datadog.trace.test.junit.utils.config.WithConfig; +import datadog.trace.test.util.DDJavaSpecification; +import io.karatelabs.common.Resource; +import io.karatelabs.core.KarateJs; +import io.karatelabs.core.ScenarioRuntime; +import io.karatelabs.core.StepResult; +import io.karatelabs.core.StepRunEvent; +import io.karatelabs.gherkin.Feature; +import io.karatelabs.gherkin.Scenario; +import io.karatelabs.gherkin.Step; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +@WithConfig(key = "legacy.context-manager.enabled", value = "false") +class StepContextRestorationTest extends DDJavaSpecification { + private CoreTracer tracer; + private AgentTracer.TracerAPI previousTracer; + private ContextHandle previousContext; + DDSpan parent; + + @BeforeEach + void setUpTracer() { + previousTracer = AgentTracer.get(); + tracer = CoreTracer.builder().writer(new ListWriter()).build(); + AgentTracer.forceRegister(tracer); + AgentTracer.installLegacyContextManager(); + previousContext = Context.current().checkpoint(); + parent = (DDSpan) tracer.startSpan("test", "parent"); + parent.setSpanType(InternalSpanTypes.TEST); + parent.swap(); + } + + @AfterEach + void restoreTracer() { + previousContext.swap(); + parent.finish(); + tracer.close(); + AgentTracer.forceRegister(previousTracer); + } + + @Test + void savedStepIsFinishedEvenWhenAnApplicationSpanIsLeftActive() { + Resource resource = Resource.path("classpath:org/example/test_succeed_one_case.feature"); + Feature feature = Feature.read(resource); + Scenario scenario = feature.getSections().get(0).getScenario(); + ScenarioRuntime runtime = new ScenarioRuntime(new KarateJs(resource), scenario); + Step step = scenario.getSteps().get(0); + ContextStore steps = + new StrongMapContextStore<>(); + KarateTracingListener hook = new KarateTracingListener(new StrongMapContextStore<>(), steps); + hook.onEvent(StepRunEvent.enter(step, runtime)); + DDSpan stepSpan = (DDSpan) AgentTracer.activeSpan(); + DDSpan applicationSpan = (DDSpan) tracer.startSpan("test", "application"); + applicationSpan.swap(); + + hook.onEvent(StepRunEvent.exit(StepResult.passed(step, 0, 0), runtime)); + + assertTrue(stepSpan.isFinished()); + assertSame(parent, Context.current()); + assertNull(steps.get(runtime)); + hook.onEvent(StepRunEvent.exit(StepResult.passed(step, 0, 0), runtime)); + assertSame(parent, Context.current()); + applicationSpan.finish(); + } +} diff --git a/dd-java-agent/instrumentation/karate/karate-2.0/src/test/java/datadog/trace/instrumentation/karate2/StepVetoForkedTest.java b/dd-java-agent/instrumentation/karate/karate-2.0/src/test/java/datadog/trace/instrumentation/karate2/StepVetoForkedTest.java new file mode 100644 index 00000000000..10f337b0ef6 --- /dev/null +++ b/dd-java-agent/instrumentation/karate/karate-2.0/src/test/java/datadog/trace/instrumentation/karate2/StepVetoForkedTest.java @@ -0,0 +1,100 @@ +package datadog.trace.instrumentation.karate2; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import datadog.context.Context; +import datadog.trace.api.civisibility.InstrumentationBridge; +import datadog.trace.api.civisibility.events.TestDescriptor; +import datadog.trace.api.civisibility.events.TestSuiteDescriptor; +import datadog.trace.api.civisibility.execution.TestExecutionTracker; +import datadog.trace.bootstrap.ContextStore; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.civisibility.events.NoOpTestEventsHandler; +import datadog.trace.civisibility.utils.StrongMapContextStore; +import datadog.trace.core.DDSpan; +import datadog.trace.test.junit.utils.config.WithConfig; +import io.karatelabs.common.Resource; +import io.karatelabs.core.FeatureRuntime; +import io.karatelabs.core.RunEventType; +import io.karatelabs.core.RunListener; +import io.karatelabs.core.Runner; +import io.karatelabs.core.ScenarioRuntime; +import io.karatelabs.core.StepRunEvent; +import io.karatelabs.core.Suite; +import io.karatelabs.gherkin.Feature; +import io.karatelabs.gherkin.Scenario; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.atomic.AtomicInteger; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +@WithConfig(key = "legacy.context-manager.enabled", value = "false") +class StepVetoForkedTest extends StepContextRestorationTest { + @BeforeAll + static void setUpHandlerFactory() { + // This fork owns the handler factory; scenario events do not create additional test spans. + InstrumentationBridge.registerTestEventsHandlerFactory(new NoOpTestEventsHandler.Factory()); + } + + @AfterEach + void stopHandler() { + TestEventsHandlerHolder.stop(); + } + + @Test + void vetoedMiddleAndFinalStepsAreFinishedBeforeTheTestEnds() { + Context.setCaptureEnabled(false); + Feature feature = + Feature.read(Resource.path("classpath:org/example/test_vetoed_steps.feature")); + Scenario scenario = feature.getSections().get(0).getScenario(); + ContextStore steps = + new StrongMapContextStore<>(); + KarateTracingListener listener = + new KarateTracingListener(new StrongMapContextStore<>(), steps); + List stepSpans = new ArrayList<>(); + AtomicInteger testEnds = new AtomicInteger(); + TestEventsHandlerHolder.TEST_EVENTS_HANDLER = + new NoOpTestEventsHandler() { + @Override + public void onTestFinish( + TestDescriptor descriptor, Long endTime, TestExecutionTracker executionTracker) { + assertSame(parent, Context.current()); + assertFalse(Context.isCaptureEnabled()); + assertEquals(4, stepSpans.size()); + assertTrue(stepSpans.stream().allMatch(DDSpan::isFinished)); + testEnds.incrementAndGet(); + } + }; + RunListener veto = + event -> { + if (event.getType() != RunEventType.STEP_ENTER) { + return true; + } + DDSpan span = (DDSpan) AgentTracer.activeSpan(); + assertEquals(KarateTracingListener.KARATE_STEP_SPAN_NAME, span.getSpanName().toString()); + assertEquals(parent.getSpanId(), span.getParentId()); + if (stepSpans.size() == 2) { + assertTrue(stepSpans.get(1).isFinished()); + } + stepSpans.add(span); + return !((StepRunEvent) event).step().getText().startsWith("def veto"); + }; + Suite suite = Runner.features(feature).listener(listener).listener(veto).buildSuite(); + ScenarioRuntime runtime = new ScenarioRuntime(FeatureRuntime.of(suite, feature), scenario); + + assertFalse(runtime.call().isFailed()); + + assertEquals(1, testEnds.get()); + assertNull(steps.get(runtime)); + assertSame(parent, Context.current()); + assertFalse(Context.isCaptureEnabled()); + assertEquals(4, stepSpans.size()); + assertTrue(stepSpans.stream().allMatch(DDSpan::isFinished)); + } +} diff --git a/dd-java-agent/instrumentation/karate/karate-2.0/src/test/java/org/example/test_vetoed_steps.feature b/dd-java-agent/instrumentation/karate/karate-2.0/src/test/java/org/example/test_vetoed_steps.feature new file mode 100644 index 00000000000..1062fc7dd48 --- /dev/null +++ b/dd-java-agent/instrumentation/karate/karate-2.0/src/test/java/org/example/test_vetoed_steps.feature @@ -0,0 +1,7 @@ +Feature: vetoed steps + + Scenario: veto a middle and final step + * def first = true + * def vetoMiddle = true + * match first == true + * def vetoFinal = true diff --git a/dd-java-agent/instrumentation/mongo/mongo-common/src/main/java/datadog/trace/instrumentation/mongo/MongoCommandListener.java b/dd-java-agent/instrumentation/mongo/mongo-common/src/main/java/datadog/trace/instrumentation/mongo/MongoCommandListener.java index c5e7f366a13..136dba0368b 100644 --- a/dd-java-agent/instrumentation/mongo/mongo-common/src/main/java/datadog/trace/instrumentation/mongo/MongoCommandListener.java +++ b/dd-java-agent/instrumentation/mongo/mongo-common/src/main/java/datadog/trace/instrumentation/mongo/MongoCommandListener.java @@ -2,8 +2,6 @@ import static datadog.trace.api.Functions.UTF8_ENCODE; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.closeActive; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.startSpan; import com.mongodb.ServerAddress; @@ -126,11 +124,9 @@ public void commandStarted(final CommandStartedEvent event) { // If DBM comment injection is enabled, the span is created on the connection instrumentation // this is required because the comment injection needs to happen before the command is sent - AgentSpan span = activeSpan(); - boolean shouldForceCloseSpanScope = true; - if (span == null || span.getSpanName() != MongoDecorator.OPERATION_NAME) { + AgentSpan span = MongoPendingSpan.take(); + if (span == null) { span = startSpan("java-mongo", MongoDecorator.OPERATION_NAME); - shouldForceCloseSpanScope = false; } try (final ContextScope scope = activateSpan(span)) { @@ -156,10 +152,6 @@ public void commandStarted(final CommandStartedEvent event) { } decorator.onStatement(span, event.getCommand(), byteBufAccessor); spanMap.put(event.getRequestId(), new SpanEntry(span)); - - if (shouldForceCloseSpanScope) { - closeActive(); - } } } diff --git a/dd-java-agent/instrumentation/mongo/mongo-common/src/main/java/datadog/trace/instrumentation/mongo/MongoPendingSpan.java b/dd-java-agent/instrumentation/mongo/mongo-common/src/main/java/datadog/trace/instrumentation/mongo/MongoPendingSpan.java new file mode 100644 index 00000000000..a1587e8d17b --- /dev/null +++ b/dd-java-agent/instrumentation/mongo/mongo-common/src/main/java/datadog/trace/instrumentation/mongo/MongoPendingSpan.java @@ -0,0 +1,39 @@ +package datadog.trace.instrumentation.mongo; + +import datadog.trace.bootstrap.instrumentation.api.AgentSpan; + +/** + * Hands a pending span from command advice to the synchronous command-start listener on the same + * thread. The advice's call-depth guard allows only one pending command per thread. + */ +public final class MongoPendingSpan { + private static final ThreadLocal CURRENT = new ThreadLocal<>(); + + private MongoPendingSpan() {} + + public static void enter(AgentSpan span) { + CURRENT.set(span); + } + + /** Transfers ownership of the pending span to the command listener. */ + public static AgentSpan take() { + AgentSpan span = CURRENT.get(); + if (span != null) { + CURRENT.set(null); + } + return span; + } + + /** + * Finishes an unclaimed span when the driver exits before notifying the command-start listener. + */ + public static void onExit(AgentSpan span, Throwable error) { + if (span != null && CURRENT.get() == span) { + CURRENT.set(null); + if (error != null) { + span.addThrowable(error); + } + span.finish(); + } + } +} diff --git a/dd-java-agent/instrumentation/mongo/mongo-common/src/test/java/datadog/trace/instrumentation/mongo/MongoPendingSpanTest.java b/dd-java-agent/instrumentation/mongo/mongo-common/src/test/java/datadog/trace/instrumentation/mongo/MongoPendingSpanTest.java new file mode 100644 index 00000000000..298264e0f0e --- /dev/null +++ b/dd-java-agent/instrumentation/mongo/mongo-common/src/test/java/datadog/trace/instrumentation/mongo/MongoPendingSpanTest.java @@ -0,0 +1,219 @@ +package datadog.trace.instrumentation.mongo; + +import static datadog.trace.api.DDTags.ERROR_MSG; +import static datadog.trace.api.DDTags.ERROR_TYPE; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.mongodb.event.CommandStartedEvent; +import com.mongodb.event.CommandSucceededEvent; +import datadog.context.Context; +import datadog.context.ContextHandle; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.common.writer.ListWriter; +import datadog.trace.core.CoreTracer; +import datadog.trace.core.DDSpan; +import datadog.trace.test.junit.utils.config.WithConfig; +import datadog.trace.test.util.DDJavaSpecification; +import org.bson.BsonDocument; +import org.bson.BsonReader; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +@WithConfig(key = "legacy.context-manager.enabled", value = "false") +class MongoPendingSpanTest extends DDJavaSpecification { + private ContextHandle previousContext; + private AgentTracer.TracerAPI previousTracer; + private CoreTracer tracer; + private DDSpan parent; + private ListWriter writer; + + @BeforeEach + void setUpContext() { + previousTracer = AgentTracer.get(); + writer = new ListWriter(); + tracer = CoreTracer.builder().writer(writer).build(); + AgentTracer.forceRegister(tracer); + AgentTracer.installLegacyContextManager(); + previousContext = Context.current().checkpoint(); + parent = (DDSpan) tracer.startSpan("test", "parent"); + parent.swap(); + Context.setCaptureEnabled(false); + } + + @AfterEach + void restoreContext() { + MongoPendingSpan.take(); + previousContext.swap(); + parent.finish(); + tracer.close(); + AgentTracer.forceRegister(previousTracer); + } + + @Test + void pendingSpanDoesNotChangeContextOrCaptureFlags() { + Context caller = Context.current(); + DDSpan span = (DDSpan) tracer.startSpan("test", "command"); + MongoPendingSpan.enter(span); + + assertSame(caller, Context.current()); + assertFalse(Context.isCaptureEnabled()); + assertSame(span, MongoPendingSpan.take()); + assertNull(MongoPendingSpan.take()); + MongoPendingSpan.onExit(span, null); + assertSame(caller, Context.current()); + assertFalse(Context.isCaptureEnabled()); + assertFalse(span.isFinished()); + span.finish(); + } + + @Test + void failureBeforeCommandStartedFinishesTheUnclaimedSpan() throws Exception { + assertFailureBeforeCommandStarted(); + } + + @Test + @WithConfig(key = "legacy.context-manager.enabled", value = "true") + void legacyFailureBeforeCommandStartedFinishesTheUnclaimedSpan() throws Exception { + assertFailureBeforeCommandStarted(); + } + + private void assertFailureBeforeCommandStarted() throws Exception { + Context caller = Context.current(); + DDSpan span = (DDSpan) tracer.startSpan("java-mongo", MongoDecorator.OPERATION_NAME); + MongoPendingSpan.enter(span); + RuntimeException failure = new RuntimeException("command failed before listener"); + + MongoPendingSpan.onExit(span, failure); + MongoPendingSpan.onExit(span, failure); + assertSame(caller, Context.current()); + assertFalse(Context.isCaptureEnabled()); + assertTrue(span.isFinished()); + assertTrue(span.isError()); + assertEquals(failure.getMessage(), span.getTag(ERROR_MSG)); + assertEquals(failure.getClass().getName(), span.getTag(ERROR_TYPE)); + assertEquals(parent.getSpanId(), span.getParentId()); + assertNull(MongoPendingSpan.take()); + parent.finish(); + writer.waitForTraces(1); + assertEquals(2, writer.get(0).size()); + assertTrue(writer.get(0).contains(span)); + } + + @Test + void completedAdviceDoesNotConsumeASubsequentPendingSpan() { + DDSpan first = (DDSpan) tracer.startSpan("test", "first"); + MongoPendingSpan.enter(first); + assertSame(first, MongoPendingSpan.take()); + DDSpan second = (DDSpan) tracer.startSpan("test", "second"); + MongoPendingSpan.enter(second); + + MongoPendingSpan.onExit(first, new IllegalStateException("first command failed")); + assertSame(second, MongoPendingSpan.take()); + MongoPendingSpan.onExit(second, null); + assertFalse(first.isFinished()); + assertFalse(first.isError()); + assertFalse(second.isFinished()); + first.finish(); + second.finish(); + } + + @Test + void skippedAdviceDoesNotConsumeThePendingSpan() { + DDSpan span = (DDSpan) tracer.startSpan("test", "command"); + MongoPendingSpan.enter(span); + MongoPendingSpan.onExit(null, new IllegalStateException("nested advice failed")); + assertSame(span, MongoPendingSpan.take()); + assertFalse(span.isFinished()); + span.finish(); + } + + @Test + void commandListenerClaimsAndFinishesThePendingSpan() { + assertListenerHandoff(); + } + + @Test + @WithConfig(key = "legacy.context-manager.enabled", value = "true") + void legacyCommandListenerClaimsAndFinishesThePendingSpan() { + assertListenerHandoff(); + } + + private void assertListenerHandoff() { + Context caller = Context.current(); + DDSpan span = (DDSpan) tracer.startSpan("java-mongo", MongoDecorator.OPERATION_NAME); + MongoPendingSpan.enter(span); + MongoCommandListener listener = listener(); + + listener.commandStarted(startedEvent()); + MongoPendingSpan.onExit(span, null); + assertNull(MongoPendingSpan.take()); + assertSame(caller, Context.current()); + assertFalse(Context.isCaptureEnabled()); + assertFalse(span.isFinished()); + + listener.commandSucceeded(succeededEvent()); + assertTrue(span.isFinished()); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void commandListenerWithoutPendingSpanCreatesAChildOfTheCaller(boolean sameOperationName) + throws Exception { + if (sameOperationName) { + parent.setOperationName(MongoDecorator.OPERATION_NAME); + } + MongoCommandListener listener = listener(); + listener.commandStarted(startedEvent()); + assertSame(parent, AgentTracer.activeSpan()); + assertFalse(Context.isCaptureEnabled()); + listener.commandSucceeded(succeededEvent()); + assertFalse(parent.isFinished()); + parent.finish(); + writer.waitForTraces(1); + assertEquals(2, writer.get(0).size()); + assertTrue( + writer.get(0).stream() + .anyMatch(span -> + span.getOperationName().equals(MongoDecorator.OPERATION_NAME) + && span.getParentId() == parent.getSpanId())); + } + + private static MongoCommandListener listener() { + BsonScrubber scrubber = + new BsonScrubber() { + @Override + public void pipe(BsonReader reader) {} + + @Override + public void close() {} + + @Override + public String getResourceName() { + return "{}"; + } + }; + return new MongoCommandListener( + 1, + new MongoDecorator() { + @Override + protected BsonScrubber newScrubber() { + return scrubber; + } + }); + } + + private static CommandStartedEvent startedEvent() { + return new CommandStartedEvent(1, null, "database", "find", new BsonDocument()); + } + + private static CommandSucceededEvent succeededEvent() { + return new CommandSucceededEvent(1, null, "find", new BsonDocument(), 1L); + } +} diff --git a/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.1/src/main/java/datadog/trace/instrumentation/mongo/MongoClient31Instrumentation.java b/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.1/src/main/java/datadog/trace/instrumentation/mongo/MongoClient31Instrumentation.java index 52386319458..de79b511066 100644 --- a/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.1/src/main/java/datadog/trace/instrumentation/mongo/MongoClient31Instrumentation.java +++ b/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.1/src/main/java/datadog/trace/instrumentation/mongo/MongoClient31Instrumentation.java @@ -57,6 +57,7 @@ public String[] helperClassNames() { packageName + ".MongoDecorator", packageName + ".MongoDecorator31", packageName + ".Context", + packageName + ".MongoPendingSpan", packageName + ".MongoCommandListener", packageName + ".MongoCommandListener$SpanEntry" }; diff --git a/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.4/src/main/java/datadog/trace/instrumentation/mongo/MongoClient34Instrumentation.java b/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.4/src/main/java/datadog/trace/instrumentation/mongo/MongoClient34Instrumentation.java index 7a52308bed4..ed2c3325824 100644 --- a/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.4/src/main/java/datadog/trace/instrumentation/mongo/MongoClient34Instrumentation.java +++ b/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.4/src/main/java/datadog/trace/instrumentation/mongo/MongoClient34Instrumentation.java @@ -69,6 +69,7 @@ public String[] helperClassNames() { packageName + ".MongoDecorator", packageName + ".MongoDecorator34", packageName + ".Context", + packageName + ".MongoPendingSpan", packageName + ".MongoCommandListener", packageName + ".MongoCommandListener$SpanEntry" }; diff --git a/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.6/src/main/java/datadog/trace/instrumentation/mongo/DefaultServerConnection36Instrumentation.java b/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.6/src/main/java/datadog/trace/instrumentation/mongo/DefaultServerConnection36Instrumentation.java index c476b425d4d..223e9f1bb7c 100644 --- a/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.6/src/main/java/datadog/trace/instrumentation/mongo/DefaultServerConnection36Instrumentation.java +++ b/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.6/src/main/java/datadog/trace/instrumentation/mongo/DefaultServerConnection36Instrumentation.java @@ -1,7 +1,6 @@ package datadog.trace.instrumentation.mongo; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpanWithoutScope; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.startSpan; import static net.bytebuddy.matcher.ElementMatchers.isMethod; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; @@ -33,6 +32,7 @@ public String instrumentedType() { public String[] helperClassNames() { return new String[] { packageName + ".BsonScrubber", + packageName + ".MongoPendingSpan", packageName + ".MongoCommentInjector", packageName + ".MongoDecorator", }; @@ -60,7 +60,8 @@ public static class CommandAdvice { public static void onEnter( @Advice.This Connection connection, @Advice.Argument(value = 0) String dbName, - @Advice.Argument(value = 1, readOnly = false) BsonDocument originalBsonDocument) { + @Advice.Argument(value = 1, readOnly = false) BsonDocument originalBsonDocument, + @Advice.Local("commandSpan") AgentSpan span) { if (!MongoCommentInjector.INJECT_COMMENT) { return; } @@ -70,9 +71,8 @@ public static void onEnter( return; } - AgentSpan span = startSpan("java-mongo", MongoDecorator.OPERATION_NAME); - // scope is going to be closed by the MongoCommandListener - activateSpanWithoutScope(span); + span = startSpan("java-mongo", MongoDecorator.OPERATION_NAME); + MongoPendingSpan.enter(span); String hostname = null; ConnectionDescription connectionDescription = connection.getDescription(); @@ -87,7 +87,9 @@ public static void onEnter( } @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) - public static void onExit() { + public static void onExit( + @Advice.Local("commandSpan") AgentSpan span, @Advice.Thrown Throwable error) { + MongoPendingSpan.onExit(span, error); if (!MongoCommentInjector.INJECT_COMMENT) { return; } diff --git a/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.6/src/test/groovy/DefaultServerConnection36InstrumentationTest.groovy b/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.6/src/test/groovy/DefaultServerConnection36InstrumentationTest.groovy index 671ca3a791b..52b586951ad 100644 --- a/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.6/src/test/groovy/DefaultServerConnection36InstrumentationTest.groovy +++ b/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.6/src/test/groovy/DefaultServerConnection36InstrumentationTest.groovy @@ -412,3 +412,11 @@ class DefaultServerConnection36InstrumentationDisabledV1ForkedTest extends Defau return V1_DB_TYPE } } + +class ContextSwapDefaultServerConnection36InstrumentationEnabledForkedTest extends DefaultServerConnection36InstrumentationEnabledV0ForkedTest { + @Override + void configurePreAgent() { + super.configurePreAgent() + injectSysConfig("legacy.context-manager.enabled", "false") + } +} diff --git a/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.8/src/main/java/datadog/trace/instrumentation/mongo/DefaultServerConnection38Instrumentation.java b/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.8/src/main/java/datadog/trace/instrumentation/mongo/DefaultServerConnection38Instrumentation.java index cd22d87c42e..4ce06c9bd94 100644 --- a/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.8/src/main/java/datadog/trace/instrumentation/mongo/DefaultServerConnection38Instrumentation.java +++ b/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.8/src/main/java/datadog/trace/instrumentation/mongo/DefaultServerConnection38Instrumentation.java @@ -1,7 +1,6 @@ package datadog.trace.instrumentation.mongo; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpanWithoutScope; import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.startSpan; import static net.bytebuddy.matcher.ElementMatchers.isMethod; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; @@ -35,6 +34,7 @@ public String[] helperClassNames() { packageName + ".MongoDecorator", packageName + ".MongoCommentInjector", packageName + ".BsonScrubber", + packageName + ".MongoPendingSpan", }; } @@ -60,7 +60,8 @@ public static class CommandAdvice { public static void onEnter( @Advice.This DefaultServerConnection connection, @Advice.Argument(value = 0) String dbName, - @Advice.Argument(value = 1, readOnly = false) BsonDocument originalBsonDocument) { + @Advice.Argument(value = 1, readOnly = false) BsonDocument originalBsonDocument, + @Advice.Local("commandSpan") AgentSpan span) { if (!MongoCommentInjector.INJECT_COMMENT) { return; } @@ -70,9 +71,8 @@ public static void onEnter( return; } - AgentSpan span = startSpan("java-mongo", MongoDecorator.OPERATION_NAME); - // scope is going to be closed by the MongoCommandListener - activateSpanWithoutScope(span); + span = startSpan("java-mongo", MongoDecorator.OPERATION_NAME); + MongoPendingSpan.enter(span); String hostname = null; ConnectionDescription connectionDescription = connection.getDescription(); @@ -87,7 +87,9 @@ public static void onEnter( } @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) - public static void onExit() { + public static void onExit( + @Advice.Local("commandSpan") AgentSpan span, @Advice.Thrown Throwable error) { + MongoPendingSpan.onExit(span, error); if (!MongoCommentInjector.INJECT_COMMENT) { return; } diff --git a/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.8/src/test/groovy/DefaultServerConnection38InstrumentationTest.groovy b/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.8/src/test/groovy/DefaultServerConnection38InstrumentationTest.groovy index 58a54d59863..0a12bf5ba38 100644 --- a/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.8/src/test/groovy/DefaultServerConnection38InstrumentationTest.groovy +++ b/dd-java-agent/instrumentation/mongo/mongo-driver/mongo-driver-3/mongo-driver-3.8/src/test/groovy/DefaultServerConnection38InstrumentationTest.groovy @@ -414,3 +414,11 @@ class DefaultServerConnection38InstrumentationDisabledV1ForkedTest extends Defau return V1_DB_TYPE } } + +class ContextSwapDefaultServerConnection38InstrumentationEnabledForkedTest extends DefaultServerConnection38InstrumentationEnabledV0ForkedTest { + @Override + void configurePreAgent() { + super.configurePreAgent() + injectSysConfig("legacy.context-manager.enabled", "false") + } +} diff --git a/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/build.gradle b/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/build.gradle index 8f6f239b6b1..39a089ee480 100644 --- a/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/build.gradle +++ b/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/build.gradle @@ -4,6 +4,8 @@ plugins { } addTestSuiteForDir('latestDepTest', 'test') +addTestSuiteForDir('dbm36Test', 'dbmTest') +addTestSuiteForDir('dbm38Test', 'dbmTest') dependencies { testContainerImage(image('mongo:4.4.29', 'test.mongo.image')) @@ -20,4 +22,19 @@ dependencies { testImplementation group: 'org.mongodb', name: 'mongodb-driver-async', version: '3.3.0' latestDepTestImplementation group: 'org.mongodb', name: 'mongodb-driver-async', version: '+' + + // DBM command advice starts at 3.6; exercise both connection implementation packages. + dbm36TestImplementation 'org.mongodb:mongodb-driver-async:3.6.0' + dbm38TestImplementation 'org.mongodb:mongodb-driver-async:3.8.0' + [configurations.dbm36TestImplementation, configurations.dbm38TestImplementation].each { + add(it.name, project(':dd-java-agent:instrumentation:mongo:mongo-driver:mongo-driver-3:mongo-driver-3.4')) { + transitive = false + } + add(it.name, project(':dd-java-agent:instrumentation:mongo:mongo-driver:mongo-driver-3:mongo-driver-3.6')) { + transitive = false + } + } + dbm38TestImplementation(project(':dd-java-agent:instrumentation:mongo:mongo-driver:mongo-driver-3:mongo-driver-3.8')) { + transitive = false + } } diff --git a/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/gradle.lockfile b/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/gradle.lockfile index 1a5b13e8826..553f73d233e 100644 --- a/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/gradle.lockfile +++ b/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/gradle.lockfile @@ -2,136 +2,142 @@ # Manual edits can break the build and are not advised. # This file is expected to be part of source control. # To regenerate this file, run: ./gradlew :dd-java-agent:instrumentation:mongo:mongo-test:mongo-test-async-3.3:dependencies --write-locks -cafe.cryptography:curve25519-elisabeth:0.1.0=latestDepTestRuntimeClasspath,testRuntimeClasspath -cafe.cryptography:ed25519-elisabeth:0.1.0=latestDepTestRuntimeClasspath,testRuntimeClasspath -ch.qos.logback:logback-classic:1.2.13=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -ch.qos.logback:logback-core:1.2.13=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -com.blogspot.mydailyjava:weak-lock-free:0.17=buildTimeInstrumentationPlugin,compileClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,muzzleTooling,runtimeClasspath,testCompileClasspath,testRuntimeClasspath -com.datadoghq.okhttp3:okhttp:3.12.15=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -com.datadoghq.okio:okio:1.17.6=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -com.datadoghq:dd-instrument-java:0.0.6=buildTimeInstrumentationPlugin,compileClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,muzzleBootstrap,muzzleTooling,runtimeClasspath,testCompileClasspath,testRuntimeClasspath -com.datadoghq:dd-javac-plugin-client:0.2.2=buildTimeInstrumentationPlugin,compileClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,muzzleBootstrap,muzzleTooling,runtimeClasspath,testCompileClasspath,testRuntimeClasspath -com.datadoghq:java-dogstatsd-client:4.4.5=latestDepTestRuntimeClasspath,testRuntimeClasspath -com.datadoghq:sketches-java:0.8.3=latestDepTestRuntimeClasspath,testRuntimeClasspath -com.fasterxml.jackson.core:jackson-annotations:2.10.3=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -com.github.docker-java:docker-java-api:3.4.2=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -com.github.docker-java:docker-java-transport-zerodep:3.4.2=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -com.github.docker-java:docker-java-transport:3.4.2=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +cafe.cryptography:curve25519-elisabeth:0.1.0=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +cafe.cryptography:ed25519-elisabeth:0.1.0=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +ch.qos.logback:logback-classic:1.2.13=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +ch.qos.logback:logback-core:1.2.13=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +com.blogspot.mydailyjava:weak-lock-free:0.17=buildTimeInstrumentationPlugin,compileClasspath,dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,muzzleTooling,runtimeClasspath,testCompileClasspath,testRuntimeClasspath +com.datadoghq.okhttp3:okhttp:3.12.15=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +com.datadoghq.okio:okio:1.17.6=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +com.datadoghq:dd-instrument-java:0.0.6=buildTimeInstrumentationPlugin,compileClasspath,dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,muzzleBootstrap,muzzleTooling,runtimeClasspath,testCompileClasspath,testRuntimeClasspath +com.datadoghq:dd-javac-plugin-client:0.2.2=buildTimeInstrumentationPlugin,compileClasspath,dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,muzzleBootstrap,muzzleTooling,runtimeClasspath,testCompileClasspath,testRuntimeClasspath +com.datadoghq:java-dogstatsd-client:4.4.5=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +com.datadoghq:sketches-java:0.8.3=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +com.fasterxml.jackson.core:jackson-annotations:2.10.3=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +com.github.docker-java:docker-java-api:3.4.2=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +com.github.docker-java:docker-java-transport-zerodep:3.4.2=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +com.github.docker-java:docker-java-transport:3.4.2=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath com.github.javaparser:javaparser-core:3.25.6=codenarc -com.github.jnr:jffi:1.4.7=latestDepTestRuntimeClasspath,testRuntimeClasspath -com.github.jnr:jnr-a64asm:1.0.0=latestDepTestRuntimeClasspath,testRuntimeClasspath -com.github.jnr:jnr-constants:0.11.4=latestDepTestRuntimeClasspath,testRuntimeClasspath -com.github.jnr:jnr-enxio:0.33.6=latestDepTestRuntimeClasspath,testRuntimeClasspath -com.github.jnr:jnr-ffi:2.3.7=latestDepTestRuntimeClasspath,testRuntimeClasspath -com.github.jnr:jnr-posix:3.2.8=latestDepTestRuntimeClasspath,testRuntimeClasspath -com.github.jnr:jnr-unixsocket:0.39.9=latestDepTestRuntimeClasspath,testRuntimeClasspath -com.github.jnr:jnr-x86asm:1.0.2=latestDepTestRuntimeClasspath,testRuntimeClasspath +com.github.jnr:jffi:1.4.7=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +com.github.jnr:jnr-a64asm:1.0.0=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +com.github.jnr:jnr-constants:0.11.4=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +com.github.jnr:jnr-enxio:0.33.6=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +com.github.jnr:jnr-ffi:2.3.7=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +com.github.jnr:jnr-posix:3.2.8=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +com.github.jnr:jnr-unixsocket:0.39.9=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +com.github.jnr:jnr-x86asm:1.0.2=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath com.github.spotbugs:spotbugs-annotations:4.10.4=compileClasspath,spotbugs com.github.spotbugs:spotbugs:4.10.4=spotbugs com.github.stephenc.jcip:jcip-annotations:1.0-1=spotbugs -com.google.auto.service:auto-service-annotations:1.1.1=annotationProcessor,compileClasspath,latestDepTestAnnotationProcessor,latestDepTestCompileClasspath,testAnnotationProcessor,testCompileClasspath -com.google.auto.service:auto-service:1.1.1=annotationProcessor,latestDepTestAnnotationProcessor,testAnnotationProcessor -com.google.auto:auto-common:1.2.1=annotationProcessor,latestDepTestAnnotationProcessor,testAnnotationProcessor -com.google.code.findbugs:jsr305:3.0.2=annotationProcessor,compileClasspath,latestDepTestAnnotationProcessor,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,spotbugs,testAnnotationProcessor,testCompileClasspath,testRuntimeClasspath +com.google.auto.service:auto-service-annotations:1.1.1=annotationProcessor,compileClasspath,dbm36TestAnnotationProcessor,dbm36TestCompileClasspath,dbm38TestAnnotationProcessor,dbm38TestCompileClasspath,latestDepTestAnnotationProcessor,latestDepTestCompileClasspath,testAnnotationProcessor,testCompileClasspath +com.google.auto.service:auto-service:1.1.1=annotationProcessor,dbm36TestAnnotationProcessor,dbm38TestAnnotationProcessor,latestDepTestAnnotationProcessor,testAnnotationProcessor +com.google.auto:auto-common:1.2.1=annotationProcessor,dbm36TestAnnotationProcessor,dbm38TestAnnotationProcessor,latestDepTestAnnotationProcessor,testAnnotationProcessor +com.google.code.findbugs:jsr305:3.0.2=annotationProcessor,compileClasspath,dbm36TestAnnotationProcessor,dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestAnnotationProcessor,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestAnnotationProcessor,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,spotbugs,testAnnotationProcessor,testCompileClasspath,testRuntimeClasspath com.google.code.gson:gson:2.14.0=spotbugs -com.google.errorprone:error_prone_annotations:2.18.0=annotationProcessor,latestDepTestAnnotationProcessor,testAnnotationProcessor -com.google.errorprone:error_prone_annotations:2.47.0=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +com.google.errorprone:error_prone_annotations:2.18.0=annotationProcessor,dbm36TestAnnotationProcessor,dbm38TestAnnotationProcessor,latestDepTestAnnotationProcessor,testAnnotationProcessor +com.google.errorprone:error_prone_annotations:2.47.0=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath com.google.errorprone:error_prone_annotations:2.48.0=spotbugs -com.google.guava:failureaccess:1.0.1=annotationProcessor,latestDepTestAnnotationProcessor,testAnnotationProcessor -com.google.guava:failureaccess:1.0.3=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -com.google.guava:guava:32.0.1-jre=annotationProcessor,latestDepTestAnnotationProcessor,testAnnotationProcessor -com.google.guava:guava:33.6.0-jre=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava=annotationProcessor,latestDepTestAnnotationProcessor,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testAnnotationProcessor,testCompileClasspath,testRuntimeClasspath -com.google.j2objc:j2objc-annotations:2.8=annotationProcessor,latestDepTestAnnotationProcessor,testAnnotationProcessor -com.google.j2objc:j2objc-annotations:3.1=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -com.google.re2j:re2j:1.8=latestDepTestRuntimeClasspath,testRuntimeClasspath -com.squareup.moshi:moshi:1.11.0=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -com.squareup.okhttp3:logging-interceptor:3.12.12=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -com.squareup.okhttp3:okhttp:3.12.12=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -com.squareup.okio:okio:1.17.5=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +com.google.guava:failureaccess:1.0.1=annotationProcessor,dbm36TestAnnotationProcessor,dbm38TestAnnotationProcessor,latestDepTestAnnotationProcessor,testAnnotationProcessor +com.google.guava:failureaccess:1.0.3=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +com.google.guava:guava:32.0.1-jre=annotationProcessor,dbm36TestAnnotationProcessor,dbm38TestAnnotationProcessor,latestDepTestAnnotationProcessor,testAnnotationProcessor +com.google.guava:guava:33.6.0-jre=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava=annotationProcessor,dbm36TestAnnotationProcessor,dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestAnnotationProcessor,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestAnnotationProcessor,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testAnnotationProcessor,testCompileClasspath,testRuntimeClasspath +com.google.j2objc:j2objc-annotations:2.8=annotationProcessor,dbm36TestAnnotationProcessor,dbm38TestAnnotationProcessor,latestDepTestAnnotationProcessor,testAnnotationProcessor +com.google.j2objc:j2objc-annotations:3.1=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +com.google.re2j:re2j:1.8=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +com.squareup.moshi:moshi:1.11.0=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +com.squareup.okhttp3:logging-interceptor:3.12.12=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +com.squareup.okhttp3:okhttp:3.12.12=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +com.squareup.okio:okio:1.17.5=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath com.thoughtworks.qdox:qdox:1.12.1=codenarc -commons-fileupload:commons-fileupload:1.5=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -commons-io:commons-io:2.11.0=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +commons-fileupload:commons-fileupload:1.5=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +commons-io:commons-io:2.11.0=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath commons-io:commons-io:2.21.0=spotbugs -de.thetaphi:forbiddenapis:3.11=compileClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -io.leangen.geantyref:geantyref:1.3.16=latestDepTestRuntimeClasspath,testRuntimeClasspath -io.sqreen:libsqreen:17.7.0=latestDepTestRuntimeClasspath,testRuntimeClasspath -javax.servlet:javax.servlet-api:3.1.0=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +de.thetaphi:forbiddenapis:3.11=compileClasspath,dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +io.leangen.geantyref:geantyref:1.3.16=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +io.sqreen:libsqreen:17.7.0=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +javax.servlet:javax.servlet-api:3.1.0=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath jaxen:jaxen:2.0.6=spotbugs -junit:junit:4.13.2=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -net.bytebuddy:byte-buddy-agent:1.18.12=buildTimeInstrumentationPlugin,compileClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,muzzleTooling,runtimeClasspath,testCompileClasspath,testRuntimeClasspath -net.bytebuddy:byte-buddy:1.18.12=buildTimeInstrumentationPlugin,compileClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,muzzleTooling,runtimeClasspath,testCompileClasspath,testRuntimeClasspath -net.java.dev.jna:jna:5.13.0=latestDepTestCompileClasspath,testCompileClasspath -net.java.dev.jna:jna:5.19.1=latestDepTestRuntimeClasspath,testRuntimeClasspath +junit:junit:4.13.2=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +net.bytebuddy:byte-buddy-agent:1.18.12=buildTimeInstrumentationPlugin,compileClasspath,dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,muzzleTooling,runtimeClasspath,testCompileClasspath,testRuntimeClasspath +net.bytebuddy:byte-buddy:1.18.12=buildTimeInstrumentationPlugin,compileClasspath,dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,muzzleTooling,runtimeClasspath,testCompileClasspath,testRuntimeClasspath +net.java.dev.jna:jna:5.13.0=dbm36TestCompileClasspath,dbm38TestCompileClasspath,latestDepTestCompileClasspath,testCompileClasspath +net.java.dev.jna:jna:5.19.1=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath net.sf.saxon:Saxon-HE:12.10=spotbugs org.apache.ant:ant-antlr:1.10.14=codenarc org.apache.ant:ant-junit:1.10.14=codenarc org.apache.bcel:bcel:6.12.0=spotbugs -org.apache.commons:commons-compress:1.24.0=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.apache.commons:commons-compress:1.24.0=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath org.apache.commons:commons-lang3:3.20.0=spotbugs org.apache.commons:commons-text:1.15.0=spotbugs org.apache.logging.log4j:log4j-api:2.26.1=spotbugs org.apache.logging.log4j:log4j-core:2.26.1=spotbugs -org.apiguardian:apiguardian-api:1.1.2=latestDepTestCompileClasspath,testCompileClasspath -org.checkerframework:checker-qual:3.33.0=annotationProcessor,latestDepTestAnnotationProcessor,testAnnotationProcessor +org.apiguardian:apiguardian-api:1.1.2=dbm36TestCompileClasspath,dbm38TestCompileClasspath,latestDepTestCompileClasspath,testCompileClasspath +org.checkerframework:checker-qual:3.33.0=annotationProcessor,dbm36TestAnnotationProcessor,dbm38TestAnnotationProcessor,latestDepTestAnnotationProcessor,testAnnotationProcessor org.codehaus.groovy:groovy-ant:3.0.23=codenarc org.codehaus.groovy:groovy-docgenerator:3.0.23=codenarc org.codehaus.groovy:groovy-groovydoc:3.0.23=codenarc org.codehaus.groovy:groovy-json:3.0.23=codenarc -org.codehaus.groovy:groovy-json:3.0.25=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.codehaus.groovy:groovy-json:3.0.25=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath org.codehaus.groovy:groovy-templates:3.0.23=codenarc org.codehaus.groovy:groovy-xml:3.0.23=codenarc org.codehaus.groovy:groovy:3.0.23=codenarc -org.codehaus.groovy:groovy:3.0.25=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.codehaus.groovy:groovy:3.0.25=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath org.codenarc:CodeNarc:3.7.0=codenarc org.dom4j:dom4j:2.2.0=spotbugs org.gmetrics:GMetrics:2.1.0=codenarc -org.hamcrest:hamcrest-core:1.3=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.hamcrest:hamcrest:3.0=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.jctools:jctools-core-jdk11:4.0.6=latestDepTestRuntimeClasspath,testRuntimeClasspath -org.jctools:jctools-core:4.0.6=latestDepTestRuntimeClasspath,testRuntimeClasspath -org.jetbrains:annotations:17.0.0=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.jspecify:jspecify:1.0.0=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.junit.jupiter:junit-jupiter-api:5.14.1=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.junit.jupiter:junit-jupiter-engine:5.14.1=latestDepTestRuntimeClasspath,testRuntimeClasspath -org.junit.jupiter:junit-jupiter-params:5.14.1=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.junit.jupiter:junit-jupiter:5.14.1=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.junit.platform:junit-platform-commons:1.14.1=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.junit.platform:junit-platform-engine:1.14.1=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.junit.platform:junit-platform-launcher:1.14.1=latestDepTestRuntimeClasspath,testRuntimeClasspath -org.junit.platform:junit-platform-runner:1.14.1=latestDepTestRuntimeClasspath,testRuntimeClasspath -org.junit.platform:junit-platform-suite-api:1.14.1=latestDepTestRuntimeClasspath,testRuntimeClasspath -org.junit.platform:junit-platform-suite-commons:1.14.1=latestDepTestRuntimeClasspath,testRuntimeClasspath -org.junit:junit-bom:5.14.1=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.mockito:mockito-core:4.4.0=latestDepTestRuntimeClasspath,testRuntimeClasspath +org.hamcrest:hamcrest-core:1.3=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.hamcrest:hamcrest:3.0=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.jctools:jctools-core-jdk11:4.0.6=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +org.jctools:jctools-core:4.0.6=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +org.jetbrains:annotations:17.0.0=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.jspecify:jspecify:1.0.0=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.junit.jupiter:junit-jupiter-api:5.14.1=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.junit.jupiter:junit-jupiter-engine:5.14.1=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +org.junit.jupiter:junit-jupiter-params:5.14.1=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.junit.jupiter:junit-jupiter:5.14.1=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.junit.platform:junit-platform-commons:1.14.1=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.junit.platform:junit-platform-engine:1.14.1=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.junit.platform:junit-platform-launcher:1.14.1=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +org.junit.platform:junit-platform-runner:1.14.1=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +org.junit.platform:junit-platform-suite-api:1.14.1=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +org.junit.platform:junit-platform-suite-commons:1.14.1=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath +org.junit:junit-bom:5.14.1=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.mockito:mockito-core:4.4.0=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,testRuntimeClasspath org.mongodb:bson:3.12.14=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath org.mongodb:bson:3.3.0=testCompileClasspath,testRuntimeClasspath +org.mongodb:bson:3.6.0=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath +org.mongodb:bson:3.8.0=dbm38TestCompileClasspath,dbm38TestRuntimeClasspath org.mongodb:mongodb-driver-async:3.12.14=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath org.mongodb:mongodb-driver-async:3.3.0=testCompileClasspath,testRuntimeClasspath +org.mongodb:mongodb-driver-async:3.6.0=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath +org.mongodb:mongodb-driver-async:3.8.0=dbm38TestCompileClasspath,dbm38TestRuntimeClasspath org.mongodb:mongodb-driver-core:3.12.14=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath org.mongodb:mongodb-driver-core:3.3.0=testCompileClasspath,testRuntimeClasspath -org.objenesis:objenesis:3.3=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.opentest4j:opentest4j:1.3.0=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.ow2.asm:asm-analysis:9.10.1=latestDepTestRuntimeClasspath,spotbugs,testRuntimeClasspath -org.ow2.asm:asm-commons:9.10.1=latestDepTestRuntimeClasspath,spotbugs,testRuntimeClasspath -org.ow2.asm:asm-tree:9.10.1=latestDepTestRuntimeClasspath,spotbugs,testRuntimeClasspath -org.ow2.asm:asm-util:9.10.1=latestDepTestRuntimeClasspath,spotbugs,testRuntimeClasspath -org.ow2.asm:asm:9.10.1=buildTimeInstrumentationPlugin,compileClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,muzzleTooling,runtimeClasspath,spotbugs,testCompileClasspath,testRuntimeClasspath -org.rnorth.duct-tape:duct-tape:1.0.8=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.slf4j:jcl-over-slf4j:1.7.30=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.slf4j:jul-to-slf4j:1.7.30=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.slf4j:log4j-over-slf4j:1.7.30=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.mongodb:mongodb-driver-core:3.6.0=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath +org.mongodb:mongodb-driver-core:3.8.0=dbm38TestCompileClasspath,dbm38TestRuntimeClasspath +org.objenesis:objenesis:3.3=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.opentest4j:opentest4j:1.3.0=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.ow2.asm:asm-analysis:9.10.1=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,spotbugs,testRuntimeClasspath +org.ow2.asm:asm-commons:9.10.1=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,spotbugs,testRuntimeClasspath +org.ow2.asm:asm-tree:9.10.1=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,spotbugs,testRuntimeClasspath +org.ow2.asm:asm-util:9.10.1=dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,spotbugs,testRuntimeClasspath +org.ow2.asm:asm:9.10.1=buildTimeInstrumentationPlugin,compileClasspath,dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,muzzleTooling,runtimeClasspath,spotbugs,testCompileClasspath,testRuntimeClasspath +org.rnorth.duct-tape:duct-tape:1.0.8=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.slf4j:jcl-over-slf4j:1.7.30=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.slf4j:jul-to-slf4j:1.7.30=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.slf4j:log4j-over-slf4j:1.7.30=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath org.slf4j:slf4j-api:1.7.30=buildTimeInstrumentationPlugin,compileClasspath,muzzleBootstrap,muzzleTooling,runtimeClasspath -org.slf4j:slf4j-api:1.7.36=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.slf4j:slf4j-api:1.7.36=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath org.slf4j:slf4j-api:2.0.17=spotbugsSlf4j org.slf4j:slf4j-api:2.0.18=spotbugs org.slf4j:slf4j-simple:2.0.17=spotbugsSlf4j -org.snakeyaml:snakeyaml-engine:2.9=buildTimeInstrumentationPlugin,latestDepTestRuntimeClasspath,muzzleTooling,runtimeClasspath,testRuntimeClasspath -org.spockframework:spock-bom:2.4-groovy-3.0=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.spockframework:spock-core:2.4-groovy-3.0=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.tabletest:tabletest-junit:1.2.2=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.tabletest:tabletest-parser:1.2.1=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.testcontainers:mongodb:1.21.4=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath -org.testcontainers:testcontainers:1.21.4=latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.snakeyaml:snakeyaml-engine:2.9=buildTimeInstrumentationPlugin,dbm36TestRuntimeClasspath,dbm38TestRuntimeClasspath,latestDepTestRuntimeClasspath,muzzleTooling,runtimeClasspath,testRuntimeClasspath +org.spockframework:spock-bom:2.4-groovy-3.0=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.spockframework:spock-core:2.4-groovy-3.0=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.tabletest:tabletest-junit:1.2.2=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.tabletest:tabletest-parser:1.2.1=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.testcontainers:mongodb:1.21.4=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath +org.testcontainers:testcontainers:1.21.4=dbm36TestCompileClasspath,dbm36TestRuntimeClasspath,dbm38TestCompileClasspath,dbm38TestRuntimeClasspath,latestDepTestCompileClasspath,latestDepTestRuntimeClasspath,testCompileClasspath,testRuntimeClasspath org.xmlresolver:xmlresolver:5.3.3=spotbugs empty=spotbugsPlugins diff --git a/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/src/dbmTest/java/datadog/trace/instrumentation/mongo/AsyncMongoDbmTest.java b/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/src/dbmTest/java/datadog/trace/instrumentation/mongo/AsyncMongoDbmTest.java new file mode 100644 index 00000000000..fb3f93f675a --- /dev/null +++ b/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/src/dbmTest/java/datadog/trace/instrumentation/mongo/AsyncMongoDbmTest.java @@ -0,0 +1,169 @@ +package datadog.trace.instrumentation.mongo; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.mongodb.ConnectionString; +import com.mongodb.async.SingleResultCallback; +import com.mongodb.async.client.MongoClient; +import com.mongodb.async.client.MongoClientSettings; +import com.mongodb.async.client.MongoClients; +import com.mongodb.async.client.MongoDatabase; +import com.mongodb.connection.ClusterSettings; +import com.mongodb.event.CommandFailedEvent; +import com.mongodb.event.CommandListener; +import com.mongodb.event.CommandStartedEvent; +import com.mongodb.event.CommandSucceededEvent; +import datadog.context.ContextScope; +import datadog.trace.agent.test.AbstractInstrumentationTest; +import datadog.trace.api.propagation.W3CTraceParent; +import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.core.DDSpan; +import java.util.List; +import java.util.UUID; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; +import java.util.stream.Collectors; +import org.bson.BsonDocument; +import org.bson.BsonInt32; +import org.bson.BsonString; +import org.bson.Document; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.testcontainers.containers.MongoDBContainer; +import org.testcontainers.utility.DockerImageName; + +abstract class AsyncMongoDbmTest extends AbstractInstrumentationTest { + private static MongoDBContainer mongo; + + @BeforeAll + static void startMongo() { + mongo = + new MongoDBContainer( + DockerImageName.parse(System.getProperty("test.mongo.image")) + .asCompatibleSubstituteFor("mongo")); + mongo.start(); + } + + @AfterAll + static void stopMongo() { + if (mongo != null) { + mongo.stop(); + } + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void asyncCommandRetainsCorrelationAndListenerParenting(boolean warmConnection) throws Exception { + String marker = UUID.randomUUID().toString(); + AtomicReference commandComment = new AtomicReference<>(); + AtomicReference listenerWork = new AtomicReference<>(); + AtomicReference listenerCaller = new AtomicReference<>(); + AtomicReference listenerFailure = new AtomicReference<>(); + CommandListener observer = + new CommandListener() { + @Override + public void commandStarted(CommandStartedEvent event) { + if (!"ping".equals(event.getCommandName())) { + return; + } + if (!event.getCommand().containsKey("comment")) { + return; + } + String comment = event.getCommand().getString("comment").getValue(); + if (!comment.startsWith(marker)) { + return; + } + commandComment.set(comment); + try { + AgentSpan caller = AgentTracer.activeSpan(); + listenerCaller.set(caller); + AgentSpan work = tracer.startSpan("test", "command-listener"); + listenerWork.set(work); + try (ContextScope ignored = tracer.activateSpan(work)) { + assertSame(work, AgentTracer.activeSpan()); + } finally { + work.finish(); + } + } catch (Throwable error) { + // The driver catches listener exceptions; bring assertion failures back to the test. + listenerFailure.set(error); + } + } + + @Override + public void commandSucceeded(CommandSucceededEvent event) {} + + @Override + public void commandFailed(CommandFailedEvent event) {} + }; + MongoClientSettings settings = + MongoClientSettings.builder() + .clusterSettings( + ClusterSettings.builder() + .applyConnectionString(new ConnectionString(mongo.getReplicaSetUrl())) + .build()) + .addCommandListener(observer) + .build(); + try (MongoClient client = MongoClients.create(settings)) { + MongoDatabase database = client.getDatabase("database"); + if (warmConnection) { + CompletableFuture warmed = new CompletableFuture<>(); + database.runCommand(new BsonDocument("ping", new BsonInt32(1)), callback(warmed)); + warmed.get(20, TimeUnit.SECONDS); + tracer.flush(); + writer.start(); + } + AgentSpan parent = tracer.startSpan("test", "caller"); + try (ContextScope ignored = tracer.activateSpan(parent)) { + CompletableFuture completed = new CompletableFuture<>(); + database.runCommand( + new BsonDocument("ping", new BsonInt32(1)).append("comment", new BsonString(marker)), + callback(completed)); + assertNotNull(completed.get(20, TimeUnit.SECONDS)); + assertSame(parent, AgentTracer.activeSpan()); + } finally { + parent.finish(); + } + assertNull(listenerFailure.get()); + blockUntilTracesMatch(traces -> traces.stream().mapToInt(List::size).sum() >= 3); + List spans = writer.stream().flatMap(List::stream).collect(Collectors.toList()); + List commands = + spans.stream() + .filter(span -> "java-mongo".equals(span.getTag("component"))) + .collect(Collectors.toList()); + assertEquals( + 1, commands.size(), "The pending span must be claimed, not finished and replaced"); + DDSpan command = commands.get(0); + assertTrue(command.isFinished()); + assertFalse(command.isError()); + assertNotNull(commandComment.get()); + assertTrue( + commandComment.get().contains("traceparent='" + W3CTraceParent.from(command) + "'")); + DDSpan work = (DDSpan) listenerWork.get(); + assertNotNull(work); + assertNotEquals(command.getSpanId(), work.getParentId()); + AgentSpan caller = listenerCaller.get(); + assertEquals(caller == null ? 0 : caller.getSpanId(), work.getParentId()); + } + } + + private static SingleResultCallback callback(CompletableFuture result) { + return (value, error) -> { + if (error != null) { + result.completeExceptionally(error); + } else { + result.complete(value); + } + }; + } +} diff --git a/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/src/dbmTest/java/datadog/trace/instrumentation/mongo/ContextSwapAsyncMongoDbmForkedTest.java b/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/src/dbmTest/java/datadog/trace/instrumentation/mongo/ContextSwapAsyncMongoDbmForkedTest.java new file mode 100644 index 00000000000..923beda9fd6 --- /dev/null +++ b/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/src/dbmTest/java/datadog/trace/instrumentation/mongo/ContextSwapAsyncMongoDbmForkedTest.java @@ -0,0 +1,7 @@ +package datadog.trace.instrumentation.mongo; + +import datadog.trace.test.junit.utils.config.WithConfig; + +@WithConfig(key = "legacy.context-manager.enabled", value = "false") +@WithConfig(key = "dbm.propagation.mode", value = "full") +class ContextSwapAsyncMongoDbmForkedTest extends AsyncMongoDbmTest {} diff --git a/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/src/dbmTest/java/datadog/trace/instrumentation/mongo/LegacyAsyncMongoDbmForkedTest.java b/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/src/dbmTest/java/datadog/trace/instrumentation/mongo/LegacyAsyncMongoDbmForkedTest.java new file mode 100644 index 00000000000..f6bf4cc27ef --- /dev/null +++ b/dd-java-agent/instrumentation/mongo/mongo-test/mongo-test-async-3.3/src/dbmTest/java/datadog/trace/instrumentation/mongo/LegacyAsyncMongoDbmForkedTest.java @@ -0,0 +1,7 @@ +package datadog.trace.instrumentation.mongo; + +import datadog.trace.test.junit.utils.config.WithConfig; + +@WithConfig(key = "legacy.context-manager.enabled", value = "true") +@WithConfig(key = "dbm.propagation.mode", value = "full") +class LegacyAsyncMongoDbmForkedTest extends AsyncMongoDbmTest {} diff --git a/dd-java-agent/instrumentation/opentracing/opentracing-0.31/src/main/java/datadog/trace/instrumentation/opentracing31/OTScopeManager.java b/dd-java-agent/instrumentation/opentracing/opentracing-0.31/src/main/java/datadog/trace/instrumentation/opentracing31/OTScopeManager.java index 0faa346dda4..af580c46487 100644 --- a/dd-java-agent/instrumentation/opentracing/opentracing-0.31/src/main/java/datadog/trace/instrumentation/opentracing31/OTScopeManager.java +++ b/dd-java-agent/instrumentation/opentracing/opentracing-0.31/src/main/java/datadog/trace/instrumentation/opentracing31/OTScopeManager.java @@ -3,18 +3,22 @@ import datadog.context.Context; import datadog.context.ContextScope; import datadog.trace.api.Config; +import datadog.trace.api.InstrumenterConfig; import datadog.trace.bootstrap.instrumentation.api.AgentSpan; import datadog.trace.bootstrap.instrumentation.api.AgentTracer; import datadog.trace.context.TraceScope; import io.opentracing.Scope; import io.opentracing.ScopeManager; import io.opentracing.Span; +import java.util.concurrent.atomic.AtomicBoolean; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class OTScopeManager implements ScopeManager { static final Logger log = LoggerFactory.getLogger(OTScopeManager.class); + private static final AtomicBoolean UNSUPPORTED_CLOSE_LOGGED = new AtomicBoolean(); + private final TypeConverter converter; private final AgentTracer.TracerAPI tracer; @@ -35,6 +39,10 @@ public Scope activate(final Span span, final boolean finishSpanOnClose) { return converter.toScope(agentScope, finishSpanOnClose); } + /** + * Returns a view of the active span. With the non-legacy context manager, closing this view does + * nothing; close the scope returned by {@code activate} to restore the previous context. + */ @Deprecated @Override public Scope active() { @@ -94,7 +102,13 @@ public Context context() { @Override public void close() { if (agentSpan == tracer.activeSpan()) { - tracer.closeActive(); + if (InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + tracer.closeActive(); + } else if (UNSUPPORTED_CLOSE_LOGGED.compareAndSet(false, true)) { + log.warn( + "ScopeManager.active().close() has no effect; " + + "close the Scope returned by activate() instead"); + } } else if (Config.get().isScopeStrictMode()) { throw new RuntimeException("Tried to close " + agentSpan + " scope when not on top"); } else { diff --git a/dd-java-agent/instrumentation/opentracing/opentracing-0.31/src/test/java/datadog/trace/instrumentation/opentracing31/ScopeManagerCloseTest.java b/dd-java-agent/instrumentation/opentracing/opentracing-0.31/src/test/java/datadog/trace/instrumentation/opentracing31/ScopeManagerCloseTest.java new file mode 100644 index 00000000000..7119378eed6 --- /dev/null +++ b/dd-java-agent/instrumentation/opentracing/opentracing-0.31/src/test/java/datadog/trace/instrumentation/opentracing31/ScopeManagerCloseTest.java @@ -0,0 +1,88 @@ +package datadog.trace.instrumentation.opentracing31; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import datadog.context.Context; +import datadog.context.ContextHandle; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.common.writer.ListWriter; +import datadog.trace.core.CoreTracer; +import datadog.trace.core.DDSpan; +import datadog.trace.instrumentation.opentracing.DefaultLogHandler; +import datadog.trace.test.junit.utils.config.WithConfig; +import datadog.trace.test.util.DDJavaSpecification; +import io.opentracing.Scope; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class ScopeManagerCloseTest extends DDJavaSpecification { + private CoreTracer tracer; + private AgentTracer.TracerAPI previousTracer; + private ContextHandle previousContext; + private DDSpan parent; + private DDSpan child; + private OTScopeManager manager; + private TypeConverter converter; + + @BeforeEach + void setUpContext() { + previousTracer = AgentTracer.get(); + tracer = CoreTracer.builder().writer(new ListWriter()).build(); + AgentTracer.forceRegister(tracer); + AgentTracer.installLegacyContextManager(); + previousContext = Context.current().checkpoint(); + parent = (DDSpan) tracer.startSpan("test", "parent"); + parent.swap(); + Context.setCaptureEnabled(false); + child = (DDSpan) tracer.startSpan("test", "child"); + converter = new TypeConverter(new DefaultLogHandler()); + manager = new OTScopeManager(tracer, converter); + } + + @AfterEach + void restoreContext() { + previousContext.swap(); + child.finish(); + parent.finish(); + tracer.close(); + AgentTracer.forceRegister(previousTracer); + } + + @Test + @WithConfig(key = "legacy.context-manager.enabled", value = "false") + void activeViewLeavesContextIntactAndRetainedScopeRestoresIt() { + Scope scope = manager.activate(converter.toSpan(child), true); + try { + Context.setCaptureEnabled(false); + manager.active().close(); + manager.active().close(); + assertSame(child, tracer.activeSpan()); + assertFalse(Context.isCaptureEnabled()); + assertFalse(child.isFinished()); + } finally { + scope.close(); + } + assertSame(parent, tracer.activeSpan()); + assertFalse(Context.isCaptureEnabled()); + assertTrue(child.isFinished()); + } + + @Test + @WithConfig(key = "legacy.context-manager.enabled", value = "true") + void legacyActiveViewClosesTheCurrentScopeWithoutFinishingTheSpan() { + Scope scope = manager.activate(converter.toSpan(child), true); + try { + manager.active().close(); + assertSame(parent, tracer.activeSpan()); + assertFalse(Context.isCaptureEnabled()); + assertFalse(child.isFinished()); + } finally { + scope.close(); + } + assertSame(parent, tracer.activeSpan()); + assertTrue(child.isFinished()); + } +} diff --git a/dd-java-agent/instrumentation/opentracing/opentracing-0.32/src/main/java/datadog/trace/instrumentation/opentracing32/OTScopeManager.java b/dd-java-agent/instrumentation/opentracing/opentracing-0.32/src/main/java/datadog/trace/instrumentation/opentracing32/OTScopeManager.java index 5591ac985cb..02fdc3e0711 100644 --- a/dd-java-agent/instrumentation/opentracing/opentracing-0.32/src/main/java/datadog/trace/instrumentation/opentracing32/OTScopeManager.java +++ b/dd-java-agent/instrumentation/opentracing/opentracing-0.32/src/main/java/datadog/trace/instrumentation/opentracing32/OTScopeManager.java @@ -3,18 +3,22 @@ import datadog.context.Context; import datadog.context.ContextScope; import datadog.trace.api.Config; +import datadog.trace.api.InstrumenterConfig; import datadog.trace.bootstrap.instrumentation.api.AgentSpan; import datadog.trace.bootstrap.instrumentation.api.AgentTracer; import datadog.trace.context.TraceScope; import io.opentracing.Scope; import io.opentracing.ScopeManager; import io.opentracing.Span; +import java.util.concurrent.atomic.AtomicBoolean; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class OTScopeManager implements ScopeManager { static final Logger log = LoggerFactory.getLogger(OTScopeManager.class); + private static final AtomicBoolean UNSUPPORTED_CLOSE_LOGGED = new AtomicBoolean(); + private final TypeConverter converter; private final AgentTracer.TracerAPI tracer; @@ -40,6 +44,10 @@ public Scope activate(final Span span, final boolean finishSpanOnClose) { return converter.toScope(agentScope, finishSpanOnClose); } + /** + * Returns a view of the active span. With the non-legacy context manager, closing this view does + * nothing; close the scope returned by {@code activate} to restore the previous context. + */ @Deprecated @Override public Scope active() { @@ -104,7 +112,13 @@ public Context context() { @Override public void close() { if (agentSpan == tracer.activeSpan()) { - tracer.closeActive(); + if (InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + tracer.closeActive(); + } else if (UNSUPPORTED_CLOSE_LOGGED.compareAndSet(false, true)) { + log.warn( + "ScopeManager.active().close() has no effect; " + + "close the Scope returned by activate() instead"); + } } else if (Config.get().isScopeStrictMode()) { throw new RuntimeException("Tried to close " + agentSpan + " scope when not on top"); } else { diff --git a/dd-java-agent/instrumentation/opentracing/opentracing-0.32/src/test/java/datadog/trace/instrumentation/opentracing32/ScopeManagerCloseTest.java b/dd-java-agent/instrumentation/opentracing/opentracing-0.32/src/test/java/datadog/trace/instrumentation/opentracing32/ScopeManagerCloseTest.java new file mode 100644 index 00000000000..a58b76ce8c7 --- /dev/null +++ b/dd-java-agent/instrumentation/opentracing/opentracing-0.32/src/test/java/datadog/trace/instrumentation/opentracing32/ScopeManagerCloseTest.java @@ -0,0 +1,88 @@ +package datadog.trace.instrumentation.opentracing32; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import datadog.context.Context; +import datadog.context.ContextHandle; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.common.writer.ListWriter; +import datadog.trace.core.CoreTracer; +import datadog.trace.core.DDSpan; +import datadog.trace.instrumentation.opentracing.DefaultLogHandler; +import datadog.trace.test.junit.utils.config.WithConfig; +import datadog.trace.test.util.DDJavaSpecification; +import io.opentracing.Scope; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class ScopeManagerCloseTest extends DDJavaSpecification { + private CoreTracer tracer; + private AgentTracer.TracerAPI previousTracer; + private ContextHandle previousContext; + private DDSpan parent; + private DDSpan child; + private OTScopeManager manager; + private TypeConverter converter; + + @BeforeEach + void setUpContext() { + previousTracer = AgentTracer.get(); + tracer = CoreTracer.builder().writer(new ListWriter()).build(); + AgentTracer.forceRegister(tracer); + AgentTracer.installLegacyContextManager(); + previousContext = Context.current().checkpoint(); + parent = (DDSpan) tracer.startSpan("test", "parent"); + parent.swap(); + Context.setCaptureEnabled(false); + child = (DDSpan) tracer.startSpan("test", "child"); + converter = new TypeConverter(new DefaultLogHandler()); + manager = new OTScopeManager(tracer, converter); + } + + @AfterEach + void restoreContext() { + previousContext.swap(); + child.finish(); + parent.finish(); + tracer.close(); + AgentTracer.forceRegister(previousTracer); + } + + @Test + @WithConfig(key = "legacy.context-manager.enabled", value = "false") + void activeViewLeavesContextIntactAndRetainedScopeRestoresIt() { + Scope scope = manager.activate(converter.toSpan(child), true); + try { + Context.setCaptureEnabled(false); + manager.active().close(); + manager.active().close(); + assertSame(child, tracer.activeSpan()); + assertFalse(Context.isCaptureEnabled()); + assertFalse(child.isFinished()); + } finally { + scope.close(); + } + assertSame(parent, tracer.activeSpan()); + assertFalse(Context.isCaptureEnabled()); + assertTrue(child.isFinished()); + } + + @Test + @WithConfig(key = "legacy.context-manager.enabled", value = "true") + void legacyActiveViewClosesTheCurrentScopeWithoutFinishingTheSpan() { + Scope scope = manager.activate(converter.toSpan(child), true); + try { + manager.active().close(); + assertSame(parent, tracer.activeSpan()); + assertFalse(Context.isCaptureEnabled()); + assertFalse(child.isFinished()); + } finally { + scope.close(); + } + assertSame(parent, tracer.activeSpan()); + assertTrue(child.isFinished()); + } +} diff --git a/dd-trace-ot/src/main/java/datadog/opentracing/OTScopeManager.java b/dd-trace-ot/src/main/java/datadog/opentracing/OTScopeManager.java index 0aba3ac4c42..638921b0053 100644 --- a/dd-trace-ot/src/main/java/datadog/opentracing/OTScopeManager.java +++ b/dd-trace-ot/src/main/java/datadog/opentracing/OTScopeManager.java @@ -3,12 +3,14 @@ import datadog.context.Context; import datadog.context.ContextScope; import datadog.trace.api.Config; +import datadog.trace.api.InstrumenterConfig; import datadog.trace.bootstrap.instrumentation.api.AgentSpan; import datadog.trace.bootstrap.instrumentation.api.AgentTracer; import datadog.trace.context.TraceScope; import io.opentracing.Scope; import io.opentracing.ScopeManager; import io.opentracing.Span; +import java.util.concurrent.atomic.AtomicBoolean; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -16,6 +18,8 @@ class OTScopeManager implements ScopeManager { static final Logger log = LoggerFactory.getLogger(OTScopeManager.class); + private static final AtomicBoolean UNSUPPORTED_CLOSE_LOGGED = new AtomicBoolean(); + private final TypeConverter converter; private final AgentTracer.TracerAPI tracer; @@ -41,6 +45,10 @@ public Scope activate(final Span span, final boolean finishSpanOnClose) { return converter.toScope(agentScope, finishSpanOnClose); } + /** + * Returns a view of the active span. With the non-legacy context manager, closing this view does + * nothing; close the scope returned by {@code activate} to restore the previous context. + */ @Deprecated @Override public Scope active() { @@ -122,7 +130,13 @@ public Context context() { @Override public void close() { if (agentSpan == tracer.activeSpan()) { - tracer.closeActive(); + if (InstrumenterConfig.get().isLegacyContextManagerEnabled()) { + tracer.closeActive(); + } else if (UNSUPPORTED_CLOSE_LOGGED.compareAndSet(false, true)) { + log.warn( + "ScopeManager.active().close() has no effect; " + + "close the Scope returned by activate() instead"); + } } else if (Config.get().isScopeStrictMode()) { throw new RuntimeException("Tried to close " + agentSpan + " scope when not on top"); } else { diff --git a/dd-trace-ot/src/test/java/datadog/opentracing/ScopeManagerCloseTest.java b/dd-trace-ot/src/test/java/datadog/opentracing/ScopeManagerCloseTest.java new file mode 100644 index 00000000000..a7e6f5d9b8e --- /dev/null +++ b/dd-trace-ot/src/test/java/datadog/opentracing/ScopeManagerCloseTest.java @@ -0,0 +1,87 @@ +package datadog.opentracing; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import datadog.context.Context; +import datadog.context.ContextHandle; +import datadog.trace.bootstrap.instrumentation.api.AgentTracer; +import datadog.trace.common.writer.ListWriter; +import datadog.trace.core.CoreTracer; +import datadog.trace.core.DDSpan; +import datadog.trace.test.junit.utils.config.WithConfig; +import datadog.trace.test.util.DDJavaSpecification; +import io.opentracing.Scope; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class ScopeManagerCloseTest extends DDJavaSpecification { + private CoreTracer tracer; + private AgentTracer.TracerAPI previousTracer; + private ContextHandle previousContext; + private DDSpan parent; + private DDSpan child; + private OTScopeManager manager; + private TypeConverter converter; + + @BeforeEach + void setUpContext() { + previousTracer = AgentTracer.get(); + tracer = CoreTracer.builder().writer(new ListWriter()).build(); + AgentTracer.forceRegister(tracer); + AgentTracer.installLegacyContextManager(); + previousContext = Context.current().checkpoint(); + parent = (DDSpan) tracer.startSpan("test", "parent"); + parent.swap(); + Context.setCaptureEnabled(false); + child = (DDSpan) tracer.startSpan("test", "child"); + converter = new TypeConverter(new DefaultLogHandler()); + manager = new OTScopeManager(tracer, converter); + } + + @AfterEach + void restoreContext() { + previousContext.swap(); + child.finish(); + parent.finish(); + tracer.close(); + AgentTracer.forceRegister(previousTracer); + } + + @Test + @WithConfig(key = "legacy.context-manager.enabled", value = "false") + void activeViewLeavesContextIntactAndRetainedScopeRestoresIt() { + Scope scope = manager.activate(converter.toSpan(child), true); + try { + Context.setCaptureEnabled(false); + manager.active().close(); + manager.active().close(); + assertSame(child, tracer.activeSpan()); + assertFalse(Context.isCaptureEnabled()); + assertFalse(child.isFinished()); + } finally { + scope.close(); + } + assertSame(parent, tracer.activeSpan()); + assertFalse(Context.isCaptureEnabled()); + assertTrue(child.isFinished()); + } + + @Test + @WithConfig(key = "legacy.context-manager.enabled", value = "true") + void legacyActiveViewClosesTheCurrentScopeWithoutFinishingTheSpan() { + Scope scope = manager.activate(converter.toSpan(child), true); + try { + manager.active().close(); + assertSame(parent, tracer.activeSpan()); + assertFalse(Context.isCaptureEnabled()); + assertFalse(child.isFinished()); + } finally { + scope.close(); + } + assertSame(parent, tracer.activeSpan()); + assertTrue(child.isFinished()); + } +} diff --git a/docs/how_instrumentations_work.md b/docs/how_instrumentations_work.md index 0f8fd1d674d..5d9618688c2 100644 --- a/docs/how_instrumentations_work.md +++ b/docs/how_instrumentations_work.md @@ -911,6 +911,8 @@ Every swap returns a `ContextHandle` for restoration by swapping back. Handles e See the [Context API](../components/context/src/main/java/datadog/context/Context.java) for the full contract. +Swapping contexts does not finish spans. + ### Continuation effects An unresolved continuation keeps `PendingTrace`'s reference count positive and prevents its normal diff --git a/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentTracer.java b/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentTracer.java index 5365fc160b3..74b2e2343f5 100644 --- a/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentTracer.java +++ b/internal-api/src/main/java/datadog/trace/bootstrap/instrumentation/api/AgentTracer.java @@ -85,27 +85,6 @@ public static AgentSpan activeSpan() { return get().activeSpan(); } - /** - * Activate a span which will be closed by {@link #closeActive()} instead of a scope. - * - * @deprecated This should only be used when the instrumented code doesn't align with a scope. - */ - @Deprecated - public static void activateSpanWithoutScope(final AgentSpan span) { - get().activateSpanWithoutScope(span); - } - - /** - * Closes the scope for the currently active span. - * - * @deprecated This should only be used when the span was previously activated with {@link - * #activateSpanWithoutScope} because the instrumented code didn't align with a scope. - */ - @Deprecated - public static void closeActive() { - get().closeActive(); - } - public static TraceConfig traceConfig(final AgentSpan span) { return null != span ? span.traceConfig() : traceConfig(); } @@ -316,11 +295,6 @@ default AgentSpan blackholeSpan() { AgentSpan activeSpan(); - /** Activate a span which will be closed by {@link #closeActive()} instead of a scope. */ - void activateSpanWithoutScope(AgentSpan span); - - void closeActive(); - // deprecated public Tracer API methods which we can't remove yet for compatibility reasons @Override @@ -343,7 +317,13 @@ default TraceScope.Continuation captureActiveSpan() { return new TraceScopeContinuationWrapper(capture(current)); } - // deprecated temporary methods only used for legacy context manager migration + // deprecated scope management methods only supported in legacy context manager mode + + @Deprecated + void activateSpanWithoutScope(AgentSpan span); + + @Deprecated + void closeActive(); @Deprecated void checkpointActiveForRollback(); @@ -357,6 +337,8 @@ default TraceScope.Continuation captureActiveSpan() { @Deprecated ContextScope activateNext(AgentSpan span); + // deprecated context migration methods only supported in legacy context manager mode + @Deprecated Context currentContext();