WIP on MetricTag

build.gradle

@@ -302,6 +302,7 @@ subprojects {
 	description = 'Facade over tracing concepts'
 
 	repositories {
+		mavenLocal()
 		mavenCentral()
 		maven {
 			// TODO remove when upgrading to GA versions of micrometer deps

dependencies.gradle

@@ -32,7 +32,7 @@ def VERSIONS = [
 ]
 
 def MICROMETER_PLATFORM_VERSIONS = [
-	'io.micrometer:micrometer-bom:1.11.0-M2'
+	'io.micrometer:micrometer-bom:1.11.0-SNAPSHOT'
 ]
 
 def PLATFORM_VERSIONS = [

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.TagValueExpressionResolver;
+import io.micrometer.common.annotation.TagValueResolver;
 import io.micrometer.common.util.StringUtils;
 import io.micrometer.tracing.Span;
 import io.micrometer.tracing.Tracer;
@@ -43,8 +45,8 @@ public class ImperativeMethodInvocationProcessor extends AbstractMethodInvocatio
     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));
+        super(newSpanParser, tracer, tracer.currentTraceContext(),
+                new SpanTagAnnotationHandler(resolverProvider, expressionResolverProvider));
     }
 
     @Override

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

@@ -15,11 +15,10 @@
  */
 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.NoOpTagValueResolver;
+import io.micrometer.common.annotation.TagValueResolver;
+
+import java.lang.annotation.*;
 
 /**
  * There are 3 different ways to add tags to a span. All of them are controlled by the

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.NoOpTagValueResolver;
+import io.micrometer.common.annotation.TagAnnotationHandler;
+import io.micrometer.common.annotation.TagValueExpressionResolver;
+import io.micrometer.common.annotation.TagValueResolver;
 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,36 @@
  * @author Christian Schwerdtfeger
  * @since 1.1.0
  */
-class SpanTagAnnotationHandler {
+class SpanTagAnnotationHandler extends TagAnnotationHandler<SpanCustomizer> {
 
-    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,
+    public SpanTagAnnotationHandler(
             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);
+        super((keyValue, spanCustomizer) -> spanCustomizer.tag(keyValue.getKey(), keyValue.getValue()),
+                resolverProvider, expressionResolverProvider, SpanTag.class, (annotation, o) -> {
+                    if (!(annotation instanceof SpanTag)) {
+                        return null;
                     }
-                }
-            }
-        }
+                    SpanTag spanTag = (SpanTag) annotation;
+                    return KeyValue.of(resolveTagKey(spanTag),
+                            resolveTagValue(spanTag, o, resolverProvider, expressionResolverProvider));
+                });
     }
 
-    private boolean methodsAreTheSame(Method mostSpecificMethod, Method method1) {
-        return method1.getName().equals(mostSpecificMethod.getName())
-                && Arrays.equals(method1.getParameterTypes(), mostSpecificMethod.getParameterTypes());
+    private static String resolveTagKey(SpanTag annotation) {
+        return StringUtils.isNotBlank(annotation.value()) ? annotation.value() : annotation.key();
     }
 
-    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);
-        }
-    }
-
-    private String resolveTagKey(AnnotatedParameter container) {
-        return StringUtils.isNotBlank(container.annotation.value()) ? container.annotation.value()
-                : container.annotation.key();
-    }
-
-    String resolveTagValue(SpanTag annotation, Object argument) {
+    static String resolveTagValue(SpanTag annotation, Object argument,
+            Function<Class<? extends TagValueResolver>, ? extends TagValueResolver> resolverProvider,
+            Function<Class<? extends TagValueExpressionResolver>, ? extends TagValueExpressionResolver> expressionResolverProvider) {
         String value = null;
         if (annotation.resolver() != NoOpTagValueResolver.class) {
             TagValueResolver tagValueResolver = resolverProvider.apply(annotation.resolver());
             value = tagValueResolver.resolve(argument);
         }
         else if (StringUtils.isNotBlank(annotation.expression())) {
-            value = this.expressionResolverProvider.apply(TagValueExpressionResolver.class)
+            value = expressionResolverProvider.apply(TagValueExpressionResolver.class)
                 .resolve(annotation.expression(), argument);
         }
         else if (argument != null) {

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

@@ -15,6 +15,7 @@
  */
 package io.micrometer.tracing.annotation;
 
+import io.micrometer.common.annotation.NoOpTagValueResolver;
 import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.BDDAssertions.then;