Abstract tracer implementations via an API (#1757)

Spring Cloud Sleuth currently is an autoconfiguration over Brave. It also consists of various instrumentation mechanisms for libraries that are not supported by Brave (e.g. Spring Cloud Circuitbreaker).

We would like to abstract Brave so that Spring Cloud Sleuth becomes an autoconfiguration for any tracer implementation that is compatible with Spring Cloud Sleuth. That way Spring Cloud Sleuth in its core module would consist of an API and various tracer implementations would implement that API which would also allow automatic instrumentation of libraries that are supported by Spring Cloud Sleuth.

## OpenTelemetry Support

Thanks to doing this abstraction we are able to support new tracer implementations, not only Brave. We've decided to add support for the OpenTelemetry SDK as the second one. If in the future if we decide to add new tracers then it will be just a matter of adding a new module that bridges to the Spring Cloud Sleuth one. Thanks to abstraction of tests as well we will be easily able to plug that tracer mechanism into our current suite of tests.

Author: marcingrzejszczak

README.adoc

@@ -68,6 +68,10 @@
 			<groupId>${project.groupId}</groupId>
 			<artifactId>spring-cloud-starter-sleuth</artifactId>
 		</dependency>
+		<dependency>
+			<groupId>${project.groupId}</groupId>
+			<artifactId>spring-cloud-starter-sleuth-otel</artifactId>
+		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-web</artifactId>

benchmarks/pom.xml

@@ -25,9 +25,6 @@
 
 import javax.annotation.PreDestroy;
 
-import brave.Span;
-import brave.Tracer;
-import brave.sampler.Sampler;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
@@ -41,6 +38,8 @@
 import org.springframework.cloud.sleuth.annotation.ContinueSpan;
 import org.springframework.cloud.sleuth.annotation.NewSpan;
 import org.springframework.cloud.sleuth.annotation.SpanTag;
+import org.springframework.cloud.sleuth.api.Span;
+import org.springframework.cloud.sleuth.api.Tracer;
 import org.springframework.cloud.sleuth.instrument.web.SkipPatternProvider;
 import org.springframework.context.ApplicationListener;
 import org.springframework.context.annotation.Bean;
@@ -121,11 +120,6 @@ public void clean() {
 		this.pool.shutdownNow();
 	}
 
-	@Bean
-	Sampler alwaysSampler() {
-		return Sampler.ALWAYS_SAMPLE;
-	}
-
 	@Bean
 	AnotherClass anotherClass() {
 		return new AnotherClass(this.tracer);
@@ -165,11 +159,11 @@ class AClass {
 
 	public String manualSpan() {
 		Span manual = this.tracer.nextSpan().name("span-name");
-		try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(manual.start())) {
+		try (Tracer.SpanInScope ws = this.tracer.withSpan(manual.start())) {
 			return this.anotherClass.continuedSpan();
 		}
 		finally {
-			manual.finish();
+			manual.end();
 		}
 	}
 
@@ -196,9 +190,9 @@ public String continuedAnnotation(@SpanTag("foo") String tagValue) {
 	public String continuedSpan() {
 		Span span = this.tracer.currentSpan();
 		span.tag("foo", "bar");
-		span.annotate("continuedspan.before");
+		span.event("continuedspan.before");
 		String response = "continued";
-		span.annotate("continuedspan.after");
+		span.event("continuedspan.after");
 		return response;
 	}
 

benchmarks/src/main/java/org/springframework/cloud/sleuth/benchmarks/app/mvc/SleuthBenchmarkingSpringApp.java

@@ -23,14 +23,14 @@
 import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 
-import brave.Tracing;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.core.scheduler.Scheduler;
 import reactor.core.scheduler.Schedulers;
 
+import org.springframework.beans.factory.BeanFactory;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
@@ -106,16 +106,16 @@ public Function<Message<String>, Message<String>> simpleFunctionWithAround() {
 
 	@Bean(name = "myFlux")
 	@ConditionalOnProperty(value = "spring.sleuth.function.type", havingValue = "simple_manual")
-	public Function<Message<String>, Message<String>> simpleManual(Tracing tracing) {
+	public Function<Message<String>, Message<String>> simpleManual(BeanFactory beanFactory) {
 		System.out.println("simple_manual_function");
-		return new SimpleManualFunction(tracing);
+		return new SimpleManualFunction(beanFactory);
 	}
 
 	@Bean(name = "myFlux")
 	@ConditionalOnProperty(value = "spring.sleuth.function.type", havingValue = "reactive_simple_manual")
-	public Function<Flux<Message<String>>, Flux<Message<String>>> reactiveSimpleManual(Tracing tracing) {
+	public Function<Flux<Message<String>>, Flux<Message<String>>> reactiveSimpleManual(BeanFactory beanFactory) {
 		System.out.println("simple_reactive_manual_function");
-		return new SimpleReactiveManualFunction(tracing);
+		return new SimpleReactiveManualFunction(beanFactory);
 	}
 
 	@Bean(name = "myFlux")
@@ -170,22 +170,22 @@ class SimpleManualFunction implements Function<Message<String>, Message<String>>
 
 	private static final Logger log = LoggerFactory.getLogger(SimpleFunction.class);
 
-	private final Tracing tracing;
+	private final BeanFactory beanFactory;
 
-	SimpleManualFunction(Tracing tracing) {
-		this.tracing = tracing;
+	SimpleManualFunction(BeanFactory beanFactory) {
+		this.beanFactory = beanFactory;
 	}
 
 	@Override
 	public Message<String> apply(Message<String> input) {
-		return (MessagingSleuthOperators.asFunction(this.tracing, input)
-				.andThen(msg -> MessagingSleuthOperators.withSpanInScope(this.tracing, msg, stringMessage -> {
+		return (MessagingSleuthOperators.asFunction(this.beanFactory, input)
+				.andThen(msg -> MessagingSleuthOperators.withSpanInScope(this.beanFactory, msg, stringMessage -> {
 					log.info("Hello from simple manual [{}]", stringMessage.getPayload());
 					return stringMessage;
-				})).andThen(msg -> MessagingSleuthOperators.afterMessageHandled(this.tracing, msg, null))
-				.andThen(msg -> MessagingSleuthOperators.handleOutputMessage(this.tracing, msg))
+				})).andThen(msg -> MessagingSleuthOperators.afterMessageHandled(this.beanFactory, msg, null))
+				.andThen(msg -> MessagingSleuthOperators.handleOutputMessage(this.beanFactory, msg))
 				.andThen(msg -> MessageBuilder.createMessage(msg.getPayload().toUpperCase(), msg.getHeaders()))
-				.andThen(msg -> MessagingSleuthOperators.afterMessageHandled(this.tracing, msg, null)).apply(input));
+				.andThen(msg -> MessagingSleuthOperators.afterMessageHandled(this.beanFactory, msg, null)).apply(input));
 	}
 
 }
@@ -207,21 +207,21 @@ class SimpleReactiveManualFunction implements Function<Flux<Message<String>>, Fl
 
 	private static final Logger log = LoggerFactory.getLogger(SimpleReactiveFunction.class);
 
-	private final Tracing tracing;
+	private final BeanFactory beanFactory;
 
-	SimpleReactiveManualFunction(Tracing tracing) {
-		this.tracing = tracing;
+	SimpleReactiveManualFunction(BeanFactory beanFactory) {
+		this.beanFactory = beanFactory;
 	}
 
 	@Override
 	public Flux<Message<String>> apply(Flux<Message<String>> input) {
-		return input.map(message -> (MessagingSleuthOperators.asFunction(this.tracing, message))
-				.andThen(msg -> MessagingSleuthOperators.withSpanInScope(this.tracing, msg, stringMessage -> {
+		return input.map(message -> (MessagingSleuthOperators.asFunction(this.beanFactory, message))
+				.andThen(msg -> MessagingSleuthOperators.withSpanInScope(this.beanFactory, msg, stringMessage -> {
 					log.info("Hello from simple manual [{}]", stringMessage.getPayload());
 					return stringMessage;
-				})).andThen(msg -> MessagingSleuthOperators.afterMessageHandled(this.tracing, msg, null))
+				})).andThen(msg -> MessagingSleuthOperators.afterMessageHandled(this.beanFactory, msg, null))
 				.andThen(msg -> MessageBuilder.createMessage(msg.getPayload().toUpperCase(), msg.getHeaders()))
-				.andThen(msg -> MessagingSleuthOperators.handleOutputMessage(this.tracing, msg)).apply(message));
+				.andThen(msg -> MessagingSleuthOperators.handleOutputMessage(this.beanFactory, msg)).apply(message));
 	}
 
 }

benchmarks/src/main/java/org/springframework/cloud/sleuth/benchmarks/app/stream/SleuthBenchmarkingStreamApplication.java

@@ -20,9 +20,6 @@
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
-import brave.handler.SpanHandler;
-import brave.propagation.TraceContext;
-import brave.sampler.Sampler;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import reactor.core.publisher.Flux;
@@ -37,6 +34,7 @@
 import org.springframework.boot.builder.SpringApplicationBuilder;
 import org.springframework.boot.web.embedded.netty.NettyReactiveWebServerFactory;
 import org.springframework.boot.web.reactive.context.ReactiveWebServerInitializedEvent;
+import org.springframework.cloud.sleuth.api.TraceContext;
 import org.springframework.cloud.sleuth.instrument.web.SkipPatternProvider;
 import org.springframework.cloud.sleuth.instrument.web.WebFluxSleuthOperators;
 import org.springframework.context.ApplicationListener;
@@ -73,11 +71,6 @@ public Mono<String> foo() {
 		return Mono.just("foo");
 	}
 
-	@Bean
-	Sampler alwaysSampler() {
-		return Sampler.ALWAYS_SAMPLE;
-	}
-
 	@Bean
 	SkipPatternProvider patternProvider() {
 		return () -> Pattern.compile("");
@@ -89,13 +82,6 @@ NettyReactiveWebServerFactory nettyReactiveWebServerFactory(@Value("${server.por
 		return new NettyReactiveWebServerFactory(serverPort == 0 ? SocketUtils.findAvailableTcpPort() : serverPort);
 	}
 
-	@Bean
-	public SpanHandler spanHandler() {
-		return new SpanHandler() {
-			// intentionally anonymous to prevent logging fallback on NOOP
-		};
-	}
-
 	@Override
 	public void onApplicationEvent(ReactiveWebServerInitializedEvent event) {
 		this.port = event.getWebServer().getPort();
@@ -135,7 +121,7 @@ public Mono<String> complex() {
 					log.info("Doing assertions");
 					TraceContext traceContext = signal.getContext().get(TraceContext.class);
 					Assert.notNull(traceContext, "Context must be set by Sleuth instrumentation");
-					Assert.state(traceContext.traceIdString().equals("4883117762eb9420"), "TraceId must be propagated");
+					Assert.state(traceContext.traceId().equals("4883117762eb9420"), "TraceId must be propagated");
 					log.info("Assertions passed");
 				});
 	}
@@ -151,7 +137,7 @@ public Mono<String> complexManual() {
 					WebFluxSleuthOperators.withSpanInScope(signal.getContext(), () -> log.info("Doing assertions"));
 					TraceContext traceContext = signal.getContext().get(TraceContext.class);
 					Assert.notNull(traceContext, "Context must be set by Sleuth instrumentation");
-					Assert.state(traceContext.traceIdString().equals("4883117762eb9420"), "TraceId must be propagated");
+					Assert.state(traceContext.traceId().equals("4883117762eb9420"), "TraceId must be propagated");
 					log.info("Assertions passed");
 				});
 	}

benchmarks/src/main/java/org/springframework/cloud/sleuth/benchmarks/app/webflux/SleuthBenchmarkingSpringWebFluxApp.java

@@ -96,6 +96,7 @@ protected ConfigurableApplicationContext initContext() {
 		protected String[] runArgs() {
 			List<String> strings = new ArrayList<>();
 			strings.addAll(Arrays.asList("--spring.jmx.enabled=false",
+					"--spring.autoconfigure.exclude=org.springframework.cloud.sleuth.otel.autoconfig.TraceOtelAutoConfiguration",
 					"--spring.application.name=defaultTraceContextForStream" + instrumentation.name()));
 			strings.addAll(instrumentation.entires.stream().map(s -> "--" + s).collect(Collectors.toList()));
 			return strings.toArray(new String[0]);
@@ -151,7 +152,7 @@ public enum Instrumentation {
 
 	}
 
-	@Configuration
+	@Configuration(proxyBeanMethods = false)
 	@Import(TestChannelBinderConfiguration.class)
 	static class TestConfiguration {
 

benchmarks/src/test/java/org/springframework/cloud/sleuth/benchmarks/jmh/SampleTests.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2016-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cloud.sleuth.benchmarks.jmh;
+
+import org.springframework.cloud.sleuth.brave.autoconfig.TraceBraveAutoConfiguration;
+import org.springframework.cloud.sleuth.otel.autoconfig.TraceOtelAutoConfiguration;
+
+public enum TracerImplementation {
+
+	otel(TraceBraveAutoConfiguration.class.getCanonicalName()), brave(
+			TraceOtelAutoConfiguration.class.getCanonicalName());
+
+	private String key = "spring.autoconfigure.exclude";
+
+	private String value;
+
+	TracerImplementation(String value) {
+		this.value = value;
+	}
+
+	public String property() {
+		return "--" + this.key + "=" + this.value;
+	}
+
+	@Override
+	public String toString() {
+		return this.name();
+	}
+
+}