Prove the restored trace context parents the outbox delivery

Author: dominik-kovacs

notify-spring-boot-outbox/pom.xml

@@ -68,6 +68,16 @@
             <artifactId>micrometer-tracing-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>io.micrometer</groupId>
+            <artifactId>micrometer-tracing-bridge-otel</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.opentelemetry</groupId>
+            <artifactId>opentelemetry-sdk-testing</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>

notify-spring-boot-outbox/src/test/java/sk/solodev/notify/outbox/MicrometerOutboxTracePropagatorTest.java

@@ -17,7 +17,7 @@
 class MicrometerOutboxTracePropagatorTest {
 
     @Test
-    void should_return_empty_when_no_span_is_active() {
+    void returnsEmptyWhenNoSpanIsActive() {
         var tracer = new SimpleTracer();
         var propagator = new TestPropagator();
         var sut = new MicrometerOutboxTracePropagator(tracer, propagator);
@@ -28,7 +28,7 @@ void should_return_empty_when_no_span_is_active() {
     }
 
     @Test
-    void should_capture_trace_context_when_span_is_active() {
+    void capturesTheTraceContextWhenASpanIsActive() {
         var tracer = new SimpleTracer();
         var propagator = new TestPropagator();
         var sut = new MicrometerOutboxTracePropagator(tracer, propagator);
@@ -47,7 +47,7 @@ void should_capture_trace_context_when_span_is_active() {
     }
 
     @Test
-    void should_run_delivery_and_return_its_value_with_restored_context() {
+    void runsTheDeliveryAndReturnsItsValueWithARestoredContext() {
         var tracer = new SimpleTracer();
         var propagator = new TestPropagator();
         var sut = new MicrometerOutboxTracePropagator(tracer, propagator);
@@ -66,7 +66,7 @@ void should_run_delivery_and_return_its_value_with_restored_context() {
     }
 
     @Test
-    void should_run_delivery_when_trace_context_is_null() {
+    void runsTheDeliveryWhenThereIsNoStoredContext() {
         var tracer = new SimpleTracer();
         var propagator = new TestPropagator();
         var sut = new MicrometerOutboxTracePropagator(tracer, propagator);
@@ -77,7 +77,7 @@ void should_run_delivery_when_trace_context_is_null() {
     }
 
     @Test
-    void should_run_delivery_even_with_malformed_context() {
+    void runsTheDeliveryEvenWhenTheStoredContextIsMalformed() {
         var tracer = new SimpleTracer();
         var propagator = new TestPropagator();
         var sut = new MicrometerOutboxTracePropagator(tracer, propagator);
@@ -88,7 +88,7 @@ void should_run_delivery_even_with_malformed_context() {
     }
 
     @Test
-    void should_propagate_trace_id_through_round_trip() {
+    void carriesTheTraceIdThroughACaptureAndRestoreRoundTrip() {
         var tracer = new SimpleTracer();
         var propagator = new TestPropagator();
         var sut = new MicrometerOutboxTracePropagator(tracer, propagator);
@@ -107,7 +107,7 @@ void should_propagate_trace_id_through_round_trip() {
 
         // Verify delivery runs (the TestSpan created by our propagator isn't recognized by
         // SimpleTracer as "current", which is a limitation of the test infrastructure.
-        // The actual parent-child link verification happens in the end-to-end test in a later task.)
+        // The actual parent-child link verification happens in OutboxTracePropagationOtelTest.)
         var deliveryRan = new AtomicBoolean(false);
         sut.withRestoredContext(captured, () -> {
             deliveryRan.set(true);
@@ -120,7 +120,7 @@ void should_propagate_trace_id_through_round_trip() {
     }
 
     @Test
-    void should_restore_context_before_running_delivery() {
+    void restoresTheContextBeforeRunningTheDelivery() {
         var tracer = new SimpleTracer();
         var propagator = new TestPropagator();
         var sut = new MicrometerOutboxTracePropagator(tracer, propagator);

notify-spring-boot-outbox/src/test/java/sk/solodev/notify/outbox/OutboxTracePropagationOtelTest.java

@@ -0,0 +1,98 @@
+package sk.solodev.notify.outbox;
+
+import io.micrometer.tracing.otel.bridge.OtelCurrentTraceContext;
+import io.micrometer.tracing.otel.bridge.OtelPropagator;
+import io.micrometer.tracing.otel.bridge.OtelTracer;
+import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
+import io.opentelemetry.context.propagation.ContextPropagators;
+import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import sk.solodev.notify.NotificationRequest;
+import sk.solodev.notify.test.RecordingNotifier;
+import tools.jackson.databind.json.JsonMapper;
+
+import java.time.Duration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Proves trace context propagation across the outbox boundary using a real OpenTelemetry SDK: the
+ * delivery span created by {@link OutboxRelay} becomes a child of the request span that enqueued,
+ * even though they run in different transactions and possibly different threads.
+ */
+class OutboxTracePropagationOtelTest {
+
+    record SampleRequest(String to, String body) implements NotificationRequest { }
+
+    private static final OutboxProperties PROPERTIES = new OutboxProperties(
+            Duration.ofSeconds(5), 100, 7, Duration.ofSeconds(10), Duration.ofMinutes(10),
+            "notification_outbox");
+
+    private InMemorySpanExporter spanExporter;
+    private OtelTracer tracer;
+    private MicrometerOutboxTracePropagator propagator;
+
+    @BeforeEach
+    void setUp() {
+        spanExporter = InMemorySpanExporter.create();
+        var tracerProvider = SdkTracerProvider.builder()
+                .addSpanProcessor(SimpleSpanProcessor.create(spanExporter))
+                .build();
+        var otelTracer = tracerProvider.get("test");
+        var propagators = ContextPropagators.create(W3CTraceContextPropagator.getInstance());
+
+        tracer = new OtelTracer(otelTracer, new OtelCurrentTraceContext(), null);
+        propagator = new MicrometerOutboxTracePropagator(tracer,
+                new OtelPropagator(propagators, otelTracer));
+    }
+
+    @Test
+    void theDeliverySpanInheritsTheTraceIdFromTheEnqueuingRequest() {
+        // Start a span representing the incoming request
+        var requestSpan = tracer.nextSpan().name("incoming-request").start();
+        String originalTraceId = requestSpan.context().traceId();
+
+        // Enqueue within the request span's scope
+        OutboxEntry entry;
+        var store = new RecordingOutboxStore();
+        var enqueuer = new DefaultOutboxNotifier(store, JsonMapper.builder().build(),
+                PROPERTIES, propagator);
+        try (var _ = tracer.withSpan(requestSpan)) {
+            enqueuer.enqueue(new SampleRequest("+421900123456", "hello"));
+        } finally {
+            requestSpan.end();
+        }
+
+        // The entry should have captured the trace context
+        entry = store.inserted.getFirst();
+        assertThat(entry.traceContext()).isNotNull();
+
+        // Now deliver it through the relay
+        var notifier = new RecordingNotifier();
+        var relay = new OutboxRelay(notifier, new RecordingOutboxStore(entry),
+                JsonMapper.builder().build(), PROPERTIES, propagator);
+
+        relay.poll();
+
+        // Export spans and find the delivery span
+        var exportedSpans = spanExporter.getFinishedSpanItems();
+
+        // The request span and the delivery span should both be present
+        assertThat(exportedSpans).hasSizeGreaterThanOrEqualTo(2);
+
+        // Find the delivery span (it's the one created after the request span ended)
+        var deliverySpan = exportedSpans.stream()
+                .filter(span -> !span.getSpanId().equals(requestSpan.context().spanId()))
+                .findFirst()
+                .orElseThrow(() -> new AssertionError("Delivery span not found"));
+
+        // The critical assertion: the delivery span must have the same trace ID as the request
+        assertThat(deliverySpan.getTraceId())
+                .as("Delivery span should inherit the request's trace ID")
+                .isEqualTo(originalTraceId);
+    }
+
+}