Backward compatibility with older versions @WithSpan

Author: xiepuhuan

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

@@ -17,6 +17,9 @@
 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;
 
@@ -31,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;
   }
@@ -115,12 +133,20 @@ private static Context parentContextFromMethodRequest(
 
   private static Context parentContextFromMethod(
       Context context, Method method, Attributes attributes) {
-    WithSpan annotation = method.getDeclaredAnnotation(WithSpan.class);
-    if (annotation.withParent()) {
+    if (withParentMethodHandle == null) {
       return context;
     }
 
-    return Context.root();
+    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/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;
 
@@ -60,6 +64,21 @@ interface Factory {
 
   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();
@@ -72,9 +91,21 @@ 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, withParent);
+      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

@@ -59,12 +59,9 @@ abstract class WithSpanAspect {
     this.requestFactory = requestFactory;
   }
 
-  static Context parentContext(Context parentContext, JoinPointRequest request, Attributes unused) {
-    if (request.withParent()) {
-      return parentContext;
-    }
-
-    return Context.root();
+  private static Context parentContext(
+      Context parentContext, JoinPointRequest request, Attributes unused) {
+    return request.withParent() ? parentContext : Context.root();
   }
 
   public Object traceMethod(ProceedingJoinPoint pjp) throws Throwable {