Add withParent option to annotation @WithSpan

Signed-off-by: xiepuhuan <[email protected]>

Author: xiepuhuan

docs/apidiffs/current_vs_latest/opentelemetry-instrumentation-annotations.txt

@@ -1,2 +1,4 @@
 Comparing source compatibility of opentelemetry-instrumentation-annotations-2.13.0-SNAPSHOT.jar against opentelemetry-instrumentation-annotations-2.12.0.jar
-No changes.
+**** MODIFIED ANNOTATION: PUBLIC ABSTRACT io.opentelemetry.instrumentation.annotations.WithSpan  (not serializable)
+	===  CLASS FILE FORMAT VERSION: 52.0 <- 52.0
+	+++* NEW METHOD: PUBLIC(+) ABSTRACT(+) boolean withParent()

instrumentation-annotations/src/main/java/io/opentelemetry/instrumentation/annotations/WithSpan.java

@@ -34,4 +34,7 @@
 
   /** Specify the {@link SpanKind} of span to be created. Defaults to {@link SpanKind#INTERNAL}. */
   SpanKind kind() default SpanKind.INTERNAL;
+
+  /** Specify whether to create a new span with parent. Defaults to {@code true}. */
+  boolean withParent() default true;
 }

instrumentation/opentelemetry-instrumentation-annotations-1.16/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/instrumentationannotations/AnnotationSingletons.java

@@ -9,7 +9,9 @@
 
 import application.io.opentelemetry.instrumentation.annotations.WithSpan;
 import io.opentelemetry.api.GlobalOpenTelemetry;
+import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.SpanKind;
+import io.opentelemetry.context.Context;
 import io.opentelemetry.instrumentation.api.annotation.support.MethodSpanAttributesExtractor;
 import io.opentelemetry.instrumentation.api.annotation.support.SpanAttributesExtractor;
 import io.opentelemetry.instrumentation.api.incubator.semconv.code.CodeAttributesExtractor;
@@ -47,6 +49,7 @@ private static Instrumenter<Method, Object> createInstrumenter() {
             INSTRUMENTATION_NAME,
             AnnotationSingletons::spanNameFromMethod)
         .addAttributesExtractor(CodeAttributesExtractor.create(MethodCodeAttributesGetter.INSTANCE))
+        .addContextCustomizer(AnnotationSingletons::parentContextFromMethod)
         .buildInstrumenter(AnnotationSingletons::spanKindFromMethod);
   }
 
@@ -62,6 +65,7 @@ private static Instrumenter<MethodRequest, Object> createInstrumenterWithAttribu
                 MethodRequest::method,
                 WithSpanParameterAttributeNamesExtractor.INSTANCE,
                 MethodRequest::args))
+        .addContextCustomizer(AnnotationSingletons::parentContextFromMethodRequest)
         .buildInstrumenter(AnnotationSingletons::spanKindFromMethodRequest);
   }
 
@@ -104,5 +108,20 @@ private static String spanNameFromMethod(Method method) {
     return spanName;
   }
 
+  private static Context parentContextFromMethodRequest(
+      Context context, MethodRequest request, Attributes attributes) {
+    return parentContextFromMethod(context, request.method(), attributes);
+  }
+
+  private static Context parentContextFromMethod(
+      Context context, Method method, Attributes attributes) {
+    WithSpan annotation = method.getDeclaredAnnotation(WithSpan.class);
+    if (annotation.withParent()) {
+      return context;
+    }
+
+    return Context.root();
+  }
+
   private AnnotationSingletons() {}
 }

instrumentation/opentelemetry-instrumentation-annotations-1.16/javaagent/src/test/java/io/opentelemetry/test/annotation/TracedWithSpan.java

@@ -57,4 +57,14 @@ public CompletionStage<String> completionStage(CompletableFuture<String> future)
   public CompletableFuture<String> completableFuture(CompletableFuture<String> future) {
     return future;
   }
+
+  @WithSpan(withParent = false)
+  public String withoutParent() {
+    return "hello!";
+  }
+
+  @WithSpan(kind = SpanKind.CONSUMER)
+  public String consumer() {
+    return withoutParent();
+  }
 }

instrumentation/opentelemetry-instrumentation-annotations-1.16/javaagent/src/test/java/io/opentelemetry/test/annotation/WithSpanInstrumentationTest.java

@@ -107,6 +107,31 @@ void multipleSpans() {
                             equalTo(CODE_FUNCTION, "otel"))));
   }
 
+  @Test
+  void multipleSpansWithoutParent() {
+    new TracedWithSpan().consumer();
+
+    testing.waitAndAssertTraces(
+        trace ->
+            trace.hasSpansSatisfyingExactly(
+                span ->
+                    span.hasName("TracedWithSpan.consumer")
+                        .hasKind(SpanKind.CONSUMER)
+                        .hasNoParent()
+                        .hasAttributesSatisfyingExactly(
+                            equalTo(CODE_NAMESPACE, TracedWithSpan.class.getName()),
+                            equalTo(CODE_FUNCTION, "consumer"))),
+        trace ->
+            trace.hasSpansSatisfyingExactly(
+                span ->
+                    span.hasName("TracedWithSpan.withoutParent")
+                        .hasKind(SpanKind.INTERNAL)
+                        .hasNoParent()
+                        .hasAttributesSatisfyingExactly(
+                            equalTo(CODE_NAMESPACE, TracedWithSpan.class.getName()),
+                            equalTo(CODE_FUNCTION, "withoutParent"))));
+  }
+
   @Test
   void excludedMethod() throws Exception {
     new TracedWithSpan().ignored();

instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/annotations/JoinPointRequest.java

@@ -18,8 +18,10 @@ final class JoinPointRequest {
   private final Method method;
   private final String spanName;
   private final SpanKind spanKind;
+  private final boolean withParent;
 
-  private JoinPointRequest(JoinPoint joinPoint, Method method, String spanName, SpanKind spanKind) {
+  private JoinPointRequest(
+      JoinPoint joinPoint, Method method, String spanName, SpanKind spanKind, boolean withParent) {
     if (spanName.isEmpty()) {
       spanName = SpanNames.fromMethod(method);
     }
@@ -28,6 +30,7 @@ private JoinPointRequest(JoinPoint joinPoint, Method method, String spanName, Sp
     this.method = method;
     this.spanName = spanName;
     this.spanKind = spanKind;
+    this.withParent = withParent;
   }
 
   String spanName() {
@@ -46,6 +49,10 @@ Object[] args() {
     return joinPoint.getArgs();
   }
 
+  boolean withParent() {
+    return withParent;
+  }
+
   interface Factory {
 
     JoinPointRequest create(JoinPoint joinPoint);
@@ -65,8 +72,9 @@ public JoinPointRequest create(JoinPoint joinPoint) {
       WithSpan annotation = method.getDeclaredAnnotation(WithSpan.class);
       String spanName = annotation != null ? annotation.value() : "";
       SpanKind spanKind = annotation != null ? annotation.kind() : SpanKind.INTERNAL;
+      boolean withParent = annotation == null || annotation.withParent();
 
-      return new JoinPointRequest(joinPoint, method, spanName, spanKind);
+      return new JoinPointRequest(joinPoint, method, spanName, spanKind, withParent);
     }
   }
 }

instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/annotations/WithSpanAspect.java

@@ -6,6 +6,7 @@
 package io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.annotations;
 
 import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.Span;
 import io.opentelemetry.context.Context;
 import io.opentelemetry.context.Scope;
@@ -53,10 +54,19 @@ abstract class WithSpanAspect {
                     JoinPointRequest::method,
                     parameterAttributeNamesExtractor,
                     JoinPointRequest::args))
+            .addContextCustomizer(WithSpanAspect::parentContext)
             .buildInstrumenter(JoinPointRequest::spanKind);
     this.requestFactory = requestFactory;
   }
 
+  static Context parentContext(Context parentContext, JoinPointRequest request, Attributes unused) {
+    if (request.withParent()) {
+      return parentContext;
+    }
+
+    return Context.root();
+  }
+
   public Object traceMethod(ProceedingJoinPoint pjp) throws Throwable {
     JoinPointRequest request = requestFactory.create(pjp);
     Context parentContext = Context.current();

instrumentation/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/annotations/InstrumentationWithSpanAspectTest.java

@@ -180,6 +180,27 @@ void withSpanAttributes() {
                             equalTo(stringKey("explicitName"), "baz"))));
   }
 
+  @Test
+  @DisplayName(
+      "when method is annotated with @WithSpan(withParent=false) should build span without parent")
+  void withSpanWithoutParent() {
+    // when
+    testing.runWithSpan("parent", withSpanTester::testWithoutParentSpan);
+
+    // then
+    testing.waitAndAssertTraces(
+        trace -> trace.hasSpansSatisfyingExactly(span -> span.hasName("parent").hasKind(INTERNAL)),
+        trace ->
+            trace.hasSpansSatisfyingExactly(
+                span ->
+                    span.hasName(unproxiedTesterSimpleClassName + ".testWithoutParentSpan")
+                        .hasKind(INTERNAL)
+                        .hasNoParent()
+                        .hasAttributesSatisfyingExactly(
+                            equalTo(CODE_NAMESPACE, unproxiedTesterClassName),
+                            equalTo(CODE_FUNCTION, "testWithoutParentSpan"))));
+  }
+
   static class InstrumentationWithSpanTester {
     @WithSpan
     public String testWithSpan() {
@@ -221,6 +242,11 @@ public String withSpanAttributes(
 
       return "hello!";
     }
+
+    @WithSpan(withParent = false)
+    public String testWithoutParentSpan() {
+      return "Span without parent span was created";
+    }
   }
 
   @Nested