diff --git a/instrumentation-api-annotation-support/build.gradle.kts b/instrumentation-api-annotation-support/build.gradle.kts index 60c0740d46..e3f1537105 100644 --- a/instrumentation-api-annotation-support/build.gradle.kts +++ b/instrumentation-api-annotation-support/build.gradle.kts @@ -9,6 +9,10 @@ group = "io.opentelemetry.instrumentation" dependencies { implementation(project(":instrumentation-api")) + // this only exists to make Intellij happy since it doesn't (currently at least) understand our + // inclusion of this artifact inside of :instrumentation-api + compileOnly(project(":instrumentation-api-caching")) + api("io.opentelemetry:opentelemetry-api") api("io.opentelemetry:opentelemetry-semconv") diff --git a/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/MethodArgumentsExtractor.java b/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/MethodArgumentsExtractor.java new file mode 100644 index 0000000000..b2c099b7f1 --- /dev/null +++ b/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/MethodArgumentsExtractor.java @@ -0,0 +1,13 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.api.annotation.support; + +/** Extractor for the actual arguments passed to the parameters of the traced method. */ +@FunctionalInterface +public interface MethodArgumentsExtractor { + /** Extracts an array of the actual arguments from the {@link REQUEST}. */ + Object[] extract(REQUEST request); +} diff --git a/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/MethodCache.java b/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/MethodCache.java new file mode 100644 index 0000000000..33a8975d49 --- /dev/null +++ b/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/MethodCache.java @@ -0,0 +1,43 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.api.annotation.support; + +import io.opentelemetry.instrumentation.api.caching.Cache; +import java.lang.reflect.Method; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Function; + +/** + * Implementation of {@link Cache} that uses {@link ClassValue} to store values keyed by {@link + * Method} compared by value equality while allowing the declaring class to be unloaded. + */ +final class MethodCache extends ClassValue> implements Cache { + @Override + public V computeIfAbsent(Method key, Function mappingFunction) { + return this.get(key.getDeclaringClass()).computeIfAbsent(key, mappingFunction); + } + + @Override + public V get(Method key) { + return this.get(key.getDeclaringClass()).get(key); + } + + @Override + public void put(Method key, V value) { + this.get(key.getDeclaringClass()).put(key, value); + } + + @Override + public void remove(Method key) { + this.get(key.getDeclaringClass()).remove(key); + } + + @Override + protected Map computeValue(Class type) { + return new ConcurrentHashMap<>(); + } +} diff --git a/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/MethodExtractor.java b/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/MethodExtractor.java new file mode 100644 index 0000000000..e9f30a45fc --- /dev/null +++ b/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/MethodExtractor.java @@ -0,0 +1,16 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.api.annotation.support; + +import java.lang.reflect.Method; + +/** Extractor for the traced {@link Method}. */ +@FunctionalInterface +public interface MethodExtractor { + + /** Extracts the {@link Method} corresponding to the {@link REQUEST}. */ + Method extract(REQUEST request); +} diff --git a/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/MethodSpanAttributesExtractor.java b/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/MethodSpanAttributesExtractor.java new file mode 100644 index 0000000000..7f71c226da --- /dev/null +++ b/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/MethodSpanAttributesExtractor.java @@ -0,0 +1,71 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.api.annotation.support; + +import io.opentelemetry.api.common.AttributesBuilder; +import io.opentelemetry.instrumentation.api.caching.Cache; +import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; +import java.lang.reflect.Method; +import java.lang.reflect.Parameter; +import org.checkerframework.checker.nullness.qual.Nullable; + +/** Extractor of {@link io.opentelemetry.api.common.Attributes} for a traced method. */ +public final class MethodSpanAttributesExtractor + extends AttributesExtractor { + + private final BaseAttributeBinder binder; + private final MethodExtractor methodExtractor; + private final MethodArgumentsExtractor methodArgumentsExtractor; + private final Cache cache; + + public static MethodSpanAttributesExtractor newInstance( + MethodExtractor methodExtractor, + ParameterAttributeNamesExtractor parameterAttributeNamesExtractor, + MethodArgumentsExtractor methodArgumentsExtractor) { + + return new MethodSpanAttributesExtractor<>( + methodExtractor, parameterAttributeNamesExtractor, methodArgumentsExtractor); + } + + MethodSpanAttributesExtractor( + MethodExtractor methodExtractor, + ParameterAttributeNamesExtractor parameterAttributeNamesExtractor, + MethodArgumentsExtractor methodArgumentsExtractor) { + this.methodExtractor = methodExtractor; + this.methodArgumentsExtractor = methodArgumentsExtractor; + this.binder = new MethodSpanAttributeBinder(parameterAttributeNamesExtractor); + this.cache = new MethodCache<>(); + } + + @Override + protected void onStart(AttributesBuilder attributes, REQUEST request) { + Method method = methodExtractor.extract(request); + AttributeBindings bindings = cache.computeIfAbsent(method, binder::bind); + if (!bindings.isEmpty()) { + Object[] args = methodArgumentsExtractor.extract(request); + bindings.apply(attributes::put, args); + } + } + + @Override + protected void onEnd( + AttributesBuilder attributes, REQUEST request, @Nullable RESPONSE response) {} + + private static class MethodSpanAttributeBinder extends BaseAttributeBinder { + private final ParameterAttributeNamesExtractor parameterAttributeNamesExtractor; + + public MethodSpanAttributeBinder( + ParameterAttributeNamesExtractor parameterAttributeNamesExtractor) { + this.parameterAttributeNamesExtractor = parameterAttributeNamesExtractor; + } + + @Override + protected @Nullable String[] attributeNamesForParameters( + Method method, Parameter[] parameters) { + return parameterAttributeNamesExtractor.extract(method, parameters); + } + } +} diff --git a/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/ParameterAttributeNamesExtractor.java b/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/ParameterAttributeNamesExtractor.java new file mode 100644 index 0000000000..64d406ab54 --- /dev/null +++ b/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/ParameterAttributeNamesExtractor.java @@ -0,0 +1,27 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.api.annotation.support; + +import java.lang.reflect.Method; +import java.lang.reflect.Parameter; +import org.checkerframework.checker.nullness.qual.Nullable; + +/** Extractor for the attribute names for the parameters of a traced method. */ +@FunctionalInterface +public interface ParameterAttributeNamesExtractor { + /** + * Returns an array of the names of the attributes for the parameters of the traced method. The + * array should be the same length as the array of the method parameters. An element may be {@code + * null} to indicate that the parameter should not be bound to an attribute. The array may also be + * {@code null} to indicate that the method has no parameters to bind to attributes. + * + * @param method the traced method + * @param parameters the method parameters + * @return an array of the attribute names + */ + @Nullable + String[] extract(Method method, Parameter[] parameters); +} diff --git a/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/async/AsyncOperationEndSupport.java b/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/async/AsyncOperationEndSupport.java index 546b7ee110..4eddd97325 100644 --- a/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/async/AsyncOperationEndSupport.java +++ b/instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/async/AsyncOperationEndSupport.java @@ -7,6 +7,7 @@ package io.opentelemetry.instrumentation.api.annotation.support.async; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; +import org.checkerframework.checker.nullness.qual.Nullable; /** * A wrapper over {@link Instrumenter} that is able to defer {@link Instrumenter#end(Context, @@ -35,13 +36,13 @@ public final class AsyncOperationEndSupport { private final Instrumenter instrumenter; private final Class responseType; private final Class asyncType; - private final AsyncOperationEndStrategy asyncOperationEndStrategy; + private final @Nullable AsyncOperationEndStrategy asyncOperationEndStrategy; private AsyncOperationEndSupport( Instrumenter instrumenter, Class responseType, Class asyncType, - AsyncOperationEndStrategy asyncOperationEndStrategy) { + @Nullable AsyncOperationEndStrategy asyncOperationEndStrategy) { this.instrumenter = instrumenter; this.responseType = responseType; this.asyncType = asyncType; @@ -61,8 +62,10 @@ public final class AsyncOperationEndSupport { * won't be {@link Instrumenter#end(Context, Object, Object, Throwable) ended} until {@code * asyncValue} completes. */ + @SuppressWarnings("unchecked") + @Nullable public ASYNC asyncEnd( - Context context, REQUEST request, ASYNC asyncValue, Throwable throwable) { + Context context, REQUEST request, @Nullable ASYNC asyncValue, @Nullable Throwable throwable) { // we can end early if an exception was thrown if (throwable != null) { instrumenter.end(context, request, null, throwable); diff --git a/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/JoinPointRequest.java b/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/JoinPointRequest.java new file mode 100644 index 0000000000..4cd4bc28a8 --- /dev/null +++ b/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/JoinPointRequest.java @@ -0,0 +1,36 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.spring.autoconfigure.aspects; + +import io.opentelemetry.extension.annotations.WithSpan; +import java.lang.reflect.Method; +import org.aspectj.lang.JoinPoint; +import org.aspectj.lang.reflect.MethodSignature; + +final class JoinPointRequest { + private final JoinPoint joinPoint; + private final Method method; + private final WithSpan annotation; + + JoinPointRequest(JoinPoint joinPoint) { + this.joinPoint = joinPoint; + MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature(); + this.method = methodSignature.getMethod(); + this.annotation = this.method.getDeclaredAnnotation(WithSpan.class); + } + + Method method() { + return method; + } + + WithSpan annotation() { + return annotation; + } + + Object[] args() { + return joinPoint.getArgs(); + } +} diff --git a/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/TraceAspectAutoConfiguration.java b/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/TraceAspectAutoConfiguration.java index 2d6e11f4ae..298c8bf881 100644 --- a/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/TraceAspectAutoConfiguration.java +++ b/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/TraceAspectAutoConfiguration.java @@ -30,15 +30,9 @@ public class TraceAspectAutoConfiguration { return new DefaultParameterNameDiscoverer(); } - @Bean - public WithSpanAspectAttributeBinder withSpanAspectAttributeBinder( - ParameterNameDiscoverer parameterNameDiscoverer) { - return new WithSpanAspectAttributeBinder(parameterNameDiscoverer); - } - @Bean public WithSpanAspect withSpanAspect( - OpenTelemetry openTelemetry, WithSpanAspectAttributeBinder withSpanAspectAttributeBinder) { - return new WithSpanAspect(openTelemetry, withSpanAspectAttributeBinder); + OpenTelemetry openTelemetry, ParameterNameDiscoverer parameterNameDiscoverer) { + return new WithSpanAspect(openTelemetry, parameterNameDiscoverer); } } diff --git a/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspect.java b/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspect.java index b7944fe7a6..0dd2ced873 100644 --- a/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspect.java +++ b/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspect.java @@ -6,14 +6,19 @@ package io.opentelemetry.instrumentation.spring.autoconfigure.aspects; import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.api.trace.SpanKind; import io.opentelemetry.context.Context; import io.opentelemetry.context.Scope; import io.opentelemetry.extension.annotations.WithSpan; -import java.lang.reflect.Method; +import io.opentelemetry.instrumentation.api.annotation.support.MethodSpanAttributesExtractor; +import io.opentelemetry.instrumentation.api.annotation.support.ParameterAttributeNamesExtractor; +import io.opentelemetry.instrumentation.api.annotation.support.async.AsyncOperationEndSupport; +import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; +import io.opentelemetry.instrumentation.api.tracer.SpanNames; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; -import org.aspectj.lang.reflect.MethodSignature; +import org.springframework.core.ParameterNameDiscoverer; /** * Uses Spring-AOP to wrap methods marked by {@link WithSpan} in a {@link @@ -27,30 +32,57 @@ import org.aspectj.lang.reflect.MethodSignature; */ @Aspect public class WithSpanAspect { - private final WithSpanAspectTracer tracer; + private static final String INSTRUMENTATION_NAME = "io.opentelemetry.spring-boot-autoconfigure"; + + private final Instrumenter instrumenter; public WithSpanAspect( - OpenTelemetry openTelemetry, WithSpanAspectAttributeBinder withSpanAspectAttributeBinder) { - tracer = new WithSpanAspectTracer(openTelemetry, withSpanAspectAttributeBinder); + OpenTelemetry openTelemetry, ParameterNameDiscoverer parameterNameDiscoverer) { + + ParameterAttributeNamesExtractor parameterAttributeNamesExtractor = + new WithSpanAspectParameterAttributeNamesExtractor(parameterNameDiscoverer); + + instrumenter = + Instrumenter.newBuilder(openTelemetry, INSTRUMENTATION_NAME, WithSpanAspect::spanName) + .addAttributesExtractor( + MethodSpanAttributesExtractor.newInstance( + JoinPointRequest::method, + parameterAttributeNamesExtractor, + JoinPointRequest::args)) + .newInstrumenter(WithSpanAspect::spanKind); + } + + private static String spanName(JoinPointRequest request) { + WithSpan annotation = request.annotation(); + String spanName = annotation.value(); + if (spanName.isEmpty()) { + return SpanNames.fromMethod(request.method()); + } + return spanName; + } + + private static SpanKind spanKind(JoinPointRequest request) { + return request.annotation().kind(); } @Around("@annotation(io.opentelemetry.extension.annotations.WithSpan)") public Object traceMethod(ProceedingJoinPoint pjp) throws Throwable { - MethodSignature signature = (MethodSignature) pjp.getSignature(); - Method method = signature.getMethod(); - WithSpan withSpan = method.getAnnotation(WithSpan.class); + JoinPointRequest request = new JoinPointRequest(pjp); Context parentContext = Context.current(); - if (!tracer.shouldStartSpan(parentContext, withSpan.kind())) { + if (!instrumenter.shouldStart(parentContext, request)) { return pjp.proceed(); } - Context context = tracer.startSpan(parentContext, withSpan, method, pjp); + Context context = instrumenter.start(parentContext, request); + AsyncOperationEndSupport asyncOperationEndSupport = + AsyncOperationEndSupport.create( + instrumenter, Object.class, request.method().getReturnType()); try (Scope ignored = context.makeCurrent()) { - Object result = pjp.proceed(); - return tracer.end(context, method.getReturnType(), result); + Object response = pjp.proceed(); + return asyncOperationEndSupport.asyncEnd(context, request, response, null); } catch (Throwable t) { - tracer.endExceptionally(context, t); + asyncOperationEndSupport.asyncEnd(context, request, null, t); throw t; } } diff --git a/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectAttributeBinder.java b/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectParameterAttributeNamesExtractor.java similarity index 67% rename from instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectAttributeBinder.java rename to instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectParameterAttributeNamesExtractor.java index e5ddfcc522..c33b464b1d 100644 --- a/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectAttributeBinder.java +++ b/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectParameterAttributeNamesExtractor.java @@ -6,32 +6,22 @@ package io.opentelemetry.instrumentation.spring.autoconfigure.aspects; import io.opentelemetry.extension.annotations.SpanAttribute; -import io.opentelemetry.instrumentation.api.annotation.support.AttributeBindings; -import io.opentelemetry.instrumentation.api.annotation.support.BaseAttributeBinder; -import io.opentelemetry.instrumentation.api.caching.Cache; +import io.opentelemetry.instrumentation.api.annotation.support.ParameterAttributeNamesExtractor; import java.lang.reflect.Method; import java.lang.reflect.Parameter; import org.checkerframework.checker.nullness.qual.Nullable; import org.springframework.core.ParameterNameDiscoverer; -public class WithSpanAspectAttributeBinder extends BaseAttributeBinder { - - private static final Cache bindings = - Cache.newBuilder().setWeakKeys().build(); - +class WithSpanAspectParameterAttributeNamesExtractor implements ParameterAttributeNamesExtractor { private final ParameterNameDiscoverer parameterNameDiscoverer; - public WithSpanAspectAttributeBinder(ParameterNameDiscoverer parameterNameDiscoverer) { + public WithSpanAspectParameterAttributeNamesExtractor( + ParameterNameDiscoverer parameterNameDiscoverer) { this.parameterNameDiscoverer = parameterNameDiscoverer; } @Override - public AttributeBindings bind(Method method) { - return bindings.computeIfAbsent(method, super::bind); - } - - @Override - protected @Nullable String[] attributeNamesForParameters(Method method, Parameter[] parameters) { + public @Nullable String[] extract(Method method, Parameter[] parameters) { String[] parameterNames = parameterNameDiscoverer.getParameterNames(method); String[] attributeNames = new String[parameters.length]; diff --git a/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectTracer.java b/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectTracer.java deleted file mode 100644 index b98e87daab..0000000000 --- a/instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectTracer.java +++ /dev/null @@ -1,92 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.spring.autoconfigure.aspects; - -import io.opentelemetry.api.OpenTelemetry; -import io.opentelemetry.api.trace.Span; -import io.opentelemetry.api.trace.SpanBuilder; -import io.opentelemetry.context.Context; -import io.opentelemetry.extension.annotations.WithSpan; -import io.opentelemetry.instrumentation.api.annotation.support.AttributeBindings; -import io.opentelemetry.instrumentation.api.tracer.BaseTracer; -import io.opentelemetry.instrumentation.api.tracer.SpanNames; -import io.opentelemetry.instrumentation.api.tracer.async.AsyncSpanEndStrategies; -import io.opentelemetry.instrumentation.api.tracer.async.AsyncSpanEndStrategy; -import java.lang.reflect.Method; -import org.aspectj.lang.JoinPoint; - -class WithSpanAspectTracer extends BaseTracer { - - private final WithSpanAspectAttributeBinder withSpanAspectAttributeBinder; - private final AsyncSpanEndStrategies asyncSpanEndStrategies = - AsyncSpanEndStrategies.getInstance(); - - WithSpanAspectTracer( - OpenTelemetry openTelemetry, WithSpanAspectAttributeBinder withSpanAspectAttributeBinder) { - super(openTelemetry); - this.withSpanAspectAttributeBinder = withSpanAspectAttributeBinder; - } - - @Override - protected String getInstrumentationName() { - return "io.opentelemetry.spring-boot-autoconfigure-aspect"; - } - - Context startSpan( - Context parentContext, WithSpan annotation, Method method, JoinPoint joinPoint) { - SpanBuilder spanBuilder = - spanBuilder(parentContext, spanName(annotation, method), annotation.kind()); - Span span = withSpanAttributes(spanBuilder, method, joinPoint).startSpan(); - switch (annotation.kind()) { - case SERVER: - return withServerSpan(parentContext, span); - case CLIENT: - return withClientSpan(parentContext, span); - default: - return parentContext.with(span); - } - } - - private static String spanName(WithSpan annotation, Method method) { - String spanName = annotation.value(); - if (spanName.isEmpty()) { - return SpanNames.fromMethod(method); - } - return spanName; - } - - public SpanBuilder withSpanAttributes( - SpanBuilder spanBuilder, Method method, JoinPoint joinPoint) { - AttributeBindings bindings = withSpanAspectAttributeBinder.bind(method); - if (!bindings.isEmpty()) { - bindings.apply(spanBuilder::setAttribute, joinPoint.getArgs()); - } - return spanBuilder; - } - - /** - * Denotes the end of the invocation of the traced method with a successful result which will end - * the span stored in the passed {@code context}. If the method returned a value representing an - * asynchronous operation then the span will not be finished until the asynchronous operation has - * completed. - * - * @param returnType Return type of the traced method. - * @param returnValue Return value from the traced method. - * @return Either {@code returnValue} or a value composing over {@code returnValue} for - * notification of completion. - */ - public Object end(Context context, Class returnType, Object returnValue) { - if (returnType.isInstance(returnValue)) { - AsyncSpanEndStrategy asyncSpanEndStrategy = - asyncSpanEndStrategies.resolveStrategy(returnType); - if (asyncSpanEndStrategy != null) { - return asyncSpanEndStrategy.end(this, context, returnValue); - } - } - end(context); - return returnValue; - } -} diff --git a/instrumentation/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectTest.java b/instrumentation/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectTest.java index 0be09127b1..feae4c603d 100644 --- a/instrumentation/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectTest.java +++ b/instrumentation/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/aspects/WithSpanAspectTest.java @@ -104,9 +104,8 @@ public class WithSpanAspectTest { return null; } }; - WithSpanAspectAttributeBinder attributeBinder = - new WithSpanAspectAttributeBinder(parameterNameDiscoverer); - WithSpanAspect aspect = new WithSpanAspect(testing.getOpenTelemetry(), attributeBinder); + + WithSpanAspect aspect = new WithSpanAspect(testing.getOpenTelemetry(), parameterNameDiscoverer); factory.addAspect(aspect); withSpanTester = factory.getProxy();