More move from core (#15)

* moved OpenTracingInvocationInstrumenterSpec from core

* add bom

settings.gradle

@@ -11,6 +11,7 @@ plugins {
 
 rootProject.name = 'micronaut-tracing'
 
+include 'tracing-bom'
 include 'tracing-core'
 include 'tracing-jaeger'
 include 'tracing-zipkin'

src/main/docs/guide/jaeger.adoc

@@ -74,12 +74,12 @@ tracing:
 
 You can also optionally dependency-inject common configuration classes into api:tracing.jaeger.JaegerConfiguration[] such as `io.jaegertracing.Configuration.SamplerConfiguration` just by defining them as beans. See the API for api:tracing.jaeger.JaegerConfiguration[] for available injection points.
 
-== Filtering http spans
+== Filtering HTTP spans
 
-It may be useful to exclude health-checks and other http requests to your service.
+It may be useful to exclude health-checks and other HTTP requests to your service.
 This can be achieved by adding a list of regular expression patterns to your configuration:
 
-.Filtering http request spans
+.Filtering HTTP request spans
 [source,yaml]
 ----
 tracing:

src/main/docs/guide/zipkin.adoc

@@ -88,12 +88,12 @@ tracing:
 
 You can also optionally dependency-inject common configuration classes into api:tracing.brave.BraveTracerConfiguration[] such as `brave.sampler.Sampler` just by defining them as beans. See the API for api:tracing.brave.BraveTracerConfiguration[] for available injection points.
 
-== Filtering http spans
+== Filtering HTTP spans
 
-It may be useful to exclude health-checks and other http requests to your service.
+It may be useful to exclude health-checks and other HTTP requests to your service.
 This can be achieved by adding a list of regular expression patterns to your configuration:
 
-.Filtering http request spans
+.Filtering HTTP request spans
 [source,yaml]
 ----
 tracing:

tracing-bom/build.gradle

@@ -0,0 +1,3 @@
+plugins {
+    id 'io.micronaut.build.internal.bom'
+}

tracing-core/src/main/java/io/micronaut/tracing/instrument/http/AbstractOpenTracingFilter.java

@@ -65,12 +65,14 @@ public AbstractOpenTracingFilter(Tracer tracer) {
     }
 
     /**
-     * Configure tracer in the filter for span creation and propagation across arbitrary transports.
+     * Configure tracer in the filter for span creation and propagation across
+     * arbitrary transports.
      *
-     * @param tracer           the tracer
-     * @param pathExclusionTest the predicate for excluding URI paths from tracing.
+     * @param tracer            the tracer
+     * @param pathExclusionTest the predicate for excluding URI paths from tracing
      */
-    public AbstractOpenTracingFilter(Tracer tracer, @Nullable Predicate<String> pathExclusionTest) {
+    public AbstractOpenTracingFilter(Tracer tracer,
+                                     @Nullable Predicate<String> pathExclusionTest) {
         this.tracer = tracer;
         this.pathExclusionTest = pathExclusionTest;
     }
@@ -147,8 +149,8 @@ protected SpanBuilder newSpan(HttpRequest<?> request, SpanContext spanContext) {
     /**
      * Tests if the defined path should be excluded from tracing.
      *
-     * @param path the path to test.
-     * @return {@code true} if the path should be excluded, {@code false} otherwise.
+     * @param path the path to test
+     * @return {@code true} if the path should be excluded
      */
     protected boolean shouldExclude(@Nullable String path) {
         return pathExclusionTest != null && path != null && pathExclusionTest.test(path);

tracing-core/src/main/java/io/micronaut/tracing/instrument/http/OpenTracingClientFilter.java

@@ -59,12 +59,13 @@ public OpenTracingClientFilter(Tracer tracer) {
     /**
      * Initialize the open tracing client filter with tracer and exclusion configuration.
      *
-     * @param tracer the tracer for span creation and configuring across arbitrary transports
-     * @param exclusionsConfiguration The {@link TracingExclusionsConfiguration}
+     * @param tracer           the tracer for span creation and configuring across arbitrary transports
+     * @param exclusionsConfig The {@link TracingExclusionsConfiguration}
      */
     @Inject
-    public OpenTracingClientFilter(Tracer tracer, @Nullable TracingExclusionsConfiguration exclusionsConfiguration) {
-        super(tracer, exclusionsConfiguration == null ? null : exclusionsConfiguration.exclusionTest());
+    public OpenTracingClientFilter(Tracer tracer,
+                                   @Nullable TracingExclusionsConfiguration exclusionsConfig) {
+        super(tracer, exclusionsConfig == null ? null : exclusionsConfig.exclusionTest());
     }
 
     @SuppressWarnings("unchecked")

tracing-core/src/main/java/io/micronaut/tracing/instrument/http/OpenTracingServerFilter.java

@@ -65,12 +65,13 @@ public OpenTracingServerFilter(Tracer tracer) {
     /**
      * Creates an HTTP server instrumentation filter.
      *
-     * @param tracer for span creation and propagation across transport
-     * @param exclusionsConfiguration The {@link TracingExclusionsConfiguration}
+     * @param tracer           for span creation and propagation across transport
+     * @param exclusionsConfig The {@link TracingExclusionsConfiguration}
      */
     @Inject
-    public OpenTracingServerFilter(Tracer tracer, @Nullable TracingExclusionsConfiguration exclusionsConfiguration) {
-        super(tracer, exclusionsConfiguration == null ? null : exclusionsConfiguration.exclusionTest());
+    public OpenTracingServerFilter(Tracer tracer,
+                                   @Nullable TracingExclusionsConfiguration exclusionsConfig) {
+        super(tracer, exclusionsConfig == null ? null : exclusionsConfig.exclusionTest());
     }
 
     @SuppressWarnings("unchecked")

tracing-core/src/main/java/io/micronaut/tracing/instrument/http/TracingExclusionsConfiguration.java

@@ -25,25 +25,28 @@
 import java.util.stream.Collectors;
 
 /**
- * @since 3.3.0
+ * @since 4.0
  */
 @ConfigurationProperties(TracingExclusionsConfiguration.PREFIX)
 public class TracingExclusionsConfiguration {
 
     public static final String PREFIX = "tracing";
+
     private List<String> exclusions;
 
     /**
-     * @return The URI patterns to exclude from the tracing.
+     * @return the URI patterns to exclude from the tracing
      */
-    @Nullable public List<String> getExclusions() {
+    @Nullable
+    public List<String> getExclusions() {
         return exclusions;
     }
 
     /**
      * Sets the URI patterns to be excluded from tracing.
      *
-     * @param exclusions A list of regular expression patterns to be excluded from tracing if the request URI matches.
+     * @param exclusions regular expression patterns to be excluded from
+     *                   tracing if the request URI matches
      *
      * @see Pattern#compile(String)
      */
@@ -52,15 +55,19 @@ public void setExclusions(@Nullable List<String> exclusions) {
     }
 
     /**
-     * @return Either null (implying everything should be included), or a Predicate which when given a URL path returns
-     *         whether that path should be excluded from tracing.
+     * @return null (implying everything should be included), or a Predicate
+     *         which, when given a URL path, returns whether that path should
+     *         be excluded from tracing.
      */
-    @Nullable public Predicate<String> exclusionTest() {
+    @Nullable
+    public Predicate<String> exclusionTest() {
         if (CollectionUtils.isEmpty(exclusions)) {
             return null;
-        } else {
-            List<Pattern> patterns = exclusions.stream().map(Pattern::compile).collect(Collectors.toList());
-            return uri -> patterns.stream().anyMatch(pattern -> pattern.matcher(uri).matches());
         }
+
+        List<Pattern> patterns = exclusions.stream()
+            .map(Pattern::compile)
+            .collect(Collectors.toList());
+        return uri -> patterns.stream().anyMatch(pattern -> pattern.matcher(uri).matches());
     }
 }

tracing-core/src/test/groovy/io/micronaut/tracing/instrument/http/TracingExclusionsConfigurationSpec.groovy

@@ -20,7 +20,7 @@ class TracingExclusionsConfigurationSpec extends Specification {
     Predicate<String> pathPredicate = configuration.exclusionTest()
 
     @Unroll
-    def "path #path is #desc by predicate"() {
+    void 'path #path is #desc by predicate'() {
         expect:
         pathPredicate.test(path) == excluded
 

tracing-jaeger/src/test/groovy/io/micronaut/tracing/jaeger/OpenTracingInvocationInstrumenterSpec.groovy

@@ -0,0 +1,42 @@
+package io.micronaut.tracing.jaeger
+
+import io.micronaut.context.ApplicationContext
+import io.opentracing.Scope
+import io.opentracing.Span
+import io.opentracing.Tracer
+import reactor.core.publisher.Flux
+import reactor.core.publisher.Mono
+import spock.lang.Specification
+
+/**
+ * Regression test: when executing certain reactive operations the ScopeManager's internal state can become permanently
+ * corrupted resulting in incorrect tracing.
+ *
+ * @author lgathy
+ */
+class OpenTracingInvocationInstrumenterSpec extends Specification {
+
+    void "test regression of corrupted ScopeManager state"() {
+        given: 'Jaeger tracer is enabled'
+        ApplicationContext context = ApplicationContext.run('tracing.jaeger.enabled': true)
+        Tracer tracer = context.getBean(Tracer)
+        String[] words = ['one', 'two', 'three']
+
+        expect: 'no active span'
+        tracer.activeSpan() == null
+
+        when: 'reactive operations are executed inside a span'
+        Span rootSpan = tracer.buildSpan('root').start()
+        Scope scope = tracer.activateSpan(rootSpan)
+        String combined = Flux
+                .merge(words.collect { Mono.just(it).flux() })
+                .reduce { a, b -> "$a, $b" }
+                .block()
+        scope.close()
+        rootSpan.finish()
+
+        then: 'there should be no active span after it was finished'
+        combined.split(", ").sort() == words.sort()
+        tracer.activeSpan() == null
+    }
+}