Aligning with annotations changes in Micrometer

micrometer-tracing/src/main/java/io/micrometer/tracing/annotation/AbstractMethodInvocationProcessor.java

@@ -47,7 +47,10 @@ void before(MethodInvocation invocation, Span span, String log, boolean hasLog)
         if (hasLog) {
             logEvent(span, String.format(AnnotationSpanDocumentation.Events.BEFORE.getValue(), log));
         }
-        spanTagAnnotationHandler.addAnnotatedParameters(invocation);
+        if (invocation instanceof SpanAspectMethodInvocation) {
+            SpanAspectMethodInvocation spanInvocation = (SpanAspectMethodInvocation) invocation;
+            spanTagAnnotationHandler.addAnnotatedParameters(tracer.currentSpanCustomizer(), spanInvocation.getPjp());
+        }
         addTags(invocation, span);
     }
 

micrometer-tracing/src/main/java/io/micrometer/tracing/annotation/ImperativeMethodInvocationProcessor.java

@@ -15,6 +15,8 @@
  */
 package io.micrometer.tracing.annotation;
 
+import io.micrometer.common.annotation.ValueExpressionResolver;
+import io.micrometer.common.annotation.ValueResolver;
 import io.micrometer.common.util.StringUtils;
 import io.micrometer.tracing.Span;
 import io.micrometer.tracing.Tracer;
@@ -41,10 +43,10 @@ public class ImperativeMethodInvocationProcessor extends AbstractMethodInvocatio
      * resolver provider
      */
     public ImperativeMethodInvocationProcessor(NewSpanParser newSpanParser, Tracer tracer,
-            Function<Class<? extends TagValueResolver>, ? extends TagValueResolver> resolverProvider,
-            Function<Class<? extends TagValueExpressionResolver>, ? extends TagValueExpressionResolver> expressionResolverProvider) {
-        super(newSpanParser, tracer, tracer.currentTraceContext(), new SpanTagAnnotationHandler(
-                tracer.currentSpanCustomizer(), resolverProvider, expressionResolverProvider));
+            Function<Class<? extends ValueResolver>, ? extends ValueResolver> resolverProvider,
+            Function<Class<? extends ValueExpressionResolver>, ? extends ValueExpressionResolver> expressionResolverProvider) {
+        super(newSpanParser, tracer, tracer.currentTraceContext(),
+                new SpanTagAnnotationHandler(resolverProvider, expressionResolverProvider));
     }
 
     @Override

micrometer-tracing/src/main/java/io/micrometer/tracing/annotation/SpanTag.java

@@ -15,17 +15,16 @@
  */
 package io.micrometer.tracing.annotation;
 
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Inherited;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import io.micrometer.common.annotation.NoOpValueResolver;
+import io.micrometer.common.annotation.ValueResolver;
+
+import java.lang.annotation.*;
 
 /**
  * There are 3 different ways to add tags to a span. All of them are controlled by the
  * annotation values. Precedence is:
  * <p>
- * try with the {@link TagValueResolver} bean if the value of the bean wasn't set, try to
+ * try with the {@link ValueResolver} bean if the value of the bean wasn't set, try to
  * evaluate a SPEL expression if there’s no SPEL expression just return a
  * {@code toString()} value of the parameter
  *
@@ -58,8 +57,8 @@
 
     /**
      * Use this bean to resolve the tag value. Has the highest precedence.
-     * @return {@link TagValueResolver} bean
+     * @return {@link ValueResolver} bean
      */
-    Class<? extends TagValueResolver> resolver() default NoOpTagValueResolver.class;
+    Class<? extends ValueResolver> resolver() default NoOpValueResolver.class;
 
 }

micrometer-tracing/src/main/java/io/micrometer/tracing/annotation/SpanTagAnnotationHandler.java

@@ -15,15 +15,14 @@
  */
 package io.micrometer.tracing.annotation;
 
+import io.micrometer.common.KeyValue;
+import io.micrometer.common.annotation.NoOpValueResolver;
+import io.micrometer.common.annotation.TagAnnotationHandler;
+import io.micrometer.common.annotation.ValueExpressionResolver;
+import io.micrometer.common.annotation.ValueResolver;
 import io.micrometer.common.util.StringUtils;
-import io.micrometer.common.util.internal.logging.InternalLogger;
-import io.micrometer.common.util.internal.logging.InternalLoggerFactory;
 import io.micrometer.tracing.SpanCustomizer;
-import org.aopalliance.intercept.MethodInvocation;
 
-import java.lang.reflect.Method;
-import java.util.Arrays;
-import java.util.List;
 import java.util.function.Function;
 
 /**
@@ -40,96 +39,35 @@
  * @author Christian Schwerdtfeger
  * @since 1.1.0
  */
-class SpanTagAnnotationHandler {
-
-    private static final InternalLogger log = InternalLoggerFactory.getInstance(SpanTagAnnotationHandler.class);
-
-    private final SpanCustomizer spanCustomizer;
-
-    private final Function<Class<? extends TagValueResolver>, ? extends TagValueResolver> resolverProvider;
-
-    private final Function<Class<? extends TagValueExpressionResolver>, ? extends TagValueExpressionResolver> expressionResolverProvider;
-
-    SpanTagAnnotationHandler(SpanCustomizer spanCustomizer,
-            Function<Class<? extends TagValueResolver>, ? extends TagValueResolver> resolverProvider,
-            Function<Class<? extends TagValueExpressionResolver>, ? extends TagValueExpressionResolver> expressionResolverProvider) {
-        this.spanCustomizer = spanCustomizer;
-        this.resolverProvider = resolverProvider;
-        this.expressionResolverProvider = expressionResolverProvider;
-    }
-
-    void addAnnotatedParameters(MethodInvocation pjp) {
-        try {
-            Method method = pjp.getMethod();
-            List<AnnotatedParameter> annotatedParameters = AnnotationUtils.findAnnotatedParameters(method,
-                    pjp.getArguments());
-            getAnnotationsFromInterfaces(pjp, method, annotatedParameters);
-            addAnnotatedArguments(annotatedParameters);
-        }
-        catch (SecurityException ex) {
-            log.error("Exception occurred while trying to add annotated parameters", ex);
-        }
-    }
-
-    private void getAnnotationsFromInterfaces(MethodInvocation pjp, Method mostSpecificMethod,
-            List<AnnotatedParameter> annotatedParameters) {
-        Class<?>[] implementedInterfaces = pjp.getThis().getClass().getInterfaces();
-        if (implementedInterfaces.length > 0) {
-            for (Class<?> implementedInterface : implementedInterfaces) {
-                for (Method methodFromInterface : implementedInterface.getMethods()) {
-                    if (methodsAreTheSame(mostSpecificMethod, methodFromInterface)) {
-                        List<AnnotatedParameter> annotatedParametersForActualMethod = AnnotationUtils
-                            .findAnnotatedParameters(methodFromInterface, pjp.getArguments());
-                        mergeAnnotatedParameters(annotatedParameters, annotatedParametersForActualMethod);
+class SpanTagAnnotationHandler extends TagAnnotationHandler<SpanCustomizer> {
+
+    public SpanTagAnnotationHandler(Function<Class<? extends ValueResolver>, ? extends ValueResolver> resolverProvider,
+            Function<Class<? extends ValueExpressionResolver>, ? extends ValueExpressionResolver> expressionResolverProvider) {
+        super((keyValue, spanCustomizer) -> spanCustomizer.tag(keyValue.getKey(), keyValue.getValue()),
+                resolverProvider, expressionResolverProvider, SpanTag.class, (annotation, o) -> {
+                    if (!(annotation instanceof SpanTag)) {
+                        return null;
                     }
-                }
-            }
-        }
-    }
-
-    private boolean methodsAreTheSame(Method mostSpecificMethod, Method method1) {
-        return method1.getName().equals(mostSpecificMethod.getName())
-                && Arrays.equals(method1.getParameterTypes(), mostSpecificMethod.getParameterTypes());
-    }
-
-    private void mergeAnnotatedParameters(List<AnnotatedParameter> annotatedParametersIndices,
-            List<AnnotatedParameter> annotatedParametersIndicesForActualMethod) {
-        for (AnnotatedParameter container : annotatedParametersIndicesForActualMethod) {
-            final int index = container.parameterIndex;
-            boolean parameterContained = false;
-            for (AnnotatedParameter parameterContainer : annotatedParametersIndices) {
-                if (parameterContainer.parameterIndex == index) {
-                    parameterContained = true;
-                    break;
-                }
-            }
-            if (!parameterContained) {
-                annotatedParametersIndices.add(container);
-            }
-        }
-    }
-
-    private void addAnnotatedArguments(List<AnnotatedParameter> toBeAdded) {
-        for (AnnotatedParameter container : toBeAdded) {
-            String tagValue = resolveTagValue(container.annotation, container.argument);
-            String tagKey = resolveTagKey(container);
-            spanCustomizer.tag(tagKey, tagValue);
-        }
+                    SpanTag spanTag = (SpanTag) annotation;
+                    return KeyValue.of(resolveTagKey(spanTag),
+                            resolveTagValue(spanTag, o, resolverProvider, expressionResolverProvider));
+                });
     }
 
-    private String resolveTagKey(AnnotatedParameter container) {
-        return StringUtils.isNotBlank(container.annotation.value()) ? container.annotation.value()
-                : container.annotation.key();
+    private static String resolveTagKey(SpanTag annotation) {
+        return StringUtils.isNotBlank(annotation.value()) ? annotation.value() : annotation.key();
     }
 
-    String resolveTagValue(SpanTag annotation, Object argument) {
+    static String resolveTagValue(SpanTag annotation, Object argument,
+            Function<Class<? extends ValueResolver>, ? extends ValueResolver> resolverProvider,
+            Function<Class<? extends ValueExpressionResolver>, ? extends ValueExpressionResolver> expressionResolverProvider) {
         String value = null;
-        if (annotation.resolver() != NoOpTagValueResolver.class) {
-            TagValueResolver tagValueResolver = resolverProvider.apply(annotation.resolver());
-            value = tagValueResolver.resolve(argument);
+        if (annotation.resolver() != NoOpValueResolver.class) {
+            ValueResolver ValueResolver = resolverProvider.apply(annotation.resolver());
+            value = ValueResolver.resolve(argument);
         }
         else if (StringUtils.isNotBlank(annotation.expression())) {
-            value = this.expressionResolverProvider.apply(TagValueExpressionResolver.class)
+            value = expressionResolverProvider.apply(ValueExpressionResolver.class)
                 .resolve(annotation.expression(), argument);
         }
         else if (argument != null) {

micrometer-tracing/src/test/java/io/micrometer/tracing/annotation/NoOpTagValueResolverTests.java

@@ -15,18 +15,19 @@
  */
 package io.micrometer.tracing.annotation;
 
+import io.micrometer.common.annotation.NoOpValueResolver;
 import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.BDDAssertions.then;
 
 /**
  * @author Marcin Grzejszczak
  */
-class NoOpTagValueResolverTests {
+class NoOpValueResolverTests {
 
     @Test
     void should_return_null() throws Exception {
-        then(new NoOpTagValueResolver().resolve("")).isNull();
+        then(new NoOpValueResolver().resolve("")).isNull();
     }
 
 }