Add @WithSpan option to break from existing context

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

@@ -6,6 +6,7 @@
 package io.opentelemetry.instrumentation.annotations;
 
 import io.opentelemetry.api.trace.SpanKind;
+import io.opentelemetry.context.Context;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -34,4 +35,15 @@
 
   /** Specify the {@link SpanKind} of span to be created. Defaults to {@link SpanKind#INTERNAL}. */
   SpanKind kind() default SpanKind.INTERNAL;
+
+  /**
+   * Specifies whether to use the current context as the parent when creating a Span.
+   *
+   * <p>If set to {@code true} (default), the created span will use the current context as its
+   * parent, remaining within the same trace.
+   *
+   * <p>If set to {@code false}, the created span will use {@link Context#root()} as its parent,
+   * starting a new, independent trace.
+   */
+  boolean withParent() default true;
 }

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

@@ -9,12 +9,17 @@
 
 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;
 import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter;
 import io.opentelemetry.instrumentation.api.semconv.util.SpanNames;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
 import java.lang.reflect.Method;
 import java.util.logging.Logger;
 
@@ -29,6 +34,21 @@ public final class AnnotationSingletons {
       createInstrumenterWithAttributes();
   private static final SpanAttributesExtractor ATTRIBUTES = createAttributesExtractor();
 
+  // The reason for using reflection here is that it needs to be compatible with the old version of
+  // @WithSpan annotation that does not include the withParent option to avoid failing the muzzle
+  // check.
+  private static MethodHandle withParentMethodHandle = null;
+
+  static {
+    try {
+      withParentMethodHandle =
+          MethodHandles.publicLookup()
+              .findVirtual(WithSpan.class, "withParent", MethodType.methodType(boolean.class));
+    } catch (NoSuchMethodException | IllegalAccessException ignore) {
+      // ignore
+    }
+  }
+
   public static Instrumenter<Method, Object> instrumenter() {
     return INSTRUMENTER;
   }
@@ -47,6 +67,7 @@ private static Instrumenter<Method, Object> createInstrumenter() {
             INSTRUMENTATION_NAME,
             AnnotationSingletons::spanNameFromMethod)
         .addAttributesExtractor(CodeAttributesExtractor.create(MethodCodeAttributesGetter.INSTANCE))
+        .addContextCustomizer(AnnotationSingletons::parentContextFromMethod)
         .buildInstrumenter(AnnotationSingletons::spanKindFromMethod);
   }
 
@@ -62,6 +83,7 @@ private static Instrumenter<MethodRequest, Object> createInstrumenterWithAttribu
                 MethodRequest::method,
                 WithSpanParameterAttributeNamesExtractor.INSTANCE,
                 MethodRequest::args))
+        .addContextCustomizer(AnnotationSingletons::parentContextFromMethodRequest)
         .buildInstrumenter(AnnotationSingletons::spanKindFromMethodRequest);
   }
 
@@ -104,5 +126,28 @@ 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) {
+    if (withParentMethodHandle == null) {
+      return context;
+    }
+
+    WithSpan annotation = method.getDeclaredAnnotation(WithSpan.class);
+
+    boolean withParent = true;
+    try {
+      withParent = (boolean) withParentMethodHandle.invoke(annotation);
+    } catch (Throwable ignore) {
+      // ignore
+    }
+
+    return withParent ? context : 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

@@ -8,7 +8,11 @@
 import io.opentelemetry.api.trace.SpanKind;
 import io.opentelemetry.instrumentation.annotations.WithSpan;
 import io.opentelemetry.instrumentation.api.semconv.util.SpanNames;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
 import java.lang.reflect.Method;
+import javax.annotation.Nullable;
 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.reflect.MethodSignature;
 
@@ -18,8 +22,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 +34,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,13 +53,32 @@ Object[] args() {
     return joinPoint.getArgs();
   }
 
+  boolean withParent() {
+    return withParent;
+  }
+
   interface Factory {
 
     JoinPointRequest create(JoinPoint joinPoint);
   }
 
   static final class InstrumentationAnnotationFactory implements Factory {
 
+    // The reason for using reflection here is that it needs to be compatible with the old version
+    // of @WithSpan annotation that does not include the withParent option to avoid failing the
+    // muzzle check.
+    private static MethodHandle withParentMethodHandle = null;
+
+    static {
+      try {
+        withParentMethodHandle =
+            MethodHandles.publicLookup()
+                .findVirtual(WithSpan.class, "withParent", MethodType.methodType(boolean.class));
+      } catch (NoSuchMethodException | IllegalAccessException ignore) {
+        // ignore
+      }
+    }
+
     @Override
     public JoinPointRequest create(JoinPoint joinPoint) {
       MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
@@ -66,7 +92,20 @@ public JoinPointRequest create(JoinPoint joinPoint) {
       String spanName = annotation != null ? annotation.value() : "";
       SpanKind spanKind = annotation != null ? annotation.kind() : SpanKind.INTERNAL;
 
-      return new JoinPointRequest(joinPoint, method, spanName, spanKind);
+      return new JoinPointRequest(
+          joinPoint, method, spanName, spanKind, withParentValueFrom(annotation));
+    }
+
+    private static boolean withParentValueFrom(@Nullable WithSpan annotation) {
+      if (annotation == null || withParentMethodHandle == null) {
+        return true;
+      }
+
+      try {
+        return (boolean) withParentMethodHandle.invoke(annotation);
+      } catch (Throwable ignore) {
+        return true;
+      }
     }
   }
 }

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,16 @@ abstract class WithSpanAspect {
                     JoinPointRequest::method,
                     parameterAttributeNamesExtractor,
                     JoinPointRequest::args))
+            .addContextCustomizer(WithSpanAspect::parentContext)
             .buildInstrumenter(JoinPointRequest::spanKind);
     this.requestFactory = requestFactory;
   }
 
+  private static Context parentContext(
+      Context parentContext, JoinPointRequest request, Attributes unused) {
+    return request.withParent() ? parentContext : 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