Add documentation for spring starters
MODIFY
instrumentation-core/spring/README.md
instrumentation-core/spring/README.md
@@ -8,9 +8,9 @@ The [first section](#manual-instrumentation-with-java-sdk) will walk you through
The [second section](#manual-instrumentation-using-handlers-and-filters) will build on the first. It will walk you through implementing spring-web handler and filter interfaces to create traces with minimal changes to existing application code. Using the OpenTelemetry API, this approach involves copy and pasting files and a significant amount of manual configurations.
-The third section will walk you through the annotations and configurations defined in the opentelemetry-instrumentation-spring package. This section will equip you with new tools to streamline the setup and instrumentation of OpenTelemetry on Spring and Spring Boot applications. With these tools you will be able to setup distributed tracing with little to no changes to existing configurations and easily customize traces with minor additions to application code.
+The [third section](#auto-instrumentation-spring-starters) with build on the first two sections. We will use spring auto-configurations and instrumentation tools packaged in OpenTelemetry [Spring Starters](starters/) to streamline the set up of OpenTelemetry using Spring. With these tools you will be able to setup distributed tracing with little to no changes to existing configurations and easily customize traces with minor additions to application code.
-In this guide we will be using a running example. In section one and two, we will create two spring web services using Spring Boot. We will then trace the requests between these services using two different approaches. Finally, in section three we will explore tools in the opentelemetry-instrumentation-spring package which can improve this process.
+In this guide we will be using a running example. In section one and two, we will create two spring web services using Spring Boot. We will then trace requests between these services using two different approaches. Finally, in section three we will explore tools documented in [opentelemetry-spring-boot-autoconfigure](/spring-boot-autoconfigure/README.md#features) which can improve this process.
# Manual Instrumentation Guide
@@ -22,6 +22,10 @@ Using the [spring project initializer](https://start.spring.io/), we will create
Add the dependencies below to enable OpenTelemetry in `MainService` and `TimeService`. The Jaeger and LoggingExporter packages are recommended for exporting traces but are not required. As of May 2020, Jaeger, Zipkin, OTLP, and Logging exporters are supported by opentelemetry-java. Feel free to use whatever exporter you are most comfortable with.
+Replace `OPENTELEMETRY_VERSION` with the latest stable [release](https://search.maven.org/search?q=g:io.opentelemetry).
+ - Minimum version: `0.7.0`
+ - Note: You may need to include our bintray maven repository to your build file: `https://dl.bintray.com/open-telemetry/maven/`. As of August 2020 the latest opentelemetry-java-instrumentation artifacts are not published to maven-central. Please check the [releasing](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/master/RELEASING.md) doc for updates to this process.
+
### Maven
#### OpenTelemetry
@@ -29,27 +33,21 @@ Add the dependencies below to enable OpenTelemetry in `MainService` and `TimeSer
<dependency>
<groupId>io.opentelemetry</groupId>
<artifactId>opentelemetry-api</artifactId>
- <version>0.5.0</version>
+ <version>OPENTELEMETRY_VERSION</version>
</dependency>
<dependency>
<groupId>io.opentelemetry</groupId>
<artifactId>opentelemetry-sdk</artifactId>
- <version>0.5.0</version>
-</dependency>
-<dependency>
- <groupId>io.grpc</groupId>
- <artifactId>grpc-context</artifactId>
- <version>1.24.0</version>
+ <version>OPENTELEMETRY_VERSION</version>
</dependency>
-
```
-#### LoggingExporter
+#### LoggingSpanExporter
```xml
<dependency>
<groupId>io.opentelemetry</groupId>
<artifactId>opentelemetry-exporters-logging</artifactId>
- <version>0.5.0</version>
+ <version>OPENTELEMETRY_VERSION</version>
</dependency>
```
@@ -58,17 +56,12 @@ Add the dependencies below to enable OpenTelemetry in `MainService` and `TimeSer
<dependency>
<groupId>io.opentelemetry</groupId>
<artifactId>opentelemetry-exporters-jaeger</artifactId>
- <version>0.5.0</version>
-</dependency>
-<dependency>
- <groupId>io.grpc</groupId>
- <artifactId>grpc-protobuf</artifactId>
- <version>1.27.2</version>
+ <version>OPENTELEMETRY_VERSION</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-netty</artifactId>
- <version>1.27.2</version>
+ <version>1.30.2</version>
</dependency>
```
@@ -76,21 +69,19 @@ Add the dependencies below to enable OpenTelemetry in `MainService` and `TimeSer
#### OpenTelemetry
```gradle
-compile "io.opentelemetry:opentelemetry-api:0.5.0"
-compile "io.opentelemetry:opentelemetry-sdk:0.5.0"
-compile "io.grpc:grpc-context:1.24.0"
+implementation "io.opentelemetry:opentelemetry-api:OPENTELEMETRY_VERSION"
+implementation "io.opentelemetry:opentelemetry-sdk:OPENTELEMETRY_VERSION"
```
#### LoggingExporter
```gradle
-compile "io.opentelemetry:opentelemetry-exporters-logging:0.5.0"
+implementation "io.opentelemetry:opentelemetry-exporters-logging:OPENTELEMETRY_VERSION"
```
#### Jaeger Exporter
```gradle
-compile "io.opentelemetry:opentelemetry-exporters-jaeger:0.5.0"
-compile "io.grpc:grpc-protobuf:1.27.2"
-compile "io.grpc:grpc-netty:1.27.2"
+implementation "io.opentelemetry:opentelemetry-exporters-jaeger:OPENTELEMETRY_VERSION"
+compile "io.grpc:grpc-netty:1.30.2"
```
### Tracer Configuration
@@ -598,3 +589,10 @@ Run both the MainService and TimeService projects in terminal or using an IDE (e
To visualize this trace add a trace exporter to one or both of your applications. Instructions on how to setup LogExporter and Jaeger can be seen [above](#tracer-configuration).
To create a sample trace enter `localhost:8080/message` in a browser. This trace should include a span for MainService and a span for TimeService.
+
+
+
+## Auto Instrumentation: Spring Starters
+
+<!-- TODO: Add Tutorial -->
+

ADD
instrumentation-core/spring/spring-boot-autoconfigure/README.md
+# OpenTelemetry Spring Auto-Configuration
+
+Auto-configures OpenTelemetry instrumentation for [spring-web](../spring-web-3.1/), [spring-webmvc](../spring-webmvc-3.1/), and [spring-webflux](../spring-webflux-5.0/). Leverages Spring Aspect Oriented Programming, dependency injection, and bean post-processing to trace spring applications. To include all features listed below use the [opentelemetry-spring-starter](../starters/spring-starter/README.md).
+
+## Quickstart
+
+### Add these dependencies to your project.
+
+Replace `OPENTELEMETRY_VERSION` with the latest stable [release](https://search.maven.org/search?q=g:io.opentelemetry).
+ - Minimum version: `0.7.0`
+ - Note: You may need to include our bintray maven repository to your build file: `https://dl.bintray.com/open-telemetry/maven/`. As of August 2020 the latest opentelemetry-java-instrumentation artifacts are not published to maven-central. Please check the [releasing](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/master/RELEASING.md) doc for updates to this process.
+
+
+For Maven add to your `pom.xml`:
+
+```xml
+<dependencies>
+ <!-- opentelemetry -->
+ <dependency>
+ <groupId>io.opentelemetry.instrumentation</groupId>
+ <artifactId>opentelemetry-spring-boot-autoconfigure</artifactId>
+ <version>OPENTELEMETRY_VERSION</version>
+ </dependency>
+
+ <dependency>
+ <groupId>io.opentelemetry</groupId>
+ <artifactId>opentelemetry-api</artifactId>
+ <version>OPENTELEMETRY_VERSION</version>
+ </dependency>
+
+ <!-- simple span exporter -->
+ <!-- outputs spans to console -->
+ <!-- provides opentelemetry-sdk artifact -->
+ <dependency>
+ <groupId>io.opentelemetry</groupId>
+ <artifactId>opentelemetry-exporters-logging</artifactId>
+ <version>OPENTELEMETRY_VERSION</version>
+ </dependency>
+
+</dependencies>
+```
+
+For Gradle add to your dependencies:
+
+```groovy
+//opentelemetry spring auto-configuration
+implementation 'io.opentelemetry.instrumentation:opentelemetry-spring-boot-autoconfigure:OPENTELEMETRY_VERSION'
+//opentelemetry
+implementation 'io.opentelemetry:opentelemetry-api:OPENTELEMETRY_VERSION'
+//opentelemetry exporter
+implementation 'io.opentelemetry:opentelemetry-exporters-otlp:OPENTELEMETRY_VERSION'
+```
+
+### Features
+
+#### Dependencies
+
+The following dependencies are optional but are required to use the corresponding features.
+
+Replace `SPRING_VERSION` with the version of spring you're using.
+ - Minimum version: `3.1`
+
+Replace `SPRING_WEBFLUX_VERSION` with the version of spring-webflux you're using.
+ - Minimum version: `5.0`
+
+Replace `SLF4J_VERSION` with the version of slf4j you're using.
+
+For Maven add to your `pom.xml`:
+
+```xml
+<dependencies>
+ <!-- opentelemetry exporters-->
+ <dependency>
+ <groupId>io.opentelemetry</groupId>
+ <artifactId>opentelemetry-exporters-jaeger</artifactId>
+ <version>OPENTELEMETRY_VERSION</version>
+ </dependency>
+ <dependency>
+ <groupId>io.opentelemetry</groupId>
+ <artifactId>opentelemetry-exporters-zipkin</artifactId>
+ <version>OPENTELEMETRY_VERSION</version>
+ </dependency>
+ <dependency>
+ <groupId>io.opentelemetry</groupId>
+ <artifactId>opentelemetry-exporters-otlp</artifactId>
+ <version>OPENTELEMETRY_VERSION</version>
+ </dependency>
+
+ <!-- Used to autoconfigure spring-web -->
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-web</artifactId>
+ <version>SPRING_VERSION</version>
+ </dependency>
+
+ <!-- Used to autoconfigure spring-webmvc -->
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-webmvc</artifactId>
+ <version>SPRING_VERSION</version>
+ </dependency>
+
+ <!-- Used to autoconfigure spring-webflux -->
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-webflux</artifactId>
+ <version>SPRING_WEBFLUX_VERSION</version>
+ </dependency>
+
+ <!-- Used to enable instrumentation using @WithSpan -->
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-aop</artifactId>
+ <version>SPRING_VERSION</version>
+ </dependency>
+ <dependency>
+ <groupId>io.opentelemetry</groupId>
+ <artifactId>opentelemetry-extension-auto-annotations</artifactId>
+ <version>OPENTELEMETRY_VERSION</version>
+ </dependency>
+</dependencies>
+```
+
+For Gradle add to your dependencies:
+
+```groovy
+//opentelemetry exporter
+implementation 'io.opentelemetry:opentelemetry-exporters-jaeger:OPENTELEMETRY_VERSION'
+implementation 'io.opentelemetry:opentelemetry-exporters-zipkin:OPENTELEMETRY_VERSION'
+implementation 'io.opentelemetry:opentelemetry-exporters-otlp:OPENTELEMETRY_VERSION'
+
+//Used to autoconfigure spring-web
+implementation "org.springframework:spring-web:SPRING_VERSION"
+
+//Used to autoconfigure spring-webmvc
+implementation "org.springframework:spring-webmvc:SPRING_VERSION"
+
+//Used to autoconfigure spring-webflux
+implementation "org.springframework:spring-webflux:SPRING_WEBFLUX_VERSION"
+
+//Enables instrumentation using @WithSpan
+implementation "org.springframework:spring-aop:SPRING_VERSION"
+implementation "io.opentelemetry:opentelemetry-extension-auto-annotations:OPENTELEMETRY_VERSION"
+```
+
+#### OpenTelemetry Auto Configuration
+
+
+#### OpenTelemetry Tracer Auto Configuration
+
+Provides a OpenTelemetry tracer bean (`io.opentelemetry.trace.Tracer`) if one does not exist in the application context of the spring project. This tracer bean will be used in all configurations listed below. Feel free to declare your own Opentelemetry tracer bean to overwrite this configuration.
+
+#### Spring Web Auto Configuration
+
+Provides auto-configuration for the OpenTelemetry RestTemplate trace interceptor defined in [opentelemetry-spring-web-3.1](../spring-web-3.1/). This auto-configuration instruments all requests sent using Spring RestTemplate beans by applying a RestTemplate bean post processor. This feature is supported for spring web versions 3.1+ and can be disabled by adding `opentelemetry.trace.httpclients.enabled=false` to your `resources/applications.properties` file. [Spring Web - RestTemplate Client Span]('#spring-web-resttemplate-client-span') show cases a sample client span generated by this auto-configuration. Check out [opentelemetry-spring-web-3.1](../spring-web-3.1/) to learn more about the OpenTelemetry RestTemplateInterceptor.
+
+#### Spring Web MVC Auto Configuration
+
+This feature auto-configures instrumentation for spring-webmvc controllers by adding a [WebMvcTracingFilter](../spring-webmvc-3.1/src/main/java/io/opentelemetry/instrumentation/springwebmvc/WebMvcTracingFilter.java) bean to the application context. This request filter implements the [OncePerRequestFilter](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/filter/OncePerRequestFilter.html) interface to capture OpenTelemetry server spans and propagate distribute tracing context if provided in the request. [Spring Web MVC - Server Span]('#spring-web-mvc-server-span') show cases a sample span generated by the WebMvcTracingFilter. Check out [opentelemetry-spring-webmvc-3.1](../spring-webmvc-3.1/) to learn more about the OpenTelemetry WebMvcTracingFilter.
+
+#### Spring WebFlux Auto Configuration
+
+Provides auto-configurations for the OpenTelemtry WebClient ExchangeFilter defined in [opentelemetry-spring-webflux-5.0](../spring-webflux-5.0/). This auto-configuration instruments all outgoing http requests sent using Spring's WebClient and WebClient Builder beans by applying a bean post processor. This feature is supported for spring webflux versions 5.0+ and can be disabled by adding `opentelemetry.trace.httpclients.enabled=false` to your `resources/applications.properties` file. [Spring Web-Flux - WebClient Span]('#spring-web-flux-webclient-span') showcases a sample span generated by the WebClientFilter. Check out [opentelemetry-spring-webflux-5.0](../spring-webflux-5.0/) to learn more about the OpenTelemetry WebClientFilter.
+
+#### Manual Instrumentation Support - @WithSpan
+
+This feature uses spring-aop to wrap methods annotated with `@WithSpan` in a span.
+
+Note - This annotation can only be applied to bean methods managed by the spring application context. Check out [spring-aop](https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#aop) to learn more about aspect weaving in spring.
+
+##### Usage
+
+```java
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import io.opentelemetry.extensions.auto.annotations.WithSpan;
+import io.opentelemetry.trace.Span;
+import io.opentelemetry.trace.Tracer;
+
+/**
+ * Test WithSpan
+ *
+ */
+@Component
+public class TracedClass {
+
+ @Autowired
+ // Tracer bean is provided by spring-boot-autoconfigure
+ Tracer tracer;
+
+ @WithSpan
+ public void tracedMethod() {
+ }
+
+ @WithSpan(value="span name")
+ public void tracedMethodWithName() {
+ Span currentSpan = tracer.getCurrentSpan();
+ currentSpan.addEvent("ADD EVENT TO tracedMethodWithName SPAN");
+ currentSpan.setAttribute("isTestAttribute", true);
+ }
+
+ @WithSpan(kind=Span.Kind.CLIENT)
+ public void tracedClientSpan() {
+ }
+}
+
+```
+
+#### Sample Traces
+
+The traces below were exported using Zipkin.
+
+##### Spring Web MVC - Server Span
+```json
+ {
+ "traceId":"0371febbbfa76b2e285a08b53a055d17",
+ "id":"9b782243ad7df179",
+ "kind":"SERVER",
+ "name":"webmvctracingfilter.dofilterinteral",
+ "timestamp":1596841405866633,
+ "duration":355648,
+ "localEndpoint":{
+ "serviceName":"sample_trace",
+ "ipv4":"XXX.XXX.X.XXX"
+ },
+ "tags":{
+ "http.client_ip":"0:0:0:0:0:0:0:1",
+ "http.flavor":"HTTP/1.1",
+ "http.method":"GET",
+ "http.status_code":"200",
+ "http.url":"/spring-webmvc/sample",
+ "http.user_agent":"PostmanRuntime/7.26.2",
+ "net.peer.ip":"0:0:0:0:0:0:0:1",
+ "net.peer.port":"33916",
+ "sampling.probability":"1.0"
+ }
+ }
+```
+
+##### Spring Web - RestTemplate Client Span
+
+```json
+ {
+ "traceId":"0371febbbfa76b2e285a08b53a055d17",
+ "parentId":"9b782243ad7df179",
+ "id":"43990118a8bdbdf5",
+ "kind":"CLIENT",
+ "name":"http get",
+ "timestamp":1596841405949825,
+ "duration":21288,
+ "localEndpoint":{
+ "serviceName":"sample_trace",
+ "ipv4":"XXX.XXX.X.XXX"
+ },
+ "tags":{
+ "http.method":"GET",
+ "http.status_code":"200",
+ "http.url":"/spring-web/sample/rest-template",
+ "net.peer.name":"localhost",
+ "net.peer.port":"8081"
+ }
+ }
+```
+
+##### Spring Web-Flux - WebClient Span
+
+```json
+ {
+ "traceId":"0371febbbfa76b2e285a08b53a055d17",
+ "parentId":"9b782243ad7df179",
+ "id":"1b14a2fc89d7a762",
+ "kind":"CLIENT",
+ "name":"http post",
+ "timestamp":1596841406109125,
+ "duration":25137,
+ "localEndpoint":{
+ "serviceName":"sample_trace",
+ "ipv4":"XXX.XXX.X.XXX"
+ },
+ "tags":{
+ "http.method":"POST",
+ "http.status_code":"200",
+ "http.url":"/spring-webflux/sample/web-client",
+ "net.peer.name":"localhost",
+ "net.peer.port":"8082"
+ }
+ }
+```
+
+##### @WithSpan Instrumentation
+
+```
+[
+ {
+ "traceId":"0371febbbfa76b2e285a08b53a055d17",
+ "parentId":"9b782243ad7df179",
+ "id":"c3ef24b9bff5901c",
+ "name":"tracedclass.withspanmethod",
+ "timestamp":1596841406165439,
+ "duration":6912,
+ "localEndpoint":{
+ "serviceName":"sample_trace",
+ "ipv4":"XXX.XXX.X.XXX"
+ },
+ "tags":{
+ "test.type":"@WithSpan annotation",
+ "test.case":'@WithSpan',
+ "test.hasEvent":'true',
+ }
+ },
+ {
+ "traceId":"0371febbbfa76b2e285a08b53a055d17",
+ "parentId":"9b782243ad7df179",
+ "id":"1a6cb395a8a33cc0",
+ "name":"@withspan set span name",
+ "timestamp":1596841406182759,
+ "duration":2187,
+ "localEndpoint":{
+ "serviceName":"sample_trace",
+ "ipv4":"XXX.XXX.X.XXX"
+ },
+ "annotations":[
+ {
+ "timestamp":1596841406182920,
+ "value":"ADD EVENT TO tracedMethodWithName SPAN"
+ }
+ ],
+ "tags":{
+ "test.type":"@WithSpan annotation",
+ "test.case":'@WithSpan(value="@withspan set span name")',
+ "test.hasEvent":'true',
+ }
+ },
+ {
+ "traceId":"0371febbbfa76b2e285a08b53a055d17",
+ "parentId":"9b782243ad7df179",
+ "id":"74dd19a8a9883f80",
+ "kind":"CLIENT",
+ "name":"tracedClientSpan",
+ "timestamp":1596841406194210,
+ "duration":130,
+ "localEndpoint":{
+ "serviceName":"sample_trace",
+ "ipv4":"XXX.XXX.X.XXX"
+ }
+ "tags":{
+ "test.type":"@WithSpan annotation",
+ "test.case":"@WithSpan(kind=Span.Kind.Client)",
+ }
+ },
+]
+```
+
+#### Spring Support
+
+Auto-configuration is natively supported by Springboot applications. To enable these features in "vanilla" use `@EnableOpenTelemetryTracing` to complete a component scan of this package.
+
+##### Usage
+
+```java
+import io.opentelemetry.instrumentation.spring.autoconfigure.EnableOpenTelemetryTracing
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@EnableOpenTelemetryTracing
+public class OpenTelemetryConfig {}
+```
+
+#### Exporter Configurations
+
+This package provides auto configurations for [OTLP](https://github.com/open-telemetry/opentelemetry-java/tree/master/exporters/otlp), [Jaeger](https://github.com/open-telemetry/opentelemetry-java/tree/master/exporters/jaeger), [Zipkin](https://github.com/open-telemetry/opentelemetry-java/tree/master/exporters/zipkin), and [Logging](https://github.com/open-telemetry/opentelemetry-java/tree/master/exporters/logging) Span Exporters.
+
+If an exporter is present in the classpath during runtime and a spring bean of the exporter is missing from the spring application context. An exporter bean is initialized and added to a simple span processor in the active tracer provider. Check out the implementation [here](/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/TracerAutoConfiguration.java).
+
+
+#### Configuration Properties
+
+##### Enabling/Disabling Features
+
+|Feature |Property |Default Value |ConditionalOnClass
+|--- |--- |--- |---
+|spring-web |opentelemetry.trace.httpclients.enabled |true |RestTemplate
+|spring-webmvc |opentelemetry.trace.httpclients.enabled |true |OncePerRequestFilter
+|spring-webflux |opentelemetry.trace.httpclients.enabled |true |WebClient
+|@WithSpan |opentelemetry.trace.aspects.enabled |true |WithSpan, Aspect
+|Otlp Exporter |opentelemetry.trace.exporters.otlp.enabled |true |OtlpGrpcSpanExporter
+|Jaeger Exporter |opentelemetry.trace.exporters.jaeger.enabled |true |JaegerGrpcSpanExporter
+|Zipkin Exporter |opentelemetry.trace.exporters.zipkin.enabled |true |ZipkinSpanExporter
+|Logging Exporter |opentelemetry.trace.exporters.logging.enabled |true |LoggingSpanExporter
+
+<!-- Slf4j Log Correlation opentelemetry.trace.loggers.slf4j.enabled true org.slf4j.MDC -->
+
+##### Exporter Properties
+
+|Feature |Property |Default Value
+|--- |--- |---
+|Otlp Exporter |opentelemetry.trace.exporters.otlp.servicename |unknown
+| |opentelemetry.trace.exporters.otlp.endpoint |localhost:55680
+| |opentelemetry.trace.exporters.otlp.spantimeout |1ms
+|Jaeger Exporter |opentelemetry.trace.exporters.jaeger.servicename |unknown
+| |opentelemetry.trace.exporters.jaeger.endpoint |localhost:14250
+| |opentelemetry.trace.exporters.jaeger.spantimeout |1ms
+|Zipkin Exporter |opentelemetry.trace.exporters.jaeger.servicename |unknown
+| |opentelemetry.trace.exporters.jaeger.endpoint |http://localhost:9411/api/v2/spans
+
+##### Tracer Properties
+
+|Feature |Property |Default Value
+|--- |--- |---
+|Tracer |opentelemetry.trace.tracer.name |otel-spring-tracer
+| |opentelemetry.trace.tracer.samplerprobability |1.0
+
+
+### Starter Guide
+
+Check out the opentelemetry [quick start](https://github.com/open-telemetry/opentelemetry-java/blob/master/QUICKSTART.md) to learn more about OpenTelemetry instrumentation.

MODIFY
instrumentation-core/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectTest.java
instrumentation-core/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectTest.java
@@ -27,8 +27,6 @@ import io.opentelemetry.extensions.auto.annotations.WithSpan;
import io.opentelemetry.trace.Span;
import io.opentelemetry.trace.Span.Kind;
import io.opentelemetry.trace.Tracer;
-import org.aspectj.lang.ProceedingJoinPoint;
-import org.aspectj.lang.reflect.MethodSignature;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
@@ -66,8 +64,6 @@ public class WithSpanAspectTest {
@Mock private Span span;
@Mock private Span.Builder spanBuilder;
@Mock private Scope scope;
- @Mock private ProceedingJoinPoint pjp;
- @Mock private MethodSignature signature;
private WithSpanTester withSpanTester;

ADD
instrumentation-core/spring/starters/jaeger-exporter-starter/README.md
+# OpenTelemetry Jaeger Exporter Starter
+
+The OpenTelemetry Jaeger Exporter Starter for Java is a starter package that includes packages required to enable tracing using OpenTelemetry. It also provides the [opentelemetry-exporters-jaeger](https://github.com/open-telemetry/opentelemetry-java/tree/master/exporters/jaeger) dependency and corresponding auto-configuration. Check out [opentelemetry-spring-boot-autoconfigure](../../spring-boot-autoconfigure/README.md#features) for the list of supported libraries and features.
+
+## Quickstart
+
+### Add these dependencies to your project.
+
+Replace `OPENTELEMETRY_VERSION` with the latest stable [release](https://search.maven.org/search?q=g:io.opentelemetry).
+ - Minimum version: `0.7.0`
+ - Note: You may need to include our bintray maven repository to your build file: `https://dl.bintray.com/open-telemetry/maven/`. As of August 2020 the latest opentelemetry-java-instrumentation artifacts are not published to maven-central. Please check the [releasing](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/master/RELEASING.md) doc for updates to this process.
+
+
+For Maven add to your `pom.xml`:
+
+```xml
+<dependencies>
+
+ <dependency>
+ <groupId>io.opentelemetry.instrumentation</groupId>
+ <artifactId>opentelemetry-jaeger-exporter-starter</artifactId>
+ <version>OPENTELEMETRY_VERSION</version>
+ </dependency>
+
+</dependencies>
+```
+
+For Gradle add to your dependencies:
+
+```groovy
+implementation 'io.opentelemetry.instrumentation:opentelemetry-jaeger-exporter-starter:OPENTELEMETRY_VERSION'
+```
+
+### Starter Guide
+
+Check out the opentelemetry-api [quick start](https://github.com/open-telemetry/opentelemetry-java/blob/master/QUICKSTART.md) to learn more about OpenTelemetry instrumentation.

ADD
instrumentation-core/spring/starters/otlp-exporter-starter/README.md
+# OpenTelemetry OTLP Exporter Starter
+
+The OpenTelemetry OTLP Exporter Starter for Java is a starter package that includes packages required to enable tracing using OpenTelemetry. It also provides the [opentelemetry-exporters-otlp](https://github.com/open-telemetry/opentelemetry-java/tree/master/exporters/otlp) dependency and corresponding auto-configuration. Check out [opentelemetry-spring-boot-autoconfigure](../../spring-boot-autoconfigure/README.md#features) for the list of supported libraries and features.
+
+## Quickstart
+
+### Add these dependencies to your project.
+
+Replace `OPENTELEMETRY_VERSION` with the latest stable [release](https://search.maven.org/search?q=g:io.opentelemetry).
+ - Minimum version: `0.7.0`
+ - Note: You may need to include our bintray maven repository to your build file: `https://dl.bintray.com/open-telemetry/maven/`. As of August 2020 the latest opentelemetry-java-instrumentation artifacts are not published to maven-central. Please check the [releasing](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/master/RELEASING.md) doc for updates to this process.
+
+
+For Maven add to your `pom.xml`:
+
+```xml
+<dependencies>
+
+ <dependency>
+ <groupId>io.opentelemetry.instrumentation</groupId>
+ <artifactId>opentelemetry-otlp-exporter-starter</artifactId>
+ <version>OPENTELEMETRY_VERSION</version>
+ </dependency>
+
+</dependencies>
+```
+
+For Gradle add to your dependencies:
+
+```groovy
+implementation 'io.opentelemetry.instrumentation:opentelemetry-otlp-exporter-starter:OPENTELEMETRY_VERSION'
+```
+
+### Starter Guide
+
+Check out the opentelemetry-api [quick start](https://github.com/open-telemetry/opentelemetry-java/blob/master/QUICKSTART.md) to learn more about OpenTelemetry instrumentation.

ADD
instrumentation-core/spring/starters/spring-starter/README.md
+# OpenTelemetry Spring Starter
+
+The OpenTelemetry Spring Starter for Java is a starter package that includes packages required to enable tracing using OpenTelemetry. Check out [opentelemetry-spring-boot-autoconfigure](../../spring-boot-autoconfigure/README.md#features) for the list of supported libraries and features.
+
+This version is compatible with Spring Boot 2.0.
+
+## Quickstart
+
+### Add these dependencies to your project.
+
+Replace `OPENTELEMETRY_VERSION` with the latest stable [release](https://search.maven.org/search?q=g:io.opentelemetry).
+ - Minimum version: `0.7.0`
+ - Note: You may need to include our bintray maven repository to your build file: `https://dl.bintray.com/open-telemetry/maven/`. As of August 2020 the latest opentelemetry-java-instrumentation artifacts are not published to maven-central. Please check the [releasing](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/master/RELEASING.md) doc for updates to this process.
+
+
+For Maven add to your `pom.xml`:
+
+```xml
+<dependencies>
+
+ <dependency>
+ <groupId>io.opentelemetry.instrumentation</groupId>
+ <artifactId>opentelemetry-spring-starter</artifactId>
+ <version>OPENTELEMETRY_VERSION</version>
+ </dependency>
+
+</dependencies>
+```
+
+For Gradle add to your dependencies:
+
+```groovy
+implementation 'io.opentelemetry.instrumentation:opentelemetry-spring-starter:OPENTELEMETRY_VERSION'
+```
+
+### Starter Guide
+
+Check out the opentelemetry-api [quick start](https://github.com/open-telemetry/opentelemetry-java/blob/master/QUICKSTART.md) to learn more about OpenTelemetry instrumentation.

ADD
instrumentation-core/spring/starters/zipkin-exporter-starter/README.md
+# OpenTelemetry Zipkin Exporter Starter
+
+The OpenTelemetry Zipkin Exporter Starter for Java is a starter package that includes packages required to enable tracing using OpenTelemetry. It also provides the [opentelemetry-exporters-zipkin](https://github.com/open-telemetry/opentelemetry-java/tree/master/exporters/zipkin) dependency and corresponding auto-configuration. Check out [opentelemetry-spring-boot-autoconfigure](../../spring-boot-autoconfigure/README.md#features) for the list of supported libraries and features.
+
+## Quickstart
+
+### Add these dependencies to your project.
+
+Replace `OPENTELEMETRY_VERSION` with the latest stable [release](https://search.maven.org/search?q=g:io.opentelemetry).
+ - Minimum version: `0.7.0`
+ - Note: You may need to include our bintray maven repository to your build file: `https://dl.bintray.com/open-telemetry/maven/`. As of August 2020 the latest opentelemetry-java-instrumentation artifacts are not published to maven-central. Please check the [releasing](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/master/RELEASING.md) doc for updates to this process.
+
+
+For Maven add to your `pom.xml`:
+
+```xml
+<dependencies>
+
+ <dependency>
+ <groupId>io.opentelemetry.instrumentation</groupId>
+ <artifactId>opentelemetry-zipkin-exporter-starter</artifactId>
+ <version>OPENTELEMETRY_VERSION</version>
+ </dependency>
+
+</dependencies>
+```
+
+For Gradle add to your dependencies:
+
+```groovy
+implementation 'io.opentelemetry.instrumentation:opentelemetry-zipkin-exporter-starter:OPENTELEMETRY_VERSION'
+```
+
+### Starter Guide
+
+Check out the opentelemetry-api [quick start](https://github.com/open-telemetry/opentelemetry-java/blob/master/QUICKSTART.md) to learn more about OpenTelemetry instrumentation.

Add documentation for spring starters  (#1035)