From b13f15f9d7db49a0cda1e6777e01d0ad3deb61d8 Mon Sep 17 00:00:00 2001 From: Marcin Grzejszczak Date: Fri, 31 Aug 2018 13:15:12 +0200 Subject: [PATCH] Added condition on presence of WebFlux without this change we have a ClassNotFoundException when reactor dependency is not passed with this change, we don't require anyone to actually have that dependency set. What we do is we conditionally create a bean of either reactor or nonreactor type, depending on the presence of the Flux class on the classpath fixes gh-1074 --- ...stractSleuthMethodInvocationProcessor.java | 117 +++++++++++ ...eactorSleuthMethodInvocationProcessor.java | 57 +++++ ...eactorSleuthMethodInvocationProcessor.java | 127 ++++++++++++ .../annotation/SleuthAdvisorConfig.java | 196 +----------------- .../SleuthAnnotationAutoConfiguration.java | 16 ++ .../SleuthMethodInvocationProcessor.java | 28 +++ spring-cloud-sleuth-zipkin/pom.xml | 5 - 7 files changed, 351 insertions(+), 195 deletions(-) create mode 100644 spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/AbstractSleuthMethodInvocationProcessor.java create mode 100644 spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/NonReactorSleuthMethodInvocationProcessor.java create mode 100644 spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/ReactorSleuthMethodInvocationProcessor.java create mode 100644 spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthMethodInvocationProcessor.java diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/AbstractSleuthMethodInvocationProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/AbstractSleuthMethodInvocationProcessor.java new file mode 100644 index 000000000..dc956f40a --- /dev/null +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/AbstractSleuthMethodInvocationProcessor.java @@ -0,0 +1,117 @@ +/* + * Copyright 2013-2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.cloud.sleuth.annotation; + +import brave.Span; +import brave.Tracer; +import org.aopalliance.intercept.MethodInvocation; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.springframework.beans.BeansException; +import org.springframework.beans.factory.BeanFactory; +import org.springframework.beans.factory.BeanFactoryAware; + +/** + * @author Marcin Grzejszczak + */ +abstract class AbstractSleuthMethodInvocationProcessor + implements SleuthMethodInvocationProcessor, BeanFactoryAware { + private static final Log logger = LogFactory + .getLog(AbstractSleuthMethodInvocationProcessor.class); + private static final String CLASS_KEY = "class"; + private static final String METHOD_KEY = "method"; + + BeanFactory beanFactory; + private NewSpanParser newSpanParser; + private Tracer tracer; + private SpanTagAnnotationHandler spanTagAnnotationHandler; + + void before(MethodInvocation invocation, Span span, String log, boolean hasLog) { + if (hasLog) { + logEvent(span, log + ".before"); + } + spanTagAnnotationHandler().addAnnotatedParameters(invocation); + addTags(invocation, span); + } + + void after(Span span, boolean isNewSpan, String log, boolean hasLog) { + if (hasLog) { + logEvent(span, log + ".after"); + } + if (isNewSpan) { + span.finish(); + } + } + + void onFailure(Span span, String log, boolean hasLog, Throwable e) { + if (logger.isDebugEnabled()) { + logger.debug("Exception occurred while trying to continue the pointcut", e); + } + if (hasLog) { + logEvent(span, log + ".afterFailure"); + } + span.error(e); + } + + void addTags(MethodInvocation invocation, Span span) { + span.tag(CLASS_KEY, invocation.getThis().getClass().getSimpleName()); + span.tag(METHOD_KEY, invocation.getMethod().getName()); + } + + void logEvent(Span span, String name) { + if (span == null) { + logger.warn("You were trying to continue a span which was null. Please " + + "remember that if two proxied methods are calling each other from " + + "the same class then the aspect will not be properly resolved"); + return; + } + span.annotate(name); + } + + String log(ContinueSpan continueSpan) { + if (continueSpan != null) { + return continueSpan.log(); + } + return ""; + } + + Tracer tracer() { + if (this.tracer == null) { + this.tracer = this.beanFactory.getBean(Tracer.class); + } + return this.tracer; + } + + NewSpanParser newSpanParser() { + if (this.newSpanParser == null) { + this.newSpanParser = this.beanFactory.getBean(NewSpanParser.class); + } + return this.newSpanParser; + } + + SpanTagAnnotationHandler spanTagAnnotationHandler() { + if (this.spanTagAnnotationHandler == null) { + this.spanTagAnnotationHandler = new SpanTagAnnotationHandler( + this.beanFactory); + } + return this.spanTagAnnotationHandler; + } + + @Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { + this.beanFactory = beanFactory; + } +} diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/NonReactorSleuthMethodInvocationProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/NonReactorSleuthMethodInvocationProcessor.java new file mode 100644 index 000000000..09074c0c3 --- /dev/null +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/NonReactorSleuthMethodInvocationProcessor.java @@ -0,0 +1,57 @@ +/* + * Copyright 2013-2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.cloud.sleuth.annotation; + +import brave.Span; +import brave.Tracer; +import org.aopalliance.intercept.MethodInvocation; +import org.springframework.util.StringUtils; + +/** + * @author Marcin Grzejszczak + * @since 2.1.0 + */ +class NonReactorSleuthMethodInvocationProcessor extends AbstractSleuthMethodInvocationProcessor { + + @Override public Object process(MethodInvocation invocation, NewSpan newSpan, + ContinueSpan continueSpan) throws Throwable { + return proceedUnderSynchronousSpan(invocation, newSpan, continueSpan); + } + + private Object proceedUnderSynchronousSpan( + MethodInvocation invocation, NewSpan newSpan, ContinueSpan continueSpan) throws Throwable { + Span span = tracer().currentSpan(); + //in case of @ContinueSpan and no span in tracer we start new span and should close it on completion + boolean startNewSpan = newSpan != null || span == null; + if (startNewSpan) { + span = tracer().nextSpan(); + newSpanParser().parse(invocation, newSpan, span); + span.start(); + } + String log = log(continueSpan); + boolean hasLog = StringUtils.hasText(log); + try (Tracer.SpanInScope ws = tracer().withSpanInScope(span)) { + before(invocation, span, log, hasLog); + return invocation.proceed(); + } catch (Exception e) { + onFailure(span, log, hasLog, e); + throw e; + } finally { + after(span, startNewSpan, log, hasLog); + } + } +} diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/ReactorSleuthMethodInvocationProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/ReactorSleuthMethodInvocationProcessor.java new file mode 100644 index 000000000..c1f105cf5 --- /dev/null +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/ReactorSleuthMethodInvocationProcessor.java @@ -0,0 +1,127 @@ +/* + * Copyright 2013-2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.cloud.sleuth.annotation; + +import java.lang.reflect.Method; +import java.util.function.Consumer; +import java.util.function.Supplier; + +import brave.Span; +import brave.Tracer; +import org.aopalliance.intercept.MethodInvocation; +import org.reactivestreams.Publisher; +import org.springframework.util.StringUtils; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; +import reactor.core.publisher.SignalType; + +/** + * @author Marcin Grzejszczak + * @since 2.1.0 + */ +class ReactorSleuthMethodInvocationProcessor extends AbstractSleuthMethodInvocationProcessor { + + private NonReactorSleuthMethodInvocationProcessor nonReactorSleuthMethodInvocationProcessor; + + @Override public Object process(MethodInvocation invocation, NewSpan newSpan, + ContinueSpan continueSpan) throws Throwable { + Method method = invocation.getMethod(); + if(isReactorReturnType(method.getReturnType())){ + return proceedUnderReactorSpan(invocation, newSpan, continueSpan); + } else { + return nonReactorSleuthMethodInvocationProcessor() + .process(invocation, newSpan, continueSpan); + } + } + + private Object proceedUnderReactorSpan( + MethodInvocation invocation, NewSpan newSpan, ContinueSpan continueSpan) throws Throwable{ + Span spanPrevious = tracer().currentSpan(); + //in case of @ContinueSpan and no span in tracer we start new span and should close it on completion + boolean startNewSpan = newSpan != null || spanPrevious == null; + Span span; + if (startNewSpan) { + span = tracer().nextSpan(); + newSpanParser().parse(invocation, newSpan, span); + } else { + span = spanPrevious; + } + String log = log(continueSpan); + boolean hasLog = StringUtils.hasText(log); + try(Tracer.SpanInScope ws = tracer().withSpanInScope(span)) { + Publisher publisher = (Publisher) invocation.proceed(); + Mono startSpan = Mono.defer(() -> withSpanInScope(span, () -> { + if (startNewSpan) { + span.start(); + } + before(invocation, span, log, hasLog); + return Mono.just(span); + })); + if(publisher instanceof Mono){ + return startSpan.flatMap(spanStarted -> ((Mono)publisher) + .doOnError(onFailureReactor(log, hasLog, spanStarted)) + .doFinally(afterReactor(startNewSpan, log, hasLog, spanStarted))) + //put span in context so it can be used by ScopePassingSpanSubscriber + .subscriberContext(context -> context.put(Span.class, span)); + } + else if(publisher instanceof Flux){ + return startSpan.flatMapMany(spanStarted -> ((Flux)publisher) + .doOnError(onFailureReactor(log, hasLog, spanStarted)) + .doFinally(afterReactor(startNewSpan, log, hasLog, spanStarted))) + //put span in context so it can be used by ScopePassingSpanSubscriber + .subscriberContext(context -> context.put(Span.class, span)); + } + else { + throw new IllegalArgumentException("Unexpected type of publisher: "+publisher.getClass()); + } + } + } + + private T withSpanInScope(Span span, Supplier supplier) { + try(Tracer.SpanInScope ws1 = tracer().withSpanInScope(span)) { + return supplier.get(); + } + } + + private Consumer afterReactor(boolean isNewSpan, String log, boolean hasLog, Span span) { + return signalType -> { + try(Tracer.SpanInScope ws = tracer().withSpanInScope(span)) { + after(span, isNewSpan, log, hasLog); + } + }; + } + + private Consumer onFailureReactor(String log, boolean hasLog, Span span) { + return throwable -> { + try(Tracer.SpanInScope ws = tracer().withSpanInScope(span)) { + onFailure(span, log, hasLog, throwable); + } + }; + } + + private boolean isReactorReturnType(Class returnType) { + return Flux.class.equals(returnType) || Mono.class.equals(returnType); + } + + private NonReactorSleuthMethodInvocationProcessor nonReactorSleuthMethodInvocationProcessor() { + if (this.nonReactorSleuthMethodInvocationProcessor == null) { + this.nonReactorSleuthMethodInvocationProcessor = new NonReactorSleuthMethodInvocationProcessor(); + this.nonReactorSleuthMethodInvocationProcessor.setBeanFactory(this.beanFactory); + } + return this.nonReactorSleuthMethodInvocationProcessor; + } +} diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAdvisorConfig.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAdvisorConfig.java index bd9dd414a..b5780d291 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAdvisorConfig.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAdvisorConfig.java @@ -19,17 +19,10 @@ package org.springframework.cloud.sleuth.annotation; import java.lang.annotation.Annotation; import java.lang.reflect.Method; import java.util.concurrent.atomic.AtomicBoolean; -import java.util.function.Consumer; -import java.util.function.Supplier; import javax.annotation.PostConstruct; -import brave.Span; -import brave.Tracer; import org.aopalliance.aop.Advice; import org.aopalliance.intercept.MethodInvocation; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.reactivestreams.Publisher; import org.springframework.aop.ClassFilter; import org.springframework.aop.IntroductionInterceptor; import org.springframework.aop.Pointcut; @@ -42,10 +35,6 @@ import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.BeanFactoryAware; import org.springframework.core.annotation.AnnotationUtils; import org.springframework.util.ReflectionUtils; -import org.springframework.util.StringUtils; -import reactor.core.publisher.Flux; -import reactor.core.publisher.Mono; -import reactor.core.publisher.SignalType; /** * Custom pointcut advisor that picks all classes / interfaces that @@ -170,14 +159,8 @@ class SleuthAdvisorConfig extends AbstractPointcutAdvisor implements BeanFactory */ class SleuthInterceptor implements IntroductionInterceptor, BeanFactoryAware { - private static final Log logger = LogFactory.getLog(SleuthInterceptor.class); - private static final String CLASS_KEY = "class"; - private static final String METHOD_KEY = "method"; - private BeanFactory beanFactory; - private NewSpanParser newSpanParser; - private Tracer tracer; - private SpanTagAnnotationHandler spanTagAnnotationHandler; + private SleuthMethodInvocationProcessor methodInvocationProcessor; @Override public Object invoke(MethodInvocation invocation) throws Throwable { @@ -185,7 +168,6 @@ class SleuthInterceptor implements IntroductionInterceptor, BeanFactoryAware { if (method == null) { return invocation.proceed(); } - Method mostSpecificMethod = AopUtils .getMostSpecificMethod(method, invocation.getThis().getClass()); NewSpan newSpan = SleuthAnnotationUtils.findAnnotation(mostSpecificMethod, NewSpan.class); @@ -193,180 +175,14 @@ class SleuthInterceptor implements IntroductionInterceptor, BeanFactoryAware { if (newSpan == null && continueSpan == null) { return invocation.proceed(); } - - if(isReactorReturnType(method.getReturnType())){ - return proceedUnderReactorSpan(invocation, newSpan, continueSpan); - } else { - return proceedUnderSynchronousSpan(invocation, newSpan, continueSpan); - } + return methodInvocationProcessor().process(invocation, newSpan, continueSpan); } - private boolean isReactorReturnType(Class returnType) { - return Flux.class.equals(returnType) || Mono.class.equals(returnType); - } - - private Object proceedUnderSynchronousSpan( - MethodInvocation invocation, NewSpan newSpan, ContinueSpan continueSpan) throws Throwable { - Span span = tracer().currentSpan(); - //in case of @ContinueSpan and no span in tracer we start new span and should close it on completion - boolean startNewSpan = newSpan != null || span == null; - if (startNewSpan) { - span = tracer().nextSpan(); - newSpanParser().parse(invocation, newSpan, span); - span.start(); + private SleuthMethodInvocationProcessor methodInvocationProcessor() { + if (this.methodInvocationProcessor == null) { + this.methodInvocationProcessor = this.beanFactory.getBean(SleuthMethodInvocationProcessor.class); } - String log = log(continueSpan); - boolean hasLog = StringUtils.hasText(log); - try (Tracer.SpanInScope ws = tracer().withSpanInScope(span)) { - before(invocation, span, log, hasLog); - return invocation.proceed(); - } catch (Exception e) { - onFailure(span, log, hasLog, e); - throw e; - } finally { - after(span, startNewSpan, log, hasLog); - } - } - - private Object proceedUnderReactorSpan( - MethodInvocation invocation, NewSpan newSpan, ContinueSpan continueSpan) throws Throwable{ - Span spanPrevious = tracer().currentSpan(); - //in case of @ContinueSpan and no span in tracer we start new span and should close it on completion - boolean startNewSpan = newSpan != null || spanPrevious == null; - Span span; - if (startNewSpan) { - span = tracer().nextSpan(); - newSpanParser().parse(invocation, newSpan, span); - } else { - span = spanPrevious; - } - - String log = log(continueSpan); - boolean hasLog = StringUtils.hasText(log); - - try(Tracer.SpanInScope ws = tracer().withSpanInScope(span)) { - - Publisher publisher = (Publisher) invocation.proceed(); - - Mono startSpan = Mono.defer(() -> withSpanInScope(span, () -> { - if (startNewSpan) { - span.start(); - } - - before(invocation, span, log, hasLog); - return Mono.just(span); - })); - - if(publisher instanceof Mono){ - return startSpan.flatMap(spanStarted -> ((Mono)publisher) - .doOnError(onFailureReactor(log, hasLog, spanStarted)) - .doFinally(afterReactor(startNewSpan, log, hasLog, spanStarted))) - //put span in context so it can be used by ScopePassingSpanSubscriber - .subscriberContext(context -> context.put(Span.class, span)); - } - else if(publisher instanceof Flux){ - return startSpan.flatMapMany(spanStarted -> ((Flux)publisher) - .doOnError(onFailureReactor(log, hasLog, spanStarted)) - .doFinally(afterReactor(startNewSpan, log, hasLog, spanStarted))) - //put span in context so it can be used by ScopePassingSpanSubscriber - .subscriberContext(context -> context.put(Span.class, span)); - } - else { - throw new IllegalArgumentException("Unexpected type of publisher: "+publisher.getClass()); - } - } - } - - private T withSpanInScope(Span span, Supplier supplier) { - try(Tracer.SpanInScope ws1 = tracer().withSpanInScope(span)) { - return supplier.get(); - } - } - - private Consumer afterReactor(boolean isNewSpan, String log, boolean hasLog, Span span) { - return signalType -> { - try(Tracer.SpanInScope ws = tracer().withSpanInScope(span)) { - after(span, isNewSpan, log, hasLog); - } - }; - } - - private Consumer onFailureReactor(String log, boolean hasLog, Span span) { - return throwable -> { - try(Tracer.SpanInScope ws = tracer().withSpanInScope(span)) { - onFailure(span, log, hasLog, throwable); - } - }; - } - - private void before(MethodInvocation invocation, Span span, String log, boolean hasLog) { - if (hasLog) { - logEvent(span, log + ".before"); - } - spanTagAnnotationHandler().addAnnotatedParameters(invocation); - addTags(invocation, span); - } - - private void after(Span span, boolean isNewSpan, String log, boolean hasLog) { - if (hasLog) { - logEvent(span, log + ".after"); - } - if (isNewSpan) { - span.finish(); - } - } - - private void onFailure(Span span, String log, boolean hasLog, Throwable e) { - if (logger.isDebugEnabled()) { - logger.debug("Exception occurred while trying to continue the pointcut", e); - } - if (hasLog) { - logEvent(span, log + ".afterFailure"); - } - span.error(e); - } - - private void addTags(MethodInvocation invocation, Span span) { - span.tag(CLASS_KEY, invocation.getThis().getClass().getSimpleName()); - span.tag(METHOD_KEY, invocation.getMethod().getName()); - } - - private void logEvent(Span span, String name) { - if (span == null) { - logger.warn("You were trying to continue a span which was null. Please " - + "remember that if two proxied methods are calling each other from " - + "the same class then the aspect will not be properly resolved"); - return; - } - span.annotate(name); - } - - private String log(ContinueSpan continueSpan) { - if (continueSpan != null) { - return continueSpan.log(); - } - return ""; - } - - private Tracer tracer() { - if (this.tracer == null) { - this.tracer = this.beanFactory.getBean(Tracer.class); - } - return this.tracer; - } - - private NewSpanParser newSpanParser() { - if (this.newSpanParser == null) { - this.newSpanParser = this.beanFactory.getBean(NewSpanParser.class); - } - return this.newSpanParser; - } - - private SpanTagAnnotationHandler spanTagAnnotationHandler() { - if (this.spanTagAnnotationHandler == null) { - this.spanTagAnnotationHandler = new SpanTagAnnotationHandler(this.beanFactory); - } - return this.spanTagAnnotationHandler; + return this.methodInvocationProcessor; } @Override public boolean implementsInterface(Class intf) { diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAnnotationAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAnnotationAutoConfiguration.java index 62a783918..4f8ace49b 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAnnotationAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAnnotationAutoConfiguration.java @@ -19,7 +19,9 @@ import brave.Tracing; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.boot.autoconfigure.AutoConfigureAfter; import org.springframework.boot.autoconfigure.condition.ConditionalOnBean; +import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; +import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.cloud.sleuth.autoconfig.TraceAutoConfiguration; @@ -65,4 +67,18 @@ public class SleuthAnnotationAutoConfiguration { return new SleuthAdvisorConfig(); } + @Bean + @Role(BeanDefinition.ROLE_INFRASTRUCTURE) + @ConditionalOnClass(name = "reactor.core.publisher.Flux") + SleuthMethodInvocationProcessor reactorSleuthMethodInvocationProcessor() { + return new ReactorSleuthMethodInvocationProcessor(); + } + + @Bean + @Role(BeanDefinition.ROLE_INFRASTRUCTURE) + @ConditionalOnMissingClass("reactor.core.publisher.Flux") + SleuthMethodInvocationProcessor nonReactorSleuthMethodInvocationProcessor() { + return new NonReactorSleuthMethodInvocationProcessor(); + } + } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthMethodInvocationProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthMethodInvocationProcessor.java new file mode 100644 index 000000000..a4ce3ffcb --- /dev/null +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthMethodInvocationProcessor.java @@ -0,0 +1,28 @@ +/* + * Copyright 2013-2018 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.cloud.sleuth.annotation; + +import org.aopalliance.intercept.MethodInvocation; + +/** + * @author Marcin Grzejszczak + * @since 2.1.0 + */ +interface SleuthMethodInvocationProcessor { + + Object process(MethodInvocation invocation, NewSpan newSpan, ContinueSpan continueSpan) throws Throwable; +} diff --git a/spring-cloud-sleuth-zipkin/pom.xml b/spring-cloud-sleuth-zipkin/pom.xml index 2d4729b05..9488ceb1b 100644 --- a/spring-cloud-sleuth-zipkin/pom.xml +++ b/spring-cloud-sleuth-zipkin/pom.xml @@ -161,11 +161,6 @@ reactor-core test - - org.reactivestreams - reactive-streams - test -