From 41b860a7c349bc31b02b734c09e9c015aa5d7b0b Mon Sep 17 00:00:00 2001 From: Tim Quinn Date: Tue, 16 Apr 2024 11:09:45 -0500 Subject: [PATCH] Review comments --- .../includes/tracing/common-callbacks.adoc | 34 ++--- ...tener.java => AutoLoadedSpanListener.java} | 22 +-- .../providers/tests/TestSpanCallbacks.java | 138 +++++++++--------- .../tests/TestSpanLifeCycleListener.java | 16 +- .../src/main/java/module-info.java | 6 +- .../jaeger/JaegerTracerProvider.java | 8 +- .../jaeger/src/main/java/module-info.java | 3 +- .../opentelemetry/HelidonOpenTelemetry.java | 6 +- .../opentelemetry/OpenTelemetryScope.java | 8 +- .../opentelemetry/OpenTelemetrySpan.java | 14 +- .../OpenTelemetrySpanBuilder.java | 12 +- .../opentelemetry/OpenTelemetryTracer.java | 10 +- .../src/main/java/module-info.java | 4 +- ...nwrap.java => TestSpanListenerUnwrap.java} | 8 +- .../providers/opentracing/OpenTracing.java | 6 +- .../opentracing/OpenTracingScope.java | 8 +- .../opentracing/OpenTracingSpan.java | 12 +- .../opentracing/OpenTracingSpanBuilder.java | 10 +- .../opentracing/OpenTracingTracer.java | 10 +- .../OpenTracingTracerProvider.java | 6 +- .../src/main/java/module-info.java | 4 +- .../providers/zipkin/ZipkinScopeManager.java | 12 +- .../tracing/providers/zipkin/ZipkinSpan.java | 10 +- .../providers/zipkin/ZipkinSpanBuilder.java | 12 +- .../providers/zipkin/ZipkinTracer.java | 8 +- .../zipkin/src/main/java/module-info.java | 3 +- .../java/io/helidon/tracing/NoOpTracer.java | 2 +- .../main/java/io/helidon/tracing/Scope.java | 2 +- ...feCycleListener.java => SpanListener.java} | 42 +++--- .../main/java/io/helidon/tracing/Tracer.java | 4 +- .../UnsupportedActivationException.java | 2 +- .../tracing/src/main/java/module-info.java | 4 +- 32 files changed, 227 insertions(+), 219 deletions(-) rename tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/{AutoLoadedSpanLifeCycleListener.java => AutoLoadedSpanListener.java} (68%) rename tracing/providers/opentelemetry/src/test/java/io/helidon/tracing/providers/opentelemetry/{TestSpanLifeCycleListenerUnwrap.java => TestSpanListenerUnwrap.java} (92%) rename tracing/tracing/src/main/java/io/helidon/tracing/{SpanLifeCycleListener.java => SpanListener.java} (75%) diff --git a/docs/src/main/asciidoc/includes/tracing/common-callbacks.adoc b/docs/src/main/asciidoc/includes/tracing/common-callbacks.adoc index b3131496bf1..a5025741ecf 100644 --- a/docs/src/main/asciidoc/includes/tracing/common-callbacks.adoc +++ b/docs/src/main/asciidoc/includes/tracing/common-callbacks.adoc @@ -22,13 +22,13 @@ include::{rootdir}/attributes.adoc // tag::defs[] :tracing-javadoc: {tracing-javadoc-base-url}/io/helidon/tracing :tracing-api-javadoc: {tracing-javadoc} -:listener-type: SpanLifeCycleListener +:listener-type: SpanListener // end::defs[] // tag::detailed[] // tag::intro[] -== Responding to Span Life Cycle Events [[Tracing-callbacks]] +== Responding to Span Lifecycle Events [[Tracing-callbacks]] Applications and libraries can register listeners to be notified at several moments during the lifecycle of every span: @@ -40,15 +40,15 @@ Applications and libraries can register listeners to be notified at several mome // end::intro[] -The next sections explain how you can write and add a listener and what it can do. See the link:{tracing-api-javadoc}/{listener-type}.html[`{listener-type}`] JavaDoc for more information. +The next sections explain how you can write and add a listener and what it can do. See the link:{tracing-api-javadoc}/{listener-type}.html[`{listener-type}`] Javadoc for more information. === Understanding What Listeners Do A listener cannot affect the lifecycle of a span or scope it is notified about, but it can add tags and events and update the baggage associated with a span. Often a listener does additional work that does not change the span or scope such as logging a message. -When Helidon invokes the listener's methods it passes safe adapters for the parameter types. These adapters limit the access the listener has to the span builder, span, or scope, as summarized in the following table. +When Helidon invokes the listener's methods it passes proxies for the parameter types. These proxies limit the access the listener has to the span builder, span, or scope, as summarized in the following table. -.Summary of Permitted Operations on Safe Adapters Passed to Listeners +.Summary of Permitted Operations on Proxies Passed to Listeners |==== | Tracing type | Changes allowed @@ -60,7 +60,7 @@ When Helidon invokes the listener's methods it passes safe adapters for the para |==== -The following tables list specifically what operations the safe adapters permit. +The following tables list specifically what operations the proxies permit. .link:{tracing-javadoc}/Span.Builder.html[`io.helidon.tracing.Span.Builder`] Operations @@ -77,7 +77,7 @@ The following tables list specifically what operations the safe adapters permit. | `unwrap(Class)` | Cast the builder to the specified implementation type. † | ✓ |==== -† Helidon returns the unwrapped object, not a safe adapter to it. +† Helidon returns the unwrapped object, not a proxy to it. .link:{tracing-javadoc}/Span.html[`io.helidon.tracing.Span`] Operations @@ -95,7 +95,7 @@ The following tables list specifically what operations the safe adapters permit. {empty}* Helidon throws the link:{tracing-javadoc}/UnsupportedActivationException.html[`UnsupportedActivationException`] if a listener attempts an illegal operation from inside its `afterActivation` method. This Helidon exception extends `UnsupportedOperationException` and adds the `Scope scope()` method. Callers should catch this exception and close the `Scope`; Helidon will have activated the span and created the scope _before_ it invoked the listeners. -† Helidon returns the unwrapped object, not a safe adapter to it. +† Helidon returns the unwrapped object, not a proxy to it. .link:{tracing-javadoc}/Scope.html[`io.helidon.tracing.Scope`] Operations |==== @@ -121,10 +121,10 @@ Create a `{listener-type}` instance and invoke the `Tracer#register({listener-ty ==== Automatically Registering a Listener on all `Tracer` Instances Helidon also uses Java service loading to locate listeners and register them automatically on all `Tracer` objects. -Follow these steps to add an auto-loaded listener. +Follow these steps to add listener service provider. 1. Implement the link:{tracing-api-javadoc}/{listener-type}.html[`{listener-type}`] interface. -2. Declare your implementation as a loadable service: +2. Declare your implementation as a service provider: a. Create the file `META-INF/services/io.helidon.tracing.{listener-type}` containing a line with the fully-qualified name of your class which implements `{listener-type}`. b. If your service has a `module-info.java` file add the following line to it: + @@ -140,12 +140,12 @@ Helidon invokes each listener's methods in the following order: |==== | Method | When invoked -| `beforeStart(Span.Builder spanBuilder)` | Just before a span is started from its builder. -| `afterStart(Span span)` | Just after a span has started. -| `afterActivate(Span span, Scope scope)` | After a span has been activated, creating a new scope. A given span might never be activated; it depends on the code. -| `afterClose(Span span, Scope scope)` | After a scope has been closed. -| `afterEnd(Span span)` | After a span has ended successfully. -| `afterEnd(Span span, Throwable t)` | After a span has ended unsuccessfully. +| `starting(Span.Builder spanBuilder)` | Just before a span is started from its builder. +| `started(Span span)` | Just after a span has started. +| `activated(Span span, Scope scope)` | After a span has been activated, creating a new scope. A given span might never be activated; it depends on the code. +| `closed(Span span, Scope scope)` | After a scope has been closed. +| `ended(Span span)` | After a span has ended successfully. +| `ended(Span span, Throwable t)` | After a span has ended unsuccessfully. |==== @@ -155,5 +155,5 @@ Helidon invokes each listener's methods in the following order: // tag::brief[] include::common-callbacks.adoc[tag=intro] -See the link:{tracing-api-javadoc}/{listener-type}.html[`{listener-type}`] JavaDoc for more information. +See the link:{tracing-api-javadoc}/{listener-type}.html[`{listener-type}`] Javadoc for more information. // end::brief[] diff --git a/tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/AutoLoadedSpanLifeCycleListener.java b/tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/AutoLoadedSpanListener.java similarity index 68% rename from tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/AutoLoadedSpanLifeCycleListener.java rename to tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/AutoLoadedSpanListener.java index f3c32f1514b..d963df4c77b 100644 --- a/tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/AutoLoadedSpanLifeCycleListener.java +++ b/tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/AutoLoadedSpanListener.java @@ -17,12 +17,12 @@ import io.helidon.tracing.Scope; import io.helidon.tracing.Span; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; /** * Test listener. */ -public class AutoLoadedSpanLifeCycleListener implements SpanLifeCycleListener { +public class AutoLoadedSpanListener implements SpanListener { /** * After start value. @@ -52,31 +52,31 @@ public class AutoLoadedSpanLifeCycleListener implements SpanLifeCycleListener { /** * For service loading. */ - public AutoLoadedSpanLifeCycleListener() { + public AutoLoadedSpanListener() { } @Override - public void afterStart(Span span) throws UnsupportedOperationException { - span.baggage().set("auto-afterStart", AFTER_START); + public void started(Span span) throws UnsupportedOperationException { + span.baggage().set("auto-started", AFTER_START); } @Override - public void afterActivate(Span span, Scope scope) throws UnsupportedOperationException { - span.baggage().set("auto-afterActivate", AFTER_ACTIVATE); + public void activated(Span span, Scope scope) throws UnsupportedOperationException { + span.baggage().set("auto-activated", AFTER_ACTIVATE); } @Override - public void afterClose(Span span, Scope scope) throws UnsupportedOperationException { - span.baggage().set("auto-afterClose", AFTER_CLOSE); + public void closed(Span span, Scope scope) throws UnsupportedOperationException { + span.baggage().set("auto-closed", AFTER_CLOSE); } @Override - public void afterEnd(Span span) { + public void ended(Span span) { span.baggage().set("auto-afterEndOk", AFTER_END_OK); } @Override - public void afterEnd(Span span, Throwable t) { + public void ended(Span span, Throwable t) { span.baggage().set("auto-afterEndBad", AFTER_END_BAD); } } diff --git a/tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/TestSpanCallbacks.java b/tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/TestSpanCallbacks.java index 0076df7bbca..78bef0fcd09 100644 --- a/tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/TestSpanCallbacks.java +++ b/tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/TestSpanCallbacks.java @@ -23,7 +23,7 @@ import io.helidon.tracing.Baggage; import io.helidon.tracing.Scope; import io.helidon.tracing.Span; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.helidon.tracing.Tracer; import io.helidon.tracing.TracerBuilder; import io.helidon.tracing.UnsupportedActivationException; @@ -60,9 +60,9 @@ static void setup() { @Test void checkSpanStartEndOk() { checkSpanStartEnd( - hasEntry("afterEnd", AFTER_END_BAGGAGE_VALUE), + hasEntry("ended", AFTER_END_BAGGAGE_VALUE), not(hasKey("afterEndBad")), - hasEntry("auto-afterEndOk", AutoLoadedSpanLifeCycleListener.AFTER_END_OK), + hasEntry("auto-afterEndOk", AutoLoadedSpanListener.AFTER_END_OK), not(hasKey("auto-afterEndBad")), Span::end); } @@ -70,18 +70,18 @@ void checkSpanStartEndOk() { @Test void checkSpanStartEndNotOk() { checkSpanStartEnd( - not(hasKey("afterEnd")), + not(hasKey("ended")), hasEntry("afterEndBad", AFTER_END_BAD_BAGGAGE_VALUE), not(hasKey("auto-afterEndOk")), - hasEntry("auto-afterEndBad", AutoLoadedSpanLifeCycleListener.AFTER_END_BAD), + hasEntry("auto-afterEndBad", AutoLoadedSpanListener.AFTER_END_BAD), span -> span.end(new Throwable())); } @Test void checkRejectBeforeStart() { - SpanLifeCycleListener l1 = new SpanLifeCycleListener() { + SpanListener l1 = new SpanListener() { @Override - public void beforeStart(Span.Builder spanBuilder) throws UnsupportedOperationException { + public void starting(Span.Builder spanBuilder) throws UnsupportedOperationException { spanBuilder.start(); } }; @@ -96,9 +96,9 @@ public void beforeStart(Span.Builder spanBuilder) throws UnsupportedOperation @Test void checkRejectAfterStart() { - SpanLifeCycleListener l1 = new SpanLifeCycleListener() { + SpanListener l1 = new SpanListener() { @Override - public void afterStart(Span span) throws UnsupportedOperationException { + public void started(Span span) throws UnsupportedOperationException { span.end(); } }; @@ -113,9 +113,9 @@ public void afterStart(Span span) throws UnsupportedOperationException { @Test void checkRejectAfterActivateEndSpan() { - SpanLifeCycleListener l1 = new SpanLifeCycleListener() { + SpanListener l1 = new SpanListener() { @Override - public void afterActivate(Span span, Scope scope) throws UnsupportedOperationException { + public void activated(Span span, Scope scope) throws UnsupportedOperationException { span.end(); } }; @@ -131,9 +131,9 @@ public void afterActivate(Span span, Scope scope) throws UnsupportedOperationExc @Test void checkRejectAfterCloseSpan() { - SpanLifeCycleListener l1 = new SpanLifeCycleListener() { + SpanListener l1 = new SpanListener() { @Override - public void afterClose(Span span, Scope scope) throws UnsupportedOperationException { + public void closed(Span span, Scope scope) throws UnsupportedOperationException { span.end(); } }; @@ -149,9 +149,9 @@ public void afterClose(Span span, Scope scope) throws UnsupportedOperationExcept @Test void checkRejectAfterCloseScope() { - SpanLifeCycleListener l1 = new SpanLifeCycleListener() { + SpanListener l1 = new SpanListener() { @Override - public void afterActivate(Span span, Scope scope) throws UnsupportedOperationException { + public void activated(Span span, Scope scope) throws UnsupportedOperationException { scope.close(); } }; @@ -167,9 +167,9 @@ public void afterActivate(Span span, Scope scope) throws UnsupportedOperationExc @Test void checkRejectAfterEndOk() { - SpanLifeCycleListener l1 = new SpanLifeCycleListener() { + SpanListener l1 = new SpanListener() { @Override - public void afterEnd(Span span) throws UnsupportedOperationException { + public void ended(Span span) throws UnsupportedOperationException { span.end(); } }; @@ -185,9 +185,9 @@ public void afterEnd(Span span) throws UnsupportedOperationException { @Test void checkRejectAfterEndBad() { - SpanLifeCycleListener l1 = new SpanLifeCycleListener() { + SpanListener l1 = new SpanListener() { @Override - public void afterEnd(Span span, Throwable t) throws UnsupportedOperationException { + public void ended(Span span, Throwable t) throws UnsupportedOperationException { span.end(new Throwable()); } }; @@ -206,7 +206,7 @@ private void checkSpanStartEnd(Matcher> spanEndOkMatche Matcher> spanAutoEndBadMatcher, Consumer spanEnder) { Map listenerInfo = new HashMap<>(); - TestLifeCycleListener listener = new TestLifeCycleListener(listenerInfo); + TestListener listener = new TestListener(listenerInfo); Tracer tracer = tracerBuilder.build(); @@ -215,57 +215,57 @@ private void checkSpanStartEnd(Matcher> spanEndOkMatche Span.Builder spanBuilder = tracer.spanBuilder(spanName); Span span = spanBuilder.start(); - assertThat("Before start", listenerInfo, hasKey("beforeStart")); + assertThat("Before start", listenerInfo, hasKey("starting")); assertThat("After start", baggageAsMap(span.baggage()), - allOf(hasEntry("afterStart", AFTER_START_BAGGAGE_VALUE), - not(hasKey("afterActivate")), - not(hasKey("afterClose")), - not(hasKey("afterEnd")), + allOf(hasEntry("started", AFTER_START_BAGGAGE_VALUE), + not(hasKey("activated")), + not(hasKey("closed")), + not(hasKey("ended")), not(hasKey("afterEndBad")), - hasEntry("auto-afterStart", AutoLoadedSpanLifeCycleListener.AFTER_START), - not(hasKey("auto-afterActivate")), - not(hasKey("auto-afterClose")), + hasEntry("auto-started", AutoLoadedSpanListener.AFTER_START), + not(hasKey("auto-activated")), + not(hasKey("auto-closed")), not(hasKey("auto-afterEndOk")), not(hasKey("auto-afterEndBad")))); try (Scope scope = span.activate()) { assertThat("After activate", baggageAsMap(span.baggage()), - allOf(hasEntry("afterStart", AFTER_START_BAGGAGE_VALUE), - hasEntry("afterActivate", AFTER_ACTIVATE_BAGGAGE_VALUE), - not(hasKey("afterClose")), - not(hasKey("afterEnd")), + allOf(hasEntry("started", AFTER_START_BAGGAGE_VALUE), + hasEntry("activated", AFTER_ACTIVATE_BAGGAGE_VALUE), + not(hasKey("closed")), + not(hasKey("ended")), not(hasKey("afterEndBad")), - hasEntry("auto-afterStart", AutoLoadedSpanLifeCycleListener.AFTER_START), - hasEntry("auto-afterActivate", AutoLoadedSpanLifeCycleListener.AFTER_ACTIVATE), - not(hasKey("auto-afterClose")), + hasEntry("auto-started", AutoLoadedSpanListener.AFTER_START), + hasEntry("auto-activated", AutoLoadedSpanListener.AFTER_ACTIVATE), + not(hasKey("auto-closed")), not(hasKey("auto-afterEndOk")), not(hasKey("auto-afterEndBad")))); } assertThat("After close", baggageAsMap(span.baggage()), - allOf(hasEntry("afterStart", AFTER_START_BAGGAGE_VALUE), - hasEntry("afterActivate", AFTER_ACTIVATE_BAGGAGE_VALUE), - hasEntry("afterClose", AFTER_CLOSE_BAGGAGE_VALUE), - not(hasKey("afterEnd")), + allOf(hasEntry("started", AFTER_START_BAGGAGE_VALUE), + hasEntry("activated", AFTER_ACTIVATE_BAGGAGE_VALUE), + hasEntry("closed", AFTER_CLOSE_BAGGAGE_VALUE), + not(hasKey("ended")), not(hasKey("afterEndBad")), - hasEntry("auto-afterStart", AutoLoadedSpanLifeCycleListener.AFTER_START), - hasEntry("auto-afterActivate", AutoLoadedSpanLifeCycleListener.AFTER_ACTIVATE), - hasEntry("auto-afterClose", AutoLoadedSpanLifeCycleListener.AFTER_CLOSE), + hasEntry("auto-started", AutoLoadedSpanListener.AFTER_START), + hasEntry("auto-activated", AutoLoadedSpanListener.AFTER_ACTIVATE), + hasEntry("auto-closed", AutoLoadedSpanListener.AFTER_CLOSE), not(hasKey("auto-afterEndOk")), not(hasKey("auto-afterEndBad")))); spanEnder.accept(span); assertThat("After end", baggageAsMap(span.baggage()), - allOf(hasEntry("afterStart", AFTER_START_BAGGAGE_VALUE), - hasEntry("afterActivate", AFTER_ACTIVATE_BAGGAGE_VALUE), - hasEntry("afterClose", AFTER_CLOSE_BAGGAGE_VALUE), + allOf(hasEntry("started", AFTER_START_BAGGAGE_VALUE), + hasEntry("activated", AFTER_ACTIVATE_BAGGAGE_VALUE), + hasEntry("closed", AFTER_CLOSE_BAGGAGE_VALUE), spanEndOkMatcher, spanEndBadMatcher, - hasEntry("auto-afterStart", AutoLoadedSpanLifeCycleListener.AFTER_START), - hasEntry("auto-afterActivate", AutoLoadedSpanLifeCycleListener.AFTER_ACTIVATE), - hasEntry("auto-afterClose", AutoLoadedSpanLifeCycleListener.AFTER_CLOSE), + hasEntry("auto-started", AutoLoadedSpanListener.AFTER_START), + hasEntry("auto-activated", AutoLoadedSpanListener.AFTER_ACTIVATE), + hasEntry("auto-closed", AutoLoadedSpanListener.AFTER_CLOSE), spanAutoEndOkMatcher, spanAutoEndBadMatcher)); } @@ -278,77 +278,77 @@ private Map baggageAsMap(Baggage baggage) { HashMap::putAll); } - private static class TestLifeCycleListener implements SpanLifeCycleListener { + private static class TestListener implements SpanListener { private final Map listenerInfo; - private TestLifeCycleListener(Map listenerInfo) { + private TestListener(Map listenerInfo) { this.listenerInfo = listenerInfo; } @Override - public void beforeStart(Span.Builder spanBuilder) throws UnsupportedOperationException { - listenerInfo.put("beforeStart", spanBuilder); + public void starting(Span.Builder spanBuilder) throws UnsupportedOperationException { + listenerInfo.put("starting", spanBuilder); } @Override - public void afterStart(Span span) throws UnsupportedOperationException { - span.baggage().set("afterStart", AFTER_START_BAGGAGE_VALUE); + public void started(Span span) throws UnsupportedOperationException { + span.baggage().set("started", AFTER_START_BAGGAGE_VALUE); } @Override - public void afterActivate(Span span, Scope scope) throws UnsupportedOperationException { - span.baggage().set("afterActivate", AFTER_ACTIVATE_BAGGAGE_VALUE); + public void activated(Span span, Scope scope) throws UnsupportedOperationException { + span.baggage().set("activated", AFTER_ACTIVATE_BAGGAGE_VALUE); } @Override - public void afterClose(Span span, Scope scope) throws UnsupportedOperationException { - span.baggage().set("afterClose", AFTER_CLOSE_BAGGAGE_VALUE); + public void closed(Span span, Scope scope) throws UnsupportedOperationException { + span.baggage().set("closed", AFTER_CLOSE_BAGGAGE_VALUE); } @Override - public void afterEnd(Span span) { - span.baggage().set("afterEnd", AFTER_END_BAGGAGE_VALUE); + public void ended(Span span) { + span.baggage().set("ended", AFTER_END_BAGGAGE_VALUE); } @Override - public void afterEnd(Span span, Throwable t) { + public void ended(Span span, Throwable t) { span.baggage().set("afterEndBad", AFTER_END_BAD_BAGGAGE_VALUE); } } - private static class BadListener implements SpanLifeCycleListener { + private static class BadListener implements SpanListener { BadListener() { } @Override - public void beforeStart(Span.Builder spanBuilder) throws UnsupportedOperationException { + public void starting(Span.Builder spanBuilder) throws UnsupportedOperationException { spanBuilder.start(); } @Override - public void afterStart(Span span) throws UnsupportedOperationException { + public void started(Span span) throws UnsupportedOperationException { span.end(); } @Override - public void afterActivate(Span span, Scope scope) throws UnsupportedOperationException { + public void activated(Span span, Scope scope) throws UnsupportedOperationException { scope.close(); } @Override - public void afterClose(Span span, Scope scope) throws UnsupportedOperationException { + public void closed(Span span, Scope scope) throws UnsupportedOperationException { span.end(); } @Override - public void afterEnd(Span span) { + public void ended(Span span) { } @Override - public void afterEnd(Span span, Throwable t) { - io.helidon.tracing.SpanLifeCycleListener.super.afterEnd(span, t); + public void ended(Span span, Throwable t) { + SpanListener.super.ended(span, t); } } } diff --git a/tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/TestSpanLifeCycleListener.java b/tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/TestSpanLifeCycleListener.java index 032be016830..84102a233e1 100644 --- a/tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/TestSpanLifeCycleListener.java +++ b/tracing/provider-tests/src/main/java/io/helidon/tracing/providers/tests/TestSpanLifeCycleListener.java @@ -20,9 +20,9 @@ import io.helidon.tracing.Scope; import io.helidon.tracing.Span; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; -class TestSpanLifeCycleListener implements SpanLifeCycleListener { +class TestSpanLifeCycleListener implements SpanListener { private Consumer> beforeStartCheck; @@ -33,42 +33,42 @@ class TestSpanLifeCycleListener implements SpanLifeCycleListener { private BiConsumer afterEndFailureCheck; @Override - public void beforeStart(Span.Builder spanBuilder) throws UnsupportedOperationException { + public void starting(Span.Builder spanBuilder) throws UnsupportedOperationException { if (beforeStartCheck != null) { beforeStartCheck.accept(spanBuilder); } } @Override - public void afterStart(Span span) throws UnsupportedOperationException { + public void started(Span span) throws UnsupportedOperationException { if (beforeStartCheck != null) { afterStartCheck.accept(span); } } @Override - public void afterActivate(Span span, Scope scope) throws UnsupportedOperationException { + public void activated(Span span, Scope scope) throws UnsupportedOperationException { if (afterActivateCheck != null) { afterActivateCheck.accept(span, scope); } } @Override - public void afterClose(Span span, Scope scope) throws UnsupportedOperationException { + public void closed(Span span, Scope scope) throws UnsupportedOperationException { if (afterCloseCheck != null) { afterCloseCheck.accept(span, scope); } } @Override - public void afterEnd(Span span) { + public void ended(Span span) { if (afterEndOkCheck != null) { afterEndOkCheck.accept(span); } } @Override - public void afterEnd(Span span, Throwable t) { + public void ended(Span span, Throwable t) { if (afterEndFailureCheck != null) { afterEndFailureCheck.accept(span, t); } diff --git a/tracing/provider-tests/src/main/java/module-info.java b/tracing/provider-tests/src/main/java/module-info.java index f6751d8c1ce..c68f87908ec 100644 --- a/tracing/provider-tests/src/main/java/module-info.java +++ b/tracing/provider-tests/src/main/java/module-info.java @@ -13,6 +13,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ + +import io.helidon.tracing.SpanListener; +import io.helidon.tracing.providers.tests.AutoLoadedSpanListener; + /** * Tests applicable to all tracing providers. */ @@ -24,5 +28,5 @@ requires org.junit.jupiter.api; requires hamcrest.all; - provides io.helidon.tracing.SpanLifeCycleListener with io.helidon.tracing.providers.tests.AutoLoadedSpanLifeCycleListener; + provides SpanListener with AutoLoadedSpanListener; } \ No newline at end of file diff --git a/tracing/providers/jaeger/src/main/java/io/helidon/tracing/providers/jaeger/JaegerTracerProvider.java b/tracing/providers/jaeger/src/main/java/io/helidon/tracing/providers/jaeger/JaegerTracerProvider.java index 7fa1d058175..aab1e47eb33 100644 --- a/tracing/providers/jaeger/src/main/java/io/helidon/tracing/providers/jaeger/JaegerTracerProvider.java +++ b/tracing/providers/jaeger/src/main/java/io/helidon/tracing/providers/jaeger/JaegerTracerProvider.java @@ -23,7 +23,7 @@ import io.helidon.common.Weight; import io.helidon.common.Weighted; import io.helidon.tracing.Span; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.helidon.tracing.Tracer; import io.helidon.tracing.providers.opentelemetry.OpenTelemetryTracerProvider; import io.helidon.tracing.spi.TracerProvider; @@ -34,8 +34,8 @@ @Weight(Weighted.DEFAULT_WEIGHT) public class JaegerTracerProvider implements TracerProvider { - private static final List LIFE_CYCLE_LISTENERS = HelidonServiceLoader.create(ServiceLoader.load( - SpanLifeCycleListener.class)).asList(); + private static final List LIFE_CYCLE_LISTENERS = HelidonServiceLoader.create(ServiceLoader.load( + SpanListener.class)).asList(); @Override public Tracer global() { @@ -62,7 +62,7 @@ public boolean available() { return true; } - static List lifeCycleListeners() { + static List lifeCycleListeners() { return LIFE_CYCLE_LISTENERS; } } diff --git a/tracing/providers/jaeger/src/main/java/module-info.java b/tracing/providers/jaeger/src/main/java/module-info.java index f95e32f366e..f058cfe2c2f 100644 --- a/tracing/providers/jaeger/src/main/java/module-info.java +++ b/tracing/providers/jaeger/src/main/java/module-info.java @@ -16,6 +16,7 @@ import io.helidon.common.features.api.Feature; import io.helidon.common.features.api.HelidonFlavor; +import io.helidon.tracing.SpanListener; /** * Jaeger tracing support. @@ -49,7 +50,7 @@ exports io.helidon.tracing.providers.jaeger; - uses io.helidon.tracing.SpanLifeCycleListener; + uses SpanListener; provides io.helidon.tracing.spi.TracerProvider with io.helidon.tracing.providers.jaeger.JaegerTracerProvider; diff --git a/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/HelidonOpenTelemetry.java b/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/HelidonOpenTelemetry.java index e762d98aa28..2974c378830 100644 --- a/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/HelidonOpenTelemetry.java +++ b/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/HelidonOpenTelemetry.java @@ -23,7 +23,7 @@ import io.helidon.common.HelidonServiceLoader; import io.helidon.common.LazyValue; import io.helidon.config.Config; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.opentelemetry.api.OpenTelemetry; import io.opentelemetry.api.baggage.Baggage; @@ -48,8 +48,8 @@ public final class HelidonOpenTelemetry { public static final String IO_OPENTELEMETRY_JAVAAGENT = "io.opentelemetry.javaagent"; private static final System.Logger LOGGER = System.getLogger(HelidonOpenTelemetry.class.getName()); - private static final LazyValue> SPAN_LIFE_CYCLE_LISTENERS = - LazyValue.create(() -> HelidonServiceLoader.create(ServiceLoader.load(SpanLifeCycleListener.class)).asList()); + private static final LazyValue> SPAN_LIFE_CYCLE_LISTENERS = + LazyValue.create(() -> HelidonServiceLoader.create(ServiceLoader.load(SpanListener.class)).asList()); private HelidonOpenTelemetry() { diff --git a/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetryScope.java b/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetryScope.java index 9e1e2b59a32..5d3e630f8d6 100644 --- a/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetryScope.java +++ b/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetryScope.java @@ -19,18 +19,18 @@ import java.util.concurrent.atomic.AtomicBoolean; import io.helidon.tracing.Scope; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; class OpenTelemetryScope implements Scope { private final OpenTelemetrySpan span; private final io.opentelemetry.context.Scope delegate; private final AtomicBoolean closed = new AtomicBoolean(); - private final List spanLifeCycleListeners; + private final List spanLifeCycleListeners; private Limited limited; OpenTelemetryScope(OpenTelemetrySpan span, io.opentelemetry.context.Scope scope, - List spanLifeCycleListeners) { + List spanLifeCycleListeners) { this.span = span; delegate = scope; this.spanLifeCycleListeners = spanLifeCycleListeners; @@ -40,7 +40,7 @@ class OpenTelemetryScope implements Scope { public void close() { if (closed.compareAndSet(false, true) && delegate != null) { delegate.close(); - spanLifeCycleListeners.forEach(listener -> listener.afterClose(span.limited(), limited())); + spanLifeCycleListeners.forEach(listener -> listener.closed(span.limited(), limited())); } } diff --git a/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetrySpan.java b/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetrySpan.java index 7bf4dc958c0..529803d2142 100644 --- a/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetrySpan.java +++ b/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetrySpan.java @@ -24,7 +24,7 @@ import io.helidon.tracing.Scope; import io.helidon.tracing.Span; import io.helidon.tracing.SpanContext; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.helidon.tracing.UnsupportedActivationException; import io.helidon.tracing.WritableBaggage; @@ -37,14 +37,14 @@ class OpenTelemetrySpan implements Span { private final io.opentelemetry.api.trace.Span delegate; private final Baggage baggage; - private final List spanLifeCycleListeners; + private final List spanLifeCycleListeners; private Limited limited; - OpenTelemetrySpan(io.opentelemetry.api.trace.Span span, List spanLifeCycleListeners) { + OpenTelemetrySpan(io.opentelemetry.api.trace.Span span, List spanLifeCycleListeners) { this(span, new MutableOpenTelemetryBaggage(), spanLifeCycleListeners); } - OpenTelemetrySpan(io.opentelemetry.api.trace.Span span, Baggage baggage, List spanLifeCycleListeners) { + OpenTelemetrySpan(io.opentelemetry.api.trace.Span span, Baggage baggage, List spanLifeCycleListeners) { delegate = span; this.baggage = baggage; this.spanLifeCycleListeners = spanLifeCycleListeners; @@ -95,7 +95,7 @@ public void addEvent(String name, Map attributes) { @Override public void end() { delegate.end(); - spanLifeCycleListeners.forEach(listener -> listener.afterEnd(limited())); + spanLifeCycleListeners.forEach(listener -> listener.ended(limited())); } @Override @@ -103,7 +103,7 @@ public void end(Throwable t) { delegate.recordException(t); delegate.setStatus(StatusCode.ERROR); delegate.end(); - spanLifeCycleListeners.forEach(listener -> listener.afterEnd(limited(), t)); + spanLifeCycleListeners.forEach(listener -> listener.ended(limited(), t)); } @Override @@ -113,7 +113,7 @@ public Scope activate() { UnsupportedActivationException ex = new UnsupportedActivationException("Error activating span", result); spanLifeCycleListeners.forEach(listener -> { try { - listener.afterActivate(limited(), result.limited()); + listener.activated(limited(), result.limited()); } catch (Throwable t) { ex.addSuppressed(t); } diff --git a/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetrySpanBuilder.java b/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetrySpanBuilder.java index f33956cdaf2..5fc0a12ca46 100644 --- a/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetrySpanBuilder.java +++ b/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetrySpanBuilder.java @@ -20,7 +20,7 @@ import io.helidon.tracing.Span; import io.helidon.tracing.SpanContext; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.opentelemetry.api.baggage.Baggage; import io.opentelemetry.api.trace.SpanBuilder; @@ -29,14 +29,14 @@ class OpenTelemetrySpanBuilder implements Span.Builder { private final SpanBuilder spanBuilder; - private final List spanLifeCycleListeners; + private final List spanLifeCycleListeners; private Limited limited; private boolean parentSet; private Baggage parentBaggage; - OpenTelemetrySpanBuilder(SpanBuilder spanBuilder, List spanLifeCycleListeners) { + OpenTelemetrySpanBuilder(SpanBuilder spanBuilder, List spanListeners) { this.spanBuilder = spanBuilder; - this.spanLifeCycleListeners = spanLifeCycleListeners; + this.spanLifeCycleListeners = spanListeners; } @Override @@ -94,13 +94,13 @@ public Span start(Instant instant) { spanBuilder.setNoParent(); } spanBuilder.setStartTimestamp(instant); - spanLifeCycleListeners.forEach(listener -> listener.beforeStart(limited())); + spanLifeCycleListeners.forEach(listener -> listener.starting(limited())); io.opentelemetry.api.trace.Span span = spanBuilder.startSpan(); OpenTelemetrySpan result = new OpenTelemetrySpan(span, spanLifeCycleListeners); if (parentBaggage != null) { parentBaggage.forEach((key, baggageEntry) -> result.baggage().set(key, baggageEntry.getValue())); } - spanLifeCycleListeners.forEach(listener -> listener.afterStart(result.limited())); + spanLifeCycleListeners.forEach(listener -> listener.started(result.limited())); return result; } diff --git a/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetryTracer.java b/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetryTracer.java index 714a96074e4..59e445f396e 100644 --- a/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetryTracer.java +++ b/tracing/providers/opentelemetry/src/main/java/io/helidon/tracing/providers/opentelemetry/OpenTelemetryTracer.java @@ -28,7 +28,7 @@ import io.helidon.tracing.HeaderProvider; import io.helidon.tracing.Span; import io.helidon.tracing.SpanContext; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.helidon.tracing.Tracer; import io.helidon.tracing.TracerBuilder; @@ -43,15 +43,15 @@ class OpenTelemetryTracer implements Tracer { private static final TextMapGetter GETTER = new Getter(); private static final TextMapSetter SETTER = new Setter(); - private static final LazyValue> SPAN_LIFE_CYCLE_LISTENERS = - LazyValue.create(() -> HelidonServiceLoader.create(ServiceLoader.load(SpanLifeCycleListener.class)).asList()); + private static final LazyValue> SPAN_LIFE_CYCLE_LISTENERS = + LazyValue.create(() -> HelidonServiceLoader.create(ServiceLoader.load(SpanListener.class)).asList()); private final OpenTelemetry telemetry; private final io.opentelemetry.api.trace.Tracer delegate; private final boolean enabled; private final TextMapPropagator propagator; private final Map tags; - private final List spanLifeCycleListeners = new ArrayList<>(SPAN_LIFE_CYCLE_LISTENERS.get()); + private final List spanLifeCycleListeners = new ArrayList<>(SPAN_LIFE_CYCLE_LISTENERS.get()); OpenTelemetryTracer(OpenTelemetry telemetry, io.opentelemetry.api.trace.Tracer tracer, Map tags) { this.telemetry = telemetry; @@ -102,7 +102,7 @@ public T unwrap(Class tracerClass) { } @Override - public Tracer register(SpanLifeCycleListener listener) { + public Tracer register(SpanListener listener) { spanLifeCycleListeners.add(listener); return this; } diff --git a/tracing/providers/opentelemetry/src/main/java/module-info.java b/tracing/providers/opentelemetry/src/main/java/module-info.java index 211f1e6fb88..456f41e1d83 100644 --- a/tracing/providers/opentelemetry/src/main/java/module-info.java +++ b/tracing/providers/opentelemetry/src/main/java/module-info.java @@ -14,6 +14,8 @@ * limitations under the License. */ +import io.helidon.tracing.SpanListener; + /** * Open telemetry support for Helidon tracing. */ @@ -32,7 +34,7 @@ exports io.helidon.tracing.providers.opentelemetry; - uses io.helidon.tracing.SpanLifeCycleListener; + uses SpanListener; provides io.helidon.tracing.spi.TracerProvider with io.helidon.tracing.providers.opentelemetry.OpenTelemetryTracerProvider; diff --git a/tracing/providers/opentelemetry/src/test/java/io/helidon/tracing/providers/opentelemetry/TestSpanLifeCycleListenerUnwrap.java b/tracing/providers/opentelemetry/src/test/java/io/helidon/tracing/providers/opentelemetry/TestSpanListenerUnwrap.java similarity index 92% rename from tracing/providers/opentelemetry/src/test/java/io/helidon/tracing/providers/opentelemetry/TestSpanLifeCycleListenerUnwrap.java rename to tracing/providers/opentelemetry/src/test/java/io/helidon/tracing/providers/opentelemetry/TestSpanListenerUnwrap.java index 49803951be2..62df15a4e81 100644 --- a/tracing/providers/opentelemetry/src/test/java/io/helidon/tracing/providers/opentelemetry/TestSpanLifeCycleListenerUnwrap.java +++ b/tracing/providers/opentelemetry/src/test/java/io/helidon/tracing/providers/opentelemetry/TestSpanListenerUnwrap.java @@ -20,7 +20,7 @@ import java.util.concurrent.atomic.AtomicReference; import io.helidon.tracing.Span; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.helidon.tracing.Tracer; import io.helidon.tracing.TracerBuilder; @@ -31,7 +31,7 @@ import static org.hamcrest.Matchers.hasEntry; import static org.hamcrest.Matchers.is; -class TestSpanLifeCycleListenerUnwrap { +class TestSpanListenerUnwrap { @Test void testSpanListenerUnwrap() { @@ -40,9 +40,9 @@ void testSpanListenerUnwrap() { AtomicReference unwrapResults = new AtomicReference<>(); - SpanLifeCycleListener l1 = new SpanLifeCycleListener() { + SpanListener l1 = new SpanListener() { @Override - public void afterStart(Span span) throws UnsupportedOperationException { + public void started(Span span) throws UnsupportedOperationException { io.opentelemetry.api.trace.Span otelSpan = span.unwrap(io.opentelemetry.api.trace.Span.class); ReadableSpan readableSpan = (ReadableSpan) otelSpan; unwrapResults.set(UnwrapResults.create(readableSpan)); diff --git a/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracing.java b/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracing.java index 06f4a56e454..b5e0450e27e 100644 --- a/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracing.java +++ b/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracing.java @@ -21,7 +21,7 @@ import io.helidon.common.HelidonServiceLoader; import io.helidon.common.LazyValue; import io.helidon.tracing.Span; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.opentracing.Tracer; @@ -30,8 +30,8 @@ */ public final class OpenTracing { - private static final LazyValue> SPAN_LIFE_CYCLE_LISTENERS = - LazyValue.create(() -> HelidonServiceLoader.create(ServiceLoader.load(SpanLifeCycleListener.class)).asList()); + private static final LazyValue> SPAN_LIFE_CYCLE_LISTENERS = + LazyValue.create(() -> HelidonServiceLoader.create(ServiceLoader.load(SpanListener.class)).asList()); private OpenTracing() { diff --git a/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingScope.java b/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingScope.java index b953fee06a7..96476d76d38 100644 --- a/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingScope.java +++ b/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingScope.java @@ -19,16 +19,16 @@ import java.util.concurrent.atomic.AtomicBoolean; import io.helidon.tracing.Scope; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; class OpenTracingScope implements Scope { private final OpenTracingSpan span; private final io.opentracing.Scope delegate; private final AtomicBoolean closed = new AtomicBoolean(); - private final List spanLifeCycleListeners; + private final List spanLifeCycleListeners; private Limited limited; - OpenTracingScope(OpenTracingSpan span, io.opentracing.Scope scope, List spanLifeCycleListeners) { + OpenTracingScope(OpenTracingSpan span, io.opentracing.Scope scope, List spanLifeCycleListeners) { this.span = span; this.delegate = scope; this.spanLifeCycleListeners = spanLifeCycleListeners; @@ -38,7 +38,7 @@ class OpenTracingScope implements Scope { public void close() { if (closed.compareAndSet(false, true) && delegate != null) { delegate.close(); - spanLifeCycleListeners.forEach(listener -> listener.afterClose(span.limited(), limited())); + spanLifeCycleListeners.forEach(listener -> listener.closed(span.limited(), limited())); } } diff --git a/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingSpan.java b/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingSpan.java index 7c15cdd07de..2ac3188fedf 100644 --- a/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingSpan.java +++ b/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingSpan.java @@ -24,7 +24,7 @@ import io.helidon.tracing.Scope; import io.helidon.tracing.Span; import io.helidon.tracing.SpanContext; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.helidon.tracing.UnsupportedActivationException; import io.helidon.tracing.WritableBaggage; @@ -36,10 +36,10 @@ class OpenTracingSpan implements Span { private final io.opentracing.Span delegate; private final OpenTracingContext context; private final WritableBaggage baggage; - private final List spanLifeCycleListeners; + private final List spanLifeCycleListeners; private Limited limited; - OpenTracingSpan(Tracer tracer, io.opentracing.Span delegate, List spanLifeCycleListeners) { + OpenTracingSpan(Tracer tracer, io.opentracing.Span delegate, List spanLifeCycleListeners) { this.tracer = tracer; this.delegate = delegate; this.context = new OpenTracingContext(delegate.context()); @@ -88,7 +88,7 @@ public void addEvent(String name, Map attributes) { @Override public void end() { delegate.finish(); - spanLifeCycleListeners.forEach(listener -> listener.afterEnd(limited())); + spanLifeCycleListeners.forEach(listener -> listener.ended(limited())); } @Override @@ -99,7 +99,7 @@ public void end(Throwable throwable) { "error.object", throwable, "message", throwable.getMessage() != null ? throwable.getMessage() : "none")); delegate.finish(); - spanLifeCycleListeners.forEach(listener -> listener.afterEnd(limited(), throwable)); + spanLifeCycleListeners.forEach(listener -> listener.ended(limited(), throwable)); } @Override @@ -108,7 +108,7 @@ public Scope activate() { UnsupportedActivationException ex = new UnsupportedActivationException("Error activating span", result); spanLifeCycleListeners.forEach(listener -> { try { - listener.afterActivate(limited(), result.limited()); + listener.activated(limited(), result.limited()); } catch (Throwable t) { ex.addSuppressed(t); } diff --git a/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingSpanBuilder.java b/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingSpanBuilder.java index fe1ec87e62a..c14db2206d8 100644 --- a/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingSpanBuilder.java +++ b/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingSpanBuilder.java @@ -23,7 +23,7 @@ import io.helidon.tracing.Span; import io.helidon.tracing.SpanContext; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.opentracing.Tracer; import io.opentracing.tag.Tags; @@ -31,11 +31,11 @@ class OpenTracingSpanBuilder implements Span.Builder { private final Tracer.SpanBuilder delegate; private final Tracer tracer; - private final List spanLifeCycleListeners; + private final List spanLifeCycleListeners; private Map baggage; private Limited limited; - OpenTracingSpanBuilder(Tracer tracer, Tracer.SpanBuilder delegate, List spanLifeCycleListeners) { + OpenTracingSpanBuilder(Tracer tracer, Tracer.SpanBuilder delegate, List spanLifeCycleListeners) { this.tracer = tracer; this.delegate = delegate; this.spanLifeCycleListeners = spanLifeCycleListeners; @@ -98,12 +98,12 @@ public OpenTracingSpanBuilder tag(String key, Number value) { @Override public Span start(Instant instant) { long micro = TimeUnit.MILLISECONDS.toMicros(instant.toEpochMilli()); - spanLifeCycleListeners.forEach(listener -> listener.beforeStart(limited())); + spanLifeCycleListeners.forEach(listener -> listener.starting(limited())); OpenTracingSpan result = new OpenTracingSpan(tracer, delegate.withStartTimestamp(micro).start(), spanLifeCycleListeners); if (baggage != null) { baggage.forEach((k, v) -> result.baggage().set(k, v)); } - spanLifeCycleListeners.forEach(listener -> listener.afterStart(result.limited())); + spanLifeCycleListeners.forEach(listener -> listener.started(result.limited())); return result; } diff --git a/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingTracer.java b/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingTracer.java index 93de6a2b218..4b141e7b943 100644 --- a/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingTracer.java +++ b/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingTracer.java @@ -30,7 +30,7 @@ import io.helidon.tracing.HeaderProvider; import io.helidon.tracing.Span; import io.helidon.tracing.SpanContext; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.helidon.tracing.Tracer; import io.helidon.tracing.TracerBuilder; @@ -41,12 +41,12 @@ class OpenTracingTracer implements Tracer { - private static final LazyValue> SPAN_LIFE_CYCLE_LISTENERS = - LazyValue.create(() -> HelidonServiceLoader.create(ServiceLoader.load(SpanLifeCycleListener.class)).asList()); + private static final LazyValue> SPAN_LIFE_CYCLE_LISTENERS = + LazyValue.create(() -> HelidonServiceLoader.create(ServiceLoader.load(SpanListener.class)).asList()); private final io.opentracing.Tracer delegate; private final boolean enabled; - private final List spanLifeCycleListeners = new ArrayList<>(SPAN_LIFE_CYCLE_LISTENERS.get()); + private final List spanLifeCycleListeners = new ArrayList<>(SPAN_LIFE_CYCLE_LISTENERS.get()); private OpenTracingTracer(io.opentracing.Tracer delegate, boolean enabled) { this.delegate = delegate; @@ -127,7 +127,7 @@ public T unwrap(Class tracerClass) { } @Override - public Tracer register(SpanLifeCycleListener listener) { + public Tracer register(SpanListener listener) { spanLifeCycleListeners.add(listener); return this; } diff --git a/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingTracerProvider.java b/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingTracerProvider.java index cff8d5a89fd..3bd878a7eb1 100644 --- a/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingTracerProvider.java +++ b/tracing/providers/opentracing/src/main/java/io/helidon/tracing/providers/opentracing/OpenTracingTracerProvider.java @@ -24,7 +24,7 @@ import io.helidon.common.Weight; import io.helidon.common.Weighted; import io.helidon.tracing.Span; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.helidon.tracing.Tracer; import io.helidon.tracing.TracerBuilder; import io.helidon.tracing.spi.TracerProvider; @@ -39,8 +39,8 @@ @Weight(Weighted.DEFAULT_WEIGHT - 50) // low weight, so it is easy to override public class OpenTracingTracerProvider implements TracerProvider { - private static final LazyValue> SPAN_LIFE_CYCLE_LISTENERS = - LazyValue.create(() -> HelidonServiceLoader.create(ServiceLoader.load(SpanLifeCycleListener.class)).asList()); + private static final LazyValue> SPAN_LIFE_CYCLE_LISTENERS = + LazyValue.create(() -> HelidonServiceLoader.create(ServiceLoader.load(SpanListener.class)).asList()); @Override public TracerBuilder createBuilder() { diff --git a/tracing/providers/opentracing/src/main/java/module-info.java b/tracing/providers/opentracing/src/main/java/module-info.java index ead5dd1d549..2c7816174c0 100644 --- a/tracing/providers/opentracing/src/main/java/module-info.java +++ b/tracing/providers/opentracing/src/main/java/module-info.java @@ -14,7 +14,7 @@ * limitations under the License. */ -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; /** * Open tracing support for Helidon tracing. @@ -36,7 +36,7 @@ exports io.helidon.tracing.providers.opentracing; uses io.helidon.tracing.providers.opentracing.spi.OpenTracingProvider; - uses SpanLifeCycleListener; + uses SpanListener; provides io.helidon.tracing.spi.TracerProvider with io.helidon.tracing.providers.opentracing.OpenTracingTracerProvider; diff --git a/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinScopeManager.java b/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinScopeManager.java index cb758870ebd..61409729127 100644 --- a/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinScopeManager.java +++ b/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinScopeManager.java @@ -17,7 +17,7 @@ import java.util.List; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import brave.opentracing.BraveScopeManager; import io.opentracing.Scope; @@ -30,9 +30,9 @@ */ class ZipkinScopeManager implements ScopeManager { private final BraveScopeManager scopeManager; - private final List spanLifeCycleListeners; + private final List spanLifeCycleListeners; - ZipkinScopeManager(BraveScopeManager scopeManager, List spanLifeCycleListeners) { + ZipkinScopeManager(BraveScopeManager scopeManager, List spanLifeCycleListeners) { this.scopeManager = scopeManager; this.spanLifeCycleListeners = spanLifeCycleListeners; } @@ -62,11 +62,11 @@ private static class ZipkinScope implements Scope { private final Scope delegate; private final ZipkinSpan zSpan; - private final List spanLifeCycleListeners; + private final List spanLifeCycleListeners; private Limited limited; private boolean isClosed; - private ZipkinScope(Scope delegate, ZipkinSpan zSpan, List spanLifeCycleListeners) { + private ZipkinScope(Scope delegate, ZipkinSpan zSpan, List spanLifeCycleListeners) { this.delegate = delegate; this.zSpan = zSpan; this.spanLifeCycleListeners = spanLifeCycleListeners; @@ -76,7 +76,7 @@ private ZipkinScope(Scope delegate, ZipkinSpan zSpan, List listener.afterClose(zSpan.limited(), limited())); + spanLifeCycleListeners.forEach(listener -> listener.closed(zSpan.limited(), limited())); } Limited limited() { diff --git a/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinSpan.java b/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinSpan.java index 3aac6d4b933..fcfbbe8cdbf 100644 --- a/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinSpan.java +++ b/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinSpan.java @@ -25,7 +25,7 @@ import io.helidon.tracing.Baggage; import io.helidon.tracing.Scope; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.helidon.tracing.WritableBaggage; import io.opentracing.Span; @@ -42,12 +42,12 @@ class ZipkinSpan implements Span { private final Span span; private final boolean isClient; - private final List spanLifeCycleListeners; + private final List spanLifeCycleListeners; private Limited limited; private final Set baggageKeys = new HashSet<>(); - ZipkinSpan(Span span, boolean isClient, List spanLifeCycleListeners) { + ZipkinSpan(Span span, boolean isClient, List spanLifeCycleListeners) { this.span = span; this.isClient = isClient; this.spanLifeCycleListeners = spanLifeCycleListeners; @@ -62,14 +62,14 @@ public SpanContext context() { public void finish() { finishLog(); span.finish(); - spanLifeCycleListeners.forEach(listener -> listener.afterEnd(limited())); + spanLifeCycleListeners.forEach(listener -> listener.ended(limited())); } @Override public void finish(long finishMicros) { finishLog(); span.finish(finishMicros); - spanLifeCycleListeners.forEach(listener -> listener.afterEnd(limited())); + spanLifeCycleListeners.forEach(listener -> listener.ended(limited())); } @Override diff --git a/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinSpanBuilder.java b/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinSpanBuilder.java index b72991671f2..38563c70393 100644 --- a/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinSpanBuilder.java +++ b/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinSpanBuilder.java @@ -19,7 +19,7 @@ import java.time.Instant; import java.util.List; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.helidon.tracing.Tag; import io.opentracing.Span; @@ -36,18 +36,18 @@ class ZipkinSpanBuilder implements Tracer.SpanBuilder { private final Tracer tracer; private final Tracer.SpanBuilder spanBuilder; - private final List spanLifeCycleListeners; + private final List spanLifeCycleListeners; private Limited limited; private boolean isClient; ZipkinSpanBuilder(Tracer tracer, Tracer.SpanBuilder spanBuilder, List> tags, - List spanLifeCycleListeners) { + List spanListeners) { this.tracer = tracer; this.spanBuilder = spanBuilder; tags.forEach(t -> this.withTag(t.key(), t)); // Updates both the native span builder and our internal tags structure. - this.spanLifeCycleListeners = spanLifeCycleListeners; + this.spanLifeCycleListeners = spanListeners; } @Override @@ -97,7 +97,7 @@ public Tracer.SpanBuilder withStartTimestamp(long microseconds) { @Override public Span start() { - spanLifeCycleListeners.forEach(listener -> listener.beforeStart(limited())); + spanLifeCycleListeners.forEach(listener -> listener.starting(limited())); Span span = spanBuilder.start(); if (isClient) { @@ -107,7 +107,7 @@ public Span start() { } var result = new ZipkinSpan(span, isClient, spanLifeCycleListeners); - spanLifeCycleListeners.forEach(listener -> listener.afterStart(result.limited())); + spanLifeCycleListeners.forEach(listener -> listener.started(result.limited())); return result; } diff --git a/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinTracer.java b/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinTracer.java index 3beb735fb2b..15c79d5a918 100644 --- a/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinTracer.java +++ b/tracing/providers/zipkin/src/main/java/io/helidon/tracing/providers/zipkin/ZipkinTracer.java @@ -22,7 +22,7 @@ import io.helidon.common.HelidonServiceLoader; import io.helidon.common.LazyValue; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; import io.helidon.tracing.Tag; import brave.opentracing.BraveTracer; @@ -45,13 +45,13 @@ */ public class ZipkinTracer implements Tracer { - private static final LazyValue> SPAN_LIFE_CYCLE_LISTENERS = - LazyValue.create(() -> HelidonServiceLoader.create(ServiceLoader.load(SpanLifeCycleListener.class)).asList()); + private static final LazyValue> SPAN_LIFE_CYCLE_LISTENERS = + LazyValue.create(() -> HelidonServiceLoader.create(ServiceLoader.load(SpanListener.class)).asList()); private final BraveTracer tracer; private final List> tags; - private final List spanLifeCycleListeners = new ArrayList<>(SPAN_LIFE_CYCLE_LISTENERS.get()); + private final List spanLifeCycleListeners = new ArrayList<>(SPAN_LIFE_CYCLE_LISTENERS.get()); /** * Create a zipkin tracer from the delegate (BraveTracer) and diff --git a/tracing/providers/zipkin/src/main/java/module-info.java b/tracing/providers/zipkin/src/main/java/module-info.java index f64c379b3b8..8742c5c752a 100644 --- a/tracing/providers/zipkin/src/main/java/module-info.java +++ b/tracing/providers/zipkin/src/main/java/module-info.java @@ -16,6 +16,7 @@ import io.helidon.common.features.api.Feature; import io.helidon.common.features.api.HelidonFlavor; +import io.helidon.tracing.SpanListener; /** * Zipkin tracing support. @@ -47,7 +48,7 @@ exports io.helidon.tracing.providers.zipkin; - uses io.helidon.tracing.SpanLifeCycleListener; + uses SpanListener; provides io.helidon.tracing.providers.opentracing.spi.OpenTracingProvider with io.helidon.tracing.providers.zipkin.ZipkinTracerProvider; diff --git a/tracing/tracing/src/main/java/io/helidon/tracing/NoOpTracer.java b/tracing/tracing/src/main/java/io/helidon/tracing/NoOpTracer.java index e86054fb14f..f636fd0364b 100644 --- a/tracing/tracing/src/main/java/io/helidon/tracing/NoOpTracer.java +++ b/tracing/tracing/src/main/java/io/helidon/tracing/NoOpTracer.java @@ -89,7 +89,7 @@ public T unwrap(Class tracerClass) { } @Override - public Tracer register(SpanLifeCycleListener listener) { + public Tracer register(SpanListener listener) { return this; } diff --git a/tracing/tracing/src/main/java/io/helidon/tracing/Scope.java b/tracing/tracing/src/main/java/io/helidon/tracing/Scope.java index b5011f6084a..931f22f4931 100644 --- a/tracing/tracing/src/main/java/io/helidon/tracing/Scope.java +++ b/tracing/tracing/src/main/java/io/helidon/tracing/Scope.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022, 2024 Oracle and/or its affiliates. + * Copyright (c) 2022 Oracle and/or its affiliates. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/tracing/tracing/src/main/java/io/helidon/tracing/SpanLifeCycleListener.java b/tracing/tracing/src/main/java/io/helidon/tracing/SpanListener.java similarity index 75% rename from tracing/tracing/src/main/java/io/helidon/tracing/SpanLifeCycleListener.java rename to tracing/tracing/src/main/java/io/helidon/tracing/SpanListener.java index d6377985ec6..9fdd5bd3094 100644 --- a/tracing/tracing/src/main/java/io/helidon/tracing/SpanLifeCycleListener.java +++ b/tracing/tracing/src/main/java/io/helidon/tracing/SpanListener.java @@ -16,12 +16,12 @@ package io.helidon.tracing; /** - * Behavior of listeners notified of span life cycle events. + * A listener notified of span life cycle events. *

- * The interface declares default empty implementations for each method, allowing concrete implementations of the - * interface to implement only the methods that are relevant for them. + * All methods are {@code default} no-op methods, allowing concrete implementations + * to implement only the methods that are relevant for them. *

- * Helidon invokes the applicable methods of a life cycle listener in the following order: + * Helidon invokes the applicable methods of a listener in the following order: * * * @@ -31,35 +31,35 @@ * * * - * + * * * * - * + * * * * - * + * * * * - * + * * * * - * + * * * * - * + * * * * * * *
Order of Invocation of Listener Methods
When invoked
{@linkplain #beforeStart(io.helidon.tracing.Span.Builder) beforeStart}{@linkplain #starting(io.helidon.tracing.Span.Builder) starting}Before a span is started from its builder.
{@linkplain #afterStart(io.helidon.tracing.Span) afterStart}{@linkplain #started(io.helidon.tracing.Span) started}After a span has started.
{@linkplain #afterActivate(io.helidon.tracing.Span, io.helidon.tracing.Scope) - * afterActivate} †{@linkplain #activated(io.helidon.tracing.Span, io.helidon.tracing.Scope) + * activated} †After a span has been activated, creating a new scope in the process.
{@linkplain #afterClose(io.helidon.tracing.Span, io.helidon.tracing.Scope) afterClose} †{@linkplain #closed(io.helidon.tracing.Span, io.helidon.tracing.Scope) closed} †After a scope has been closed.
{@linkplain #afterEnd(io.helidon.tracing.Span) afterEnd (successful)} *{@linkplain #ended(io.helidon.tracing.Span) ended (successful)} *After a span has ended successfully.
{@linkplain #afterEnd(io.helidon.tracing.Span, Throwable) afterEnd (unsuccessful)} *{@linkplain #ended(io.helidon.tracing.Span, Throwable) ended (unsuccessful)} *After a span has ended unsuccessfully.
† Not all spans are activated; it is up to the application or library code that creates and manages the span. - * As a result Helidon might not invoke your listener's {@code afterActivate} and {@code afterClose} methods for + * As a result Helidon might not invoke your listener's {@code activated} and {@code closed} methods for * every span. *

* * The successful or unsuccessful nature of a span's end is not about whether the tracing or telemetry @@ -72,10 +72,10 @@ *

* When Helidon invokes the listener methods it passes implementations of the key span types ({@link Span.Builder}, * {@link Span}, {@link io.helidon.tracing.Scope}) which do not support lifecycle state changes. - * If a lifecycle listener tries to start or end or activate a span, + * If a listener tries to start or end or activate a span, * for example, Helidon throws an {@link java.lang.UnsupportedOperationException}. */ -public interface SpanLifeCycleListener { +public interface SpanListener { /** * Invoked just prior to a {@linkplain io.helidon.tracing.Span span} being started from its @@ -84,7 +84,7 @@ public interface SpanLifeCycleListener { * @param spanBuilder the {@link Span.Builder} for the builder about to be used to start a span * @throws java.lang.UnsupportedOperationException if the listener tries to start the span */ - default void beforeStart(Span.Builder spanBuilder) throws UnsupportedOperationException { + default void starting(Span.Builder spanBuilder) { } /** @@ -93,7 +93,7 @@ default void beforeStart(Span.Builder spanBuilder) throws UnsupportedOperatio * @param span {@link io.helidon.tracing.Span} for the newly-started span * @throws java.lang.UnsupportedOperationException if the listener tries to end the span */ - default void afterStart(Span span) throws UnsupportedOperationException { + default void started(Span span) { } /** @@ -101,7 +101,7 @@ default void afterStart(Span span) throws UnsupportedOperationException { *

* Callers should normally catch the {@link io.helidon.tracing.UnsupportedActivationException}, retrieve the * {@link io.helidon.tracing.Scope} from it, and then close that {@code Scope}. - * Helidon activates the scope before invoking span life cycle listeners, so Helidon has added the span and baggage + * Helidon activates the scope before invoking span listeners, so Helidon has added the span and baggage * to the current tracing context by the time Helidon throws this exception. In the absence of this exception being * thrown, the {@link io.helidon.tracing.Span#activate()} method returns the {@code Scope} so the caller can close it. * But when Helidon throws this exception due to an error in a listener, the caller has no access to the {@code Scope} @@ -112,7 +112,7 @@ default void afterStart(Span span) throws UnsupportedOperationException { * the span * @throws io.helidon.tracing.UnsupportedActivationException if the listener tries to close the scope or end the span */ - default void afterActivate(Span span, Scope scope) throws UnsupportedActivationException { + default void activated(Span span, Scope scope) { } /** @@ -122,7 +122,7 @@ default void afterActivate(Span span, Scope scope) throws UnsupportedActivationE * @param scope the just-closed {@link io.helidon.tracing.Scope} * @throws java.lang.UnsupportedOperationException if the listener tries to end the span */ - default void afterClose(Span span, Scope scope) throws UnsupportedOperationException { + default void closed(Span span, Scope scope) { } /** @@ -130,7 +130,7 @@ default void afterClose(Span span, Scope scope) throws UnsupportedOperationExcep * * @param span the just-ended {@link io.helidon.tracing.Span} */ - default void afterEnd(Span span) { + default void ended(Span span) { } /** @@ -139,6 +139,6 @@ default void afterEnd(Span span) { * @param span the just-ended {@link io.helidon.tracing.Span} * @param t {@link java.lang.Throwable} indicating the problem associated with the ended span */ - default void afterEnd(Span span, Throwable t) { + default void ended(Span span, Throwable t) { } } diff --git a/tracing/tracing/src/main/java/io/helidon/tracing/Tracer.java b/tracing/tracing/src/main/java/io/helidon/tracing/Tracer.java index 16e4f4794c6..2be216432d9 100644 --- a/tracing/tracing/src/main/java/io/helidon/tracing/Tracer.java +++ b/tracing/tracing/src/main/java/io/helidon/tracing/Tracer.java @@ -106,8 +106,8 @@ default T unwrap(Class tracerClass) { * Registers with the tracer a life cycle event listener to receive events from span builders, spans, and scopes * derived from this tracer. * - * @param listener the {@link SpanLifeCycleListener} to register + * @param listener the {@link SpanListener} to register * @return the updated {@code Tracer} */ - Tracer register(SpanLifeCycleListener listener); + Tracer register(SpanListener listener); } diff --git a/tracing/tracing/src/main/java/io/helidon/tracing/UnsupportedActivationException.java b/tracing/tracing/src/main/java/io/helidon/tracing/UnsupportedActivationException.java index 5aa19bcfe9a..2d367400f12 100644 --- a/tracing/tracing/src/main/java/io/helidon/tracing/UnsupportedActivationException.java +++ b/tracing/tracing/src/main/java/io/helidon/tracing/UnsupportedActivationException.java @@ -17,7 +17,7 @@ /** * Indicates a failed attempt to activate a {@link io.helidon.tracing.Span} due to an error - * in a {@link io.helidon.tracing.SpanLifeCycleListener} callback. + * in a {@link SpanListener} callback. *

* Callers should normally catch this exception and then retrieve and close the {@link io.helidon.tracing.Scope}. * Helidon activates the scope before invoking span life cycle listeners, so the span and baggage have already diff --git a/tracing/tracing/src/main/java/module-info.java b/tracing/tracing/src/main/java/module-info.java index 30be9c3a438..53db015305b 100644 --- a/tracing/tracing/src/main/java/module-info.java +++ b/tracing/tracing/src/main/java/module-info.java @@ -16,7 +16,7 @@ import io.helidon.common.features.api.Feature; import io.helidon.common.features.api.HelidonFlavor; -import io.helidon.tracing.SpanLifeCycleListener; +import io.helidon.tracing.SpanListener; /** * Opentracing support for helidon, with an abstraction API and SPI for tracing collectors. @@ -41,6 +41,6 @@ exports io.helidon.tracing.spi; uses io.helidon.tracing.spi.TracerProvider; - uses SpanLifeCycleListener; + uses SpanListener; }