From 9f912d004ac48cd3ec0f704401e99d5c78d47071 Mon Sep 17 00:00:00 2001 From: ascrutae Date: Wed, 9 Aug 2017 18:06:47 +0800 Subject: [PATCH 01/12] support resttemplate plugin --- .../trace/component/ComponentsDefine.java | 5 +- apm-sniffer/apm-agent/pom.xml | 10 +++ apm-sniffer/apm-sdk-plugin/pom.xml | 1 + .../concurrent-util-4.3.x-plugin/pom.xml | 24 +++++ .../FailureCallbackInterceptor.java | 44 +++++++++ .../SuccessCallbackInterceptor.java | 41 +++++++++ .../FailureCallbackInstrumentation.java | 56 ++++++++++++ ...stenableFutureCallbackInstrumentation.java | 65 ++++++++++++++ .../SuccessCallbackInstrumentation.java | 51 +++++++++++ .../match/EitherInterfaceMatch.java | 77 ++++++++++++++++ .../concurrent/match/FailedCallbackMatch.java | 31 +++++++ .../match/ListenableFutureCallbackMatch.java | 65 ++++++++++++++ .../match/SuccessCallbackMatch.java | 32 +++++++ .../src/main/resources/skywalking-plugin.def | 3 + .../apm-sdk-plugin/spring-plugins/pom.xml | 26 ++++++ .../resttemplate-4.3.x-plugin/pom.xml | 24 +++++ .../async/FutureGetInterceptor.java | 33 +++++++ .../async/ResponseCallBackInterceptor.java | 29 ++++++ .../async/RestExecuteInterceptor.java | 51 +++++++++++ ...esponseExtractorFutureInstrumentation.java | 77 ++++++++++++++++ .../define/RestTemplateInstrumentation.java | 77 ++++++++++++++++ .../sync/RestExecuteInterceptor.java | 44 +++++++++ .../sync/RestRequestInterceptor.java | 30 +++++++ .../sync/RestResponseInterceptor.java | 34 +++++++ .../define/RestTemplateInstrumentation.java | 89 +++++++++++++++++++ .../http/client/RestRequestInterceptor.java | 26 ++++++ .../src/main/resources/skywalking-plugin.def | 3 + 27 files changed, 1047 insertions(+), 1 deletion(-) create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/pom.xml create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/FailureCallbackInstrumentation.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/ListenableFutureCallbackInstrumentation.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/SuccessCallbackInstrumentation.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/EitherInterfaceMatch.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/FailedCallbackMatch.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/ListenableFutureCallbackMatch.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/SuccessCallbackMatch.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/resources/skywalking-plugin.def create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/pom.xml create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/ResponseCallBackInterceptor.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/ResponseExtractorFutureInstrumentation.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/RestTemplateInstrumentation.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestRequestInterceptor.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestResponseInterceptor.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/define/RestTemplateInstrumentation.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/springframework/http/client/RestRequestInterceptor.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/resources/skywalking-plugin.def diff --git a/apm-network/src/main/java/org/skywalking/apm/network/trace/component/ComponentsDefine.java b/apm-network/src/main/java/org/skywalking/apm/network/trace/component/ComponentsDefine.java index 912efa40c..d70e56787 100644 --- a/apm-network/src/main/java/org/skywalking/apm/network/trace/component/ComponentsDefine.java +++ b/apm-network/src/main/java/org/skywalking/apm/network/trace/component/ComponentsDefine.java @@ -31,6 +31,8 @@ public class ComponentsDefine { public static final OfficialComponent OKHTTP = new OfficialComponent(12, "OKHttp"); + public static final OfficialComponent REST_TEMPLATE = new OfficialComponent(13, "RestTemplate"); + private static ComponentsDefine instance = new ComponentsDefine(); private String[] components; @@ -40,7 +42,7 @@ public class ComponentsDefine { } public ComponentsDefine() { - components = new String[13]; + components = new String[14]; addComponent(TOMCAT); addComponent(HTTPCLIENT); addComponent(DUBBO); @@ -53,6 +55,7 @@ public class ComponentsDefine { addComponent(RESIN); addComponent(FEIGN); addComponent(OKHTTP); + addComponent(REST_TEMPLATE); } private void addComponent(OfficialComponent component) { diff --git a/apm-sniffer/apm-agent/pom.xml b/apm-sniffer/apm-agent/pom.xml index b07bef698..11c5388f8 100644 --- a/apm-sniffer/apm-agent/pom.xml +++ b/apm-sniffer/apm-agent/pom.xml @@ -80,6 +80,16 @@ apm-feign-default-http-9.x-plugin ${project.version} + + org.skywalking + apm-resttemplate-plugin + ${project.version} + + + org.skywalking + apm-spring-concurrent-util-plugin + ${project.version} + diff --git a/apm-sniffer/apm-sdk-plugin/pom.xml b/apm-sniffer/apm-sdk-plugin/pom.xml index 97bf4117a..1b06f19d8 100644 --- a/apm-sniffer/apm-sdk-plugin/pom.xml +++ b/apm-sniffer/apm-sdk-plugin/pom.xml @@ -22,6 +22,7 @@ okhttp-3.x-plugin resin-3.x-plugin resin-4.x-plugin + spring-plugins pom diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/pom.xml b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/pom.xml new file mode 100644 index 000000000..2e3fd3b4f --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/pom.xml @@ -0,0 +1,24 @@ + + + spring-plugins + org.skywalking + 3.2-2017 + + 4.0.0 + + apm-spring-concurrent-util-plugin + jar + + concurrent-util-4.3.x-plugin + http://maven.apache.org + + + + org.springframework + spring-core + 4.3.8.RELEASE + provided + + + diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java new file mode 100644 index 000000000..56ae40584 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java @@ -0,0 +1,44 @@ +package org.skywalking.apm.plugin.spring.concurrent; + +import java.net.URI; +import org.skywalking.apm.agent.core.context.ContextManager; +import org.skywalking.apm.agent.core.context.ContextSnapshot; +import org.skywalking.apm.agent.core.context.tag.Tags; +import org.skywalking.apm.agent.core.context.trace.AbstractSpan; +import org.skywalking.apm.agent.core.context.trace.SpanLayer; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; +import org.skywalking.apm.network.trace.component.ComponentsDefine; + +public class FailureCallbackInterceptor implements InstanceMethodsAroundInterceptor { + + @Override + public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + Object[] cacheValues = (Object[])objInst.getSkyWalkingDynamicField(); + if (cacheValues == null) { + return; + } + + URI uri = (URI)cacheValues[0]; + AbstractSpan span = ContextManager.createLocalSpan("future/failureCallback:" + uri.getPath()); + span.errorOccurred().log((Throwable)allArguments[0]).setComponent(ComponentsDefine.REST_TEMPLATE).setLayer(SpanLayer.HTTP); + Tags.URL.set(span, uri.getPath()); + ContextManager.continued((ContextSnapshot)cacheValues[2]); + } + + @Override + public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Object ret) throws Throwable { + ContextManager.stopSpan(); + return ret; + } + + @Override + public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Throwable t) { + ContextManager.activeSpan().errorOccurred().log(t); + } + +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java new file mode 100644 index 000000000..482a88638 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java @@ -0,0 +1,41 @@ +package org.skywalking.apm.plugin.spring.concurrent; + +import java.net.URI; +import org.skywalking.apm.agent.core.context.ContextManager; +import org.skywalking.apm.agent.core.context.ContextSnapshot; +import org.skywalking.apm.agent.core.context.tag.Tags; +import org.skywalking.apm.agent.core.context.trace.AbstractSpan; +import org.skywalking.apm.agent.core.context.trace.SpanLayer; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; +import org.skywalking.apm.network.trace.component.ComponentsDefine; + +public class SuccessCallbackInterceptor implements InstanceMethodsAroundInterceptor { + + @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + Object[] cacheValues = (Object[])objInst.getSkyWalkingDynamicField(); + if (cacheValues == null) { + return; + } + + URI uri = (URI)cacheValues[0]; + AbstractSpan span = ContextManager.createLocalSpan("future/successCallback:" + uri.getPath()); + span.setComponent(ComponentsDefine.REST_TEMPLATE).setLayer(SpanLayer.HTTP); + Tags.URL.set(span, uri.getPath()); + ContextManager.continued((ContextSnapshot)cacheValues[2]); + } + + @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Object ret) throws Throwable { + ContextManager.stopSpan(); + return ret; + } + + @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Throwable t) { + ContextManager.activeSpan().errorOccurred().log(t); + } + +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/FailureCallbackInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/FailureCallbackInstrumentation.java new file mode 100644 index 000000000..27d79b566 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/FailureCallbackInstrumentation.java @@ -0,0 +1,56 @@ +package org.skywalking.apm.plugin.spring.concurrent.define; + +import net.bytebuddy.description.method.MethodDescription; +import net.bytebuddy.matcher.ElementMatcher; +import org.skywalking.apm.agent.core.plugin.interceptor.ConstructorInterceptPoint; +import org.skywalking.apm.agent.core.plugin.interceptor.InstanceMethodsInterceptPoint; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.ClassInstanceMethodsEnhancePluginDefine; +import org.skywalking.apm.agent.core.plugin.match.ClassMatch; +import org.skywalking.apm.plugin.spring.concurrent.FailureCallbackInterceptor; + +import static net.bytebuddy.matcher.ElementMatchers.named; +import static org.skywalking.apm.plugin.spring.concurrent.match.FailedCallbackMatch.failedCallbackMatch; + +/** + * {@link FailureCallbackInstrumentation} enhance the onFailure method that class inherited + * org.springframework.util.concurrent.FailureCallback by {@link FailureCallbackInterceptor}. + * + * @author zhangxin + */ +public class FailureCallbackInstrumentation extends ClassInstanceMethodsEnhancePluginDefine { + + public static final String FAILURE_CALLBACK_INTERCEPTOR = "org.skywalking.apm.plugin.spring.concurrent.FailureCallbackInterceptor"; + public static final String FAILURE_METHOD_NAME = "onFailure"; + + @Override + protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() { + return new ConstructorInterceptPoint[0]; + } + + @Override + protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() { + return new InstanceMethodsInterceptPoint[] { + new InstanceMethodsInterceptPoint() { + @Override + public ElementMatcher getMethodsMatcher() { + return named(FAILURE_METHOD_NAME); + } + + @Override + public String getMethodsInterceptor() { + return FAILURE_CALLBACK_INTERCEPTOR; + } + + @Override + public boolean isOverrideArgs() { + return false; + } + } + }; + } + + @Override + protected ClassMatch enhanceClass() { + return failedCallbackMatch(); + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/ListenableFutureCallbackInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/ListenableFutureCallbackInstrumentation.java new file mode 100644 index 000000000..74ebbcad7 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/ListenableFutureCallbackInstrumentation.java @@ -0,0 +1,65 @@ +package org.skywalking.apm.plugin.spring.concurrent.define; + +import net.bytebuddy.description.method.MethodDescription; +import net.bytebuddy.matcher.ElementMatcher; +import org.skywalking.apm.agent.core.plugin.interceptor.ConstructorInterceptPoint; +import org.skywalking.apm.agent.core.plugin.interceptor.InstanceMethodsInterceptPoint; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.ClassInstanceMethodsEnhancePluginDefine; +import org.skywalking.apm.agent.core.plugin.match.ClassMatch; +import org.skywalking.apm.plugin.spring.concurrent.FailureCallbackInterceptor; +import org.skywalking.apm.plugin.spring.concurrent.SuccessCallbackInterceptor; + +import static net.bytebuddy.matcher.ElementMatchers.named; +import static org.skywalking.apm.plugin.spring.concurrent.match.ListenableFutureCallbackMatch.listenableFutureCallbackMatch; + +/** + * {@link ListenableFutureCallbackInstrumentation} enhance onSuccess method and oonFailure + * that class inherited org.springframework.util.concurrent.ListenableFutureCallback by {@link + * SuccessCallbackInterceptor} and {@link FailureCallbackInterceptor }. + * + * @author zhangxin + */ +public class ListenableFutureCallbackInstrumentation extends ClassInstanceMethodsEnhancePluginDefine { + @Override protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() { + return new ConstructorInterceptPoint[0]; + } + + @Override protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() { + return new InstanceMethodsInterceptPoint[] { + new InstanceMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(SuccessCallbackInstrumentation.SUCCESS_METHOD_NAME); + } + + @Override public String getMethodsInterceptor() { + return SuccessCallbackInstrumentation.SUCCESS_CALLBACK_INTERCEPTOR; + } + + @Override public boolean isOverrideArgs() { + return false; + } + }, + new InstanceMethodsInterceptPoint() { + + @Override + public ElementMatcher getMethodsMatcher() { + return named(FailureCallbackInstrumentation.FAILURE_METHOD_NAME); + } + + @Override + public String getMethodsInterceptor() { + return FailureCallbackInstrumentation.FAILURE_CALLBACK_INTERCEPTOR; + } + + @Override + public boolean isOverrideArgs() { + return false; + } + } + }; + } + + @Override protected ClassMatch enhanceClass() { + return listenableFutureCallbackMatch(); + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/SuccessCallbackInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/SuccessCallbackInstrumentation.java new file mode 100644 index 000000000..4be5c3381 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/SuccessCallbackInstrumentation.java @@ -0,0 +1,51 @@ +package org.skywalking.apm.plugin.spring.concurrent.define; + +import net.bytebuddy.description.method.MethodDescription; +import net.bytebuddy.matcher.ElementMatcher; +import org.skywalking.apm.agent.core.plugin.interceptor.ConstructorInterceptPoint; +import org.skywalking.apm.agent.core.plugin.interceptor.InstanceMethodsInterceptPoint; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.ClassInstanceMethodsEnhancePluginDefine; +import org.skywalking.apm.agent.core.plugin.match.ClassMatch; +import org.skywalking.apm.plugin.spring.concurrent.FailureCallbackInterceptor; +import org.skywalking.apm.plugin.spring.concurrent.SuccessCallbackInterceptor; + +import static net.bytebuddy.matcher.ElementMatchers.named; +import static org.skywalking.apm.plugin.spring.concurrent.match.SuccessCallbackMatch.successCallbackMatch; + +/** + * {@link SuccessCallbackInstrumentation} enhance the onSuccess method that class inherited + * org.springframework.util.concurrent.SuccessCallback by {@link SuccessCallbackInterceptor}. + * + * @author zhangxin + */ +public class SuccessCallbackInstrumentation extends ClassInstanceMethodsEnhancePluginDefine { + + public static final String SUCCESS_CALLBACK_INTERCEPTOR = "org.skywalking.apm.plugin.spring.concurrent.SuccessCallbackInterceptor"; + public static final String SUCCESS_METHOD_NAME = "onSuccess"; + + @Override protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() { + return new ConstructorInterceptPoint[0]; + } + + @Override protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() { + return new InstanceMethodsInterceptPoint[] { + new InstanceMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(SUCCESS_METHOD_NAME); + } + + @Override public String getMethodsInterceptor() { + return SUCCESS_CALLBACK_INTERCEPTOR; + } + + @Override public boolean isOverrideArgs() { + return false; + } + } + }; + } + + @Override protected ClassMatch enhanceClass() { + return successCallbackMatch(); + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/EitherInterfaceMatch.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/EitherInterfaceMatch.java new file mode 100644 index 000000000..1396c6d20 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/EitherInterfaceMatch.java @@ -0,0 +1,77 @@ +package org.skywalking.apm.plugin.spring.concurrent.match; + +import net.bytebuddy.description.type.TypeDescription; +import net.bytebuddy.matcher.ElementMatcher; +import org.skywalking.apm.agent.core.plugin.match.IndirectMatch; + +import static net.bytebuddy.matcher.ElementMatchers.hasSuperType; +import static net.bytebuddy.matcher.ElementMatchers.nameStartsWith; +import static net.bytebuddy.matcher.ElementMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.not; + +/** + * {@link EitherInterfaceMatch} match the class inherited {@link #getMatchInterface() } and not inherited {@link + * #getMutexInterface()} + * + * @author zhangxin + */ +public abstract class EitherInterfaceMatch implements IndirectMatch { + + private static final String SPRING_PACKAGE_PREFIX = "org.springframework"; + private static final String OBJECT_CLASS_NAME = "java.lang.Object"; + + protected EitherInterfaceMatch() { + + } + + @Override + public ElementMatcher.Junction buildJunction() { + return not(nameStartsWith(SPRING_PACKAGE_PREFIX)). + and(hasSuperType(named(getMatchInterface()))) + .and(not(hasSuperType(named(getMutexInterface())))); + } + + @Override + public boolean isMatch(TypeDescription typeDescription) { + MatchResult matchResult = new MatchResult(); + for (TypeDescription.Generic generic : typeDescription.getInterfaces()) { + matchHierarchyClazz(generic, matchResult); + } + + matchHierarchyClazz(typeDescription.getSuperClass(), matchResult); + return matchResult.result(); + } + + public abstract String getMatchInterface(); + + public abstract String getMutexInterface(); + + private void matchHierarchyClazz(TypeDescription.Generic clazz, MatchResult matchResult) { + if (clazz.asRawType().getTypeName().equals(getMutexInterface())) { + matchResult.findMutexInterface = true; + return; + } + + if (clazz.asRawType().getTypeName().equals(getMatchInterface())) { + matchResult.findMatchInterface = true; + } + + for (TypeDescription.Generic generic : clazz.getInterfaces()) { + matchHierarchyClazz(generic, matchResult); + } + + TypeDescription.Generic superClazz = clazz.getSuperClass(); + if (superClazz != null && !clazz.getTypeName().equals(OBJECT_CLASS_NAME)) { + matchHierarchyClazz(superClazz, matchResult); + } + } + + private static class MatchResult { + private boolean findMatchInterface = false; + private boolean findMutexInterface = false; + + public boolean result() { + return findMatchInterface && !findMutexInterface; + } + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/FailedCallbackMatch.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/FailedCallbackMatch.java new file mode 100644 index 000000000..abcfde249 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/FailedCallbackMatch.java @@ -0,0 +1,31 @@ +package org.skywalking.apm.plugin.spring.concurrent.match; + +import org.skywalking.apm.agent.core.plugin.match.ClassMatch; + +/** + * {@link FailedCallbackMatch} match the class that inherited org.springframework.util.concurrent.FailureCallback + * and not inherited org.springframework.util.concurrent.SuccessCallback + * + * @author zhangxin + */ +public class FailedCallbackMatch extends EitherInterfaceMatch { + + private static final String MATCH_INTERFACE = "org.springframework.util.concurrent.FailureCallback"; + private static final String MUTEX_INTERFACE = "org.springframework.util.concurrent.SuccessCallback"; + + private FailedCallbackMatch() { + + } + + @Override public String getMatchInterface() { + return MATCH_INTERFACE; + } + + @Override public String getMutexInterface() { + return MUTEX_INTERFACE; + } + + public static ClassMatch failedCallbackMatch() { + return new FailedCallbackMatch(); + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/ListenableFutureCallbackMatch.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/ListenableFutureCallbackMatch.java new file mode 100644 index 000000000..a18cf6f01 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/ListenableFutureCallbackMatch.java @@ -0,0 +1,65 @@ +package org.skywalking.apm.plugin.spring.concurrent.match; + +import net.bytebuddy.description.type.TypeDescription; +import net.bytebuddy.matcher.ElementMatcher; +import org.skywalking.apm.agent.core.plugin.match.ClassMatch; +import org.skywalking.apm.agent.core.plugin.match.IndirectMatch; + +import static net.bytebuddy.matcher.ElementMatchers.hasSuperType; +import static net.bytebuddy.matcher.ElementMatchers.nameStartsWith; +import static net.bytebuddy.matcher.ElementMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.not; + +/** + * {@link ListenableFutureCallbackMatch} match the class that inherited org.springframework.util.concurrent.ListenableFutureCallback. + * + * @author zhangxin + */ +public class ListenableFutureCallbackMatch implements IndirectMatch { + + private static final String LISTENABLE_FUTURE_CALLBACK_CLASS_NAME = "org.springframework.util.concurrent.ListenableFutureCallback"; + + private ListenableFutureCallbackMatch() { + + } + + @Override + public ElementMatcher.Junction buildJunction() { + return not(nameStartsWith("org.springframework")). + and(hasSuperType(named(LISTENABLE_FUTURE_CALLBACK_CLASS_NAME))); + } + + @Override + public boolean isMatch(TypeDescription typeDescription) { + boolean isMatch = false; + for (TypeDescription.Generic generic : typeDescription.getInterfaces()) { + isMatch = isMatch || matchExactClass(generic); + } + + return isMatch || matchExactClass(typeDescription.getSuperClass()); + } + + private boolean matchExactClass(TypeDescription.Generic clazz) { + if (clazz.asRawType().getTypeName().equals(LISTENABLE_FUTURE_CALLBACK_CLASS_NAME)) { + return true; + } + + boolean isMatch = false; + for (TypeDescription.Generic generic : clazz.getInterfaces()) { + isMatch = isMatch || matchExactClass(generic); + } + + if (!isMatch) { + TypeDescription.Generic superClazz = clazz.getSuperClass(); + if (superClazz != null && !clazz.getTypeName().equals("java.lang.Object")) { + isMatch = isMatch || matchExactClass(superClazz); + } + } + + return isMatch; + } + + public static ClassMatch listenableFutureCallbackMatch() { + return new ListenableFutureCallbackMatch(); + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/SuccessCallbackMatch.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/SuccessCallbackMatch.java new file mode 100644 index 000000000..309767198 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/SuccessCallbackMatch.java @@ -0,0 +1,32 @@ +package org.skywalking.apm.plugin.spring.concurrent.match; + +import org.skywalking.apm.agent.core.plugin.match.ClassMatch; + +/** + * {@link SuccessCallbackMatch} match the class that inherited org.springframework.util.concurrent.SuccessCallback + * and not inherited org.springframework.util.concurrent.FailureCallback + * + * @author zhangxin + */ +public class SuccessCallbackMatch extends EitherInterfaceMatch { + + private static final String MATCH_INTERFACE = "org.springframework.util.concurrent.SuccessCallback"; + private static final String MUTEX_INTERFACE = "org.springframework.util.concurrent.FailureCallback"; + + private SuccessCallbackMatch() { + } + + @Override + public String getMatchInterface() { + return MATCH_INTERFACE; + } + + @Override + public String getMutexInterface() { + return MUTEX_INTERFACE; + } + + public static ClassMatch successCallbackMatch() { + return new SuccessCallbackMatch(); + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/resources/skywalking-plugin.def b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/resources/skywalking-plugin.def new file mode 100644 index 000000000..8c9426546 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/resources/skywalking-plugin.def @@ -0,0 +1,3 @@ +spring-concurrent-util-4.3.8=org.skywalking.apm.plugin.spring.concurrent.define.FailureCallbackInstrumentation +spring-concurrent-util-4.3.8=org.skywalking.apm.plugin.spring.concurrent.define.SuccessCallbackInstrumentation +spring-concurrent-util-4.3.8=org.skywalking.apm.plugin.spring.concurrent.define.ListenableFutureCallbackInstrumentation diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml b/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml new file mode 100644 index 000000000..a7558877d --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml @@ -0,0 +1,26 @@ + + + 4.0.0 + + + org.skywalking + apm-sdk-plugin + 3.2-2017 + + + spring-plugins + + concurrent-util-4.3.x-plugin + resttemplate-4.3.x-plugin + + pom + + apm-sdk-plugin + http://maven.apache.org + + + UTF-8 + + + diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/pom.xml b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/pom.xml new file mode 100644 index 000000000..3dde8eb50 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/pom.xml @@ -0,0 +1,24 @@ + + + spring-plugins + org.skywalking + 3.2-2017 + + 4.0.0 + + apm-resttemplate-plugin + jar + + resttemplate-4.3.x-plugin + http://maven.apache.org + + + + org.springframework + spring-web + 4.3.8.RELEASE + provided + + + diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java new file mode 100644 index 000000000..102ba4e3b --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java @@ -0,0 +1,33 @@ +package org.skywalking.apm.plugin.spring.resttemplate.async; + +import com.google.instrumentation.trace.Span; +import java.net.URI; +import java.util.List; +import org.skywalking.apm.agent.core.context.ContextManager; +import org.skywalking.apm.agent.core.context.trace.AbstractSpan; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; + +public class FutureGetInterceptor implements InstanceMethodsAroundInterceptor { + @Override + public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + List cacheValues = (List)objInst.getSkyWalkingDynamicField(); + ContextManager.createLocalSpan("future/get:" + ((URI)cacheValues.get(0)).getPath()); + } + + @Override + public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Object ret) throws Throwable { + ContextManager.stopSpan(); + return ret; + } + + @Override + public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Throwable t) { + AbstractSpan activeSpan = ContextManager.activeSpan(); + activeSpan.errorOccurred().log(t); + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/ResponseCallBackInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/ResponseCallBackInterceptor.java new file mode 100644 index 000000000..ab4cc2dd8 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/ResponseCallBackInterceptor.java @@ -0,0 +1,29 @@ +package org.skywalking.apm.plugin.spring.resttemplate.async; + +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; + +public class ResponseCallBackInterceptor implements InstanceMethodsAroundInterceptor { + + @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + EnhancedInstance successCallBak = (EnhancedInstance)allArguments[0]; + successCallBak.setSkyWalkingDynamicField(objInst.getSkyWalkingDynamicField()); + + if (allArguments.length == 2) { + EnhancedInstance failedCallBack = (EnhancedInstance)allArguments[1]; + failedCallBack.setSkyWalkingDynamicField(objInst.getSkyWalkingDynamicField()); + } + } + + @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Object ret) throws Throwable { + return ret; + } + + @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Throwable t) { + + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java new file mode 100644 index 000000000..378ad6da6 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java @@ -0,0 +1,51 @@ +package org.skywalking.apm.plugin.spring.resttemplate.async; + +import java.net.URI; +import org.skywalking.apm.agent.core.context.ContextCarrier; +import org.skywalking.apm.agent.core.context.ContextManager; +import org.skywalking.apm.agent.core.context.tag.Tags; +import org.skywalking.apm.agent.core.context.trace.AbstractSpan; +import org.skywalking.apm.agent.core.context.trace.SpanLayer; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; +import org.skywalking.apm.network.trace.component.ComponentsDefine; +import org.springframework.http.HttpMethod; + +public class RestExecuteInterceptor implements InstanceMethodsAroundInterceptor { + + @Override + public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + final URI requestURL = (URI)allArguments[0]; + final HttpMethod httpMethod = (HttpMethod)allArguments[1]; + final ContextCarrier contextCarrier = new ContextCarrier(); + String remotePeer = requestURL.getHost() + ":" + requestURL.getPort(); + AbstractSpan span = ContextManager.createExitSpan(requestURL.getPath(), contextCarrier, remotePeer); + + span.setComponent(ComponentsDefine.REST_TEMPLATE); + Tags.URL.set(span, requestURL.getScheme() + "://" + requestURL.getHost() + ":" + requestURL.getPort() + requestURL.getPath()); + Tags.HTTP.METHOD.set(span, httpMethod.toString()); + SpanLayer.asHttp(span); + Object[] cacheValues = new Object[3]; + cacheValues[0] = requestURL; + cacheValues[1] = contextCarrier.serialize(); + objInst.setSkyWalkingDynamicField(cacheValues); + } + + @Override + public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Object ret) throws Throwable { + Object[] cacheValues = (Object[])objInst.getSkyWalkingDynamicField(); + cacheValues[3] = ContextManager.capture(); + ((EnhancedInstance)ret).setSkyWalkingDynamicField(cacheValues); + ContextManager.stopSpan(); + return ret; + } + + @Override + public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Throwable t) { + ContextManager.activeSpan().errorOccurred().log(t); + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/ResponseExtractorFutureInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/ResponseExtractorFutureInstrumentation.java new file mode 100644 index 000000000..858fe5a7f --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/ResponseExtractorFutureInstrumentation.java @@ -0,0 +1,77 @@ +package org.skywalking.apm.plugin.spring.resttemplate.async.define; + +import java.net.URI; +import net.bytebuddy.description.method.MethodDescription; +import net.bytebuddy.matcher.ElementMatcher; +import org.skywalking.apm.agent.core.context.ContextSnapshot; +import org.skywalking.apm.agent.core.plugin.interceptor.ConstructorInterceptPoint; +import org.skywalking.apm.agent.core.plugin.interceptor.InstanceMethodsInterceptPoint; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.ClassInstanceMethodsEnhancePluginDefine; +import org.skywalking.apm.agent.core.plugin.match.ClassMatch; +import org.skywalking.apm.plugin.spring.resttemplate.async.ResponseCallBackInterceptor; + +import static net.bytebuddy.matcher.ElementMatchers.named; +import static org.skywalking.apm.agent.core.plugin.match.NameMatch.byName; + +/** + * {@link ResponseExtractorFutureInstrumentation} enhance the addCallback method and get method of + * org.springframework.web.client.AsyncRestTemplate$ResponseExtractorFuture by + * org.skywalking.apm.plugin.spring.resttemplate.async.ResponseCallBackInterceptor and + * org.skywalking.apm.plugin.spring.resttemplate.async.FutureGetInterceptor. + * + * {@link ResponseCallBackInterceptor} set the {@link URI} and {@link ContextSnapshot} to inherited + * org.springframework.util.concurrent.SuccessCallback and org.springframework.util.concurrent.FailureCallback + * + * @author zhangxin + */ +public class ResponseExtractorFutureInstrumentation extends ClassInstanceMethodsEnhancePluginDefine { + + private static final String ADD_CALLBACK_METHOD_NAME = "addCallback"; + private static final String ADD_CALLBACK_INTERCEPTOR = "org.skywalking.apm.plugin.spring.resttemplate.async.ResponseCallBackInterceptor"; + private static final String ENHANCE_CLASS = "org.springframework.web.client.AsyncRestTemplate$ResponseExtractorFuture"; + private static final String GET_METHOD_INTERCEPTOR = "org.skywalking.apm.plugin.spring.resttemplate.async.FutureGetInterceptor"; + private static final String GET_METHOD_NAME = "get"; + + @Override + protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() { + return new ConstructorInterceptPoint[0]; + + } + + @Override + protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() { + return new InstanceMethodsInterceptPoint[] { + new InstanceMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(ADD_CALLBACK_METHOD_NAME); + } + + @Override public String getMethodsInterceptor() { + return ADD_CALLBACK_INTERCEPTOR; + } + + @Override public boolean isOverrideArgs() { + return false; + } + }, + new InstanceMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(GET_METHOD_NAME); + } + + @Override public String getMethodsInterceptor() { + return GET_METHOD_INTERCEPTOR; + } + + @Override public boolean isOverrideArgs() { + return false; + } + } + }; + } + + @Override + protected ClassMatch enhanceClass() { + return byName(ENHANCE_CLASS); + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/RestTemplateInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/RestTemplateInstrumentation.java new file mode 100644 index 000000000..622ee4fe8 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/RestTemplateInstrumentation.java @@ -0,0 +1,77 @@ +package org.skywalking.apm.plugin.spring.resttemplate.async.define; + +import java.net.URI; +import net.bytebuddy.description.method.MethodDescription; +import net.bytebuddy.matcher.ElementMatcher; +import org.skywalking.apm.agent.core.context.ContextSnapshot; +import org.skywalking.apm.agent.core.plugin.interceptor.ConstructorInterceptPoint; +import org.skywalking.apm.agent.core.plugin.interceptor.InstanceMethodsInterceptPoint; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.ClassInstanceMethodsEnhancePluginDefine; +import org.skywalking.apm.agent.core.plugin.match.ClassMatch; +import org.skywalking.apm.plugin.spring.resttemplate.async.FutureGetInterceptor; +import org.skywalking.apm.plugin.spring.resttemplate.async.ResponseCallBackInterceptor; + +import static net.bytebuddy.matcher.ElementMatchers.named; +import static org.skywalking.apm.agent.core.plugin.match.NameMatch.byName; + +/** + * {@link RestTemplateInstrumentation} enhance the doExecute method and createAsyncRequest + * method of org.springframework.web.client.AsyncRestTemplate by org.skywalking.apm.plugin.spring.resttemplate.async.RestExecuteInterceptor + * and org.springframework.http.client.RestRequestInterceptor. + * + * org.springframework.http.client.RestRequestInterceptor set {@link URI} and {@link ContextSnapshot} to + * org.springframework.web.client.AsyncRestTemplate$ResponseExtractorFuture for propagate trace context + * after execute doExecute . + * + * @author zhangxin + */ +public class RestTemplateInstrumentation extends ClassInstanceMethodsEnhancePluginDefine { + + private static final String ENHANCE_CLASS = "org.springframework.web.client.AsyncRestTemplate"; + private static final String DO_EXECUTE_METHOD_NAME = "doExecute"; + private static final String DO_EXECUTE_INTERCEPTOR = "org.skywalking.apm.plugin.spring.resttemplate.async.RestExecuteInterceptor"; + private static final String CREATE_REQUEST_METHOD_NAME = "createAsyncRequest"; + private static final String CREATE_REQUEST_INTERCEPTOR = "org.springframework.http.client.RestRequestInterceptor"; + + @Override + protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() { + return new ConstructorInterceptPoint[0]; + } + + @Override + protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() { + return new InstanceMethodsInterceptPoint[] { + new InstanceMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(DO_EXECUTE_METHOD_NAME); + } + + @Override public String getMethodsInterceptor() { + return DO_EXECUTE_INTERCEPTOR; + } + + @Override public boolean isOverrideArgs() { + return false; + } + }, + new InstanceMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(CREATE_REQUEST_METHOD_NAME); + } + + @Override public String getMethodsInterceptor() { + return CREATE_REQUEST_INTERCEPTOR; + } + + @Override public boolean isOverrideArgs() { + return false; + } + } + }; + } + + @Override + protected ClassMatch enhanceClass() { + return byName(ENHANCE_CLASS); + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java new file mode 100644 index 000000000..0fb1bec8f --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java @@ -0,0 +1,44 @@ +package org.skywalking.apm.plugin.spring.resttemplate.sync; + +import java.net.URI; +import org.skywalking.apm.agent.core.context.ContextCarrier; +import org.skywalking.apm.agent.core.context.ContextManager; +import org.skywalking.apm.agent.core.context.tag.Tags; +import org.skywalking.apm.agent.core.context.trace.AbstractSpan; +import org.skywalking.apm.agent.core.context.trace.SpanLayer; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; +import org.skywalking.apm.network.trace.component.ComponentsDefine; +import org.springframework.http.HttpMethod; + +public class RestExecuteInterceptor implements InstanceMethodsAroundInterceptor { + @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + + final URI requestURL = (URI)allArguments[0]; + final HttpMethod httpMethod = (HttpMethod)allArguments[1]; + final ContextCarrier contextCarrier = new ContextCarrier(); + String remotePeer = requestURL.getHost() + ":" + requestURL.getPort(); + AbstractSpan span = ContextManager.createExitSpan(requestURL.getPath(), contextCarrier, remotePeer); + + span.setComponent(ComponentsDefine.REST_TEMPLATE); + Tags.URL.set(span, requestURL.getScheme() + "://" + requestURL.getHost() + ":" + requestURL.getPort() + requestURL.getPath()); + Tags.HTTP.METHOD.set(span, httpMethod.toString()); + SpanLayer.asHttp(span); + + objInst.setSkyWalkingDynamicField(contextCarrier.serialize()); + } + + @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Object ret) throws Throwable { + ContextManager.stopSpan(); + return ret; + } + + @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Throwable t) { + ContextManager.activeSpan().errorOccurred().log(t); + + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestRequestInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestRequestInterceptor.java new file mode 100644 index 000000000..ad8b709d3 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestRequestInterceptor.java @@ -0,0 +1,30 @@ +package org.skywalking.apm.plugin.spring.resttemplate.sync; + +import org.skywalking.apm.agent.core.conf.Config; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; +import org.springframework.http.client.AbstractClientHttpRequest; +import org.springframework.http.client.ClientHttpRequest; + +public class RestRequestInterceptor implements InstanceMethodsAroundInterceptor { + @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + + } + + @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Object ret) throws Throwable { + ClientHttpRequest clientHttpRequest = (ClientHttpRequest)ret; + if (clientHttpRequest instanceof AbstractClientHttpRequest) { + AbstractClientHttpRequest httpRequest = (AbstractClientHttpRequest)clientHttpRequest; + httpRequest.getHeaders().set(Config.Plugin.Propagation.HEADER_NAME, String.valueOf(objInst.getSkyWalkingDynamicField())); + } + return ret; + } + + @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Throwable t) { + + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestResponseInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestResponseInterceptor.java new file mode 100644 index 000000000..f15bc56e8 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestResponseInterceptor.java @@ -0,0 +1,34 @@ +package org.skywalking.apm.plugin.spring.resttemplate.sync; + +import org.skywalking.apm.agent.core.context.ContextManager; +import org.skywalking.apm.agent.core.context.tag.Tags; +import org.skywalking.apm.agent.core.context.trace.AbstractSpan; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; +import org.springframework.http.client.ClientHttpResponse; + +public class RestResponseInterceptor implements InstanceMethodsAroundInterceptor { + @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + + } + + @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Object ret) throws Throwable { + + ClientHttpResponse response = (ClientHttpResponse)allArguments[2]; + int statusCode = response.getStatusCode().value(); + AbstractSpan span = ContextManager.activeSpan(); + if (statusCode >= 400) { + span.errorOccurred(); + Tags.STATUS_CODE.set(span, Integer.toString(statusCode)); + } + return ret; + } + + @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Throwable t) { + ContextManager.activeSpan().errorOccurred().log(t); + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/define/RestTemplateInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/define/RestTemplateInstrumentation.java new file mode 100644 index 000000000..9fb529bf1 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/define/RestTemplateInstrumentation.java @@ -0,0 +1,89 @@ +package org.skywalking.apm.plugin.spring.resttemplate.sync.define; + +import net.bytebuddy.description.method.MethodDescription; +import net.bytebuddy.matcher.ElementMatcher; +import org.skywalking.apm.agent.core.plugin.interceptor.ConstructorInterceptPoint; +import org.skywalking.apm.agent.core.plugin.interceptor.InstanceMethodsInterceptPoint; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.ClassInstanceMethodsEnhancePluginDefine; +import org.skywalking.apm.agent.core.plugin.match.ClassMatch; + +import static net.bytebuddy.matcher.ElementMatchers.named; +import static org.skywalking.apm.agent.core.plugin.match.NameMatch.byName; + +/** + * {@link RestTemplateInstrumentation} enhance the doExecute method,handleResponse method and + * handleResponse method of org.springframework.web.client.RestTemplate by + * org.skywalking.apm.plugin.spring.resttemplate.sync.RestExecuteInterceptor, + * org.skywalking.apm.plugin.spring.resttemplate.sync.RestResponseInterceptor and + * org.skywalking.apm.plugin.spring.resttemplate.sync.RestRequestInterceptor. + * + * org.skywalking.apm.plugin.spring.resttemplate.sync.RestResponseInterceptor set context to header for + * propagate trace context after execute createRequest. + * + * @author zhangxin + */ +public class RestTemplateInstrumentation extends ClassInstanceMethodsEnhancePluginDefine { + + private static final String ENHANCE_CLASS = "org.springframework.web.client.RestTemplate"; + private static final String DO_EXECUTE_METHOD_NAME = "doExecute"; + private static final String DO_EXECUTE_INTERCEPTOR = "org.skywalking.apm.plugin.spring.resttemplate.sync.RestExecuteInterceptor"; + private static final String HANDLE_REQUEST_METHOD_NAME = "handleResponse"; + private static final String HAND_REQUEST_INTERCEPTOR = "org.skywalking.apm.plugin.spring.resttemplate.sync.RestResponseInterceptor"; + private static final String CREATE_REQUEST_METHOD_NAME = "createRequest"; + private static final String CREATE_REQUEST_INTERCEPTOR = "org.skywalking.apm.plugin.spring.resttemplate.sync.RestRequestInterceptor"; + + @Override + protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() { + return new ConstructorInterceptPoint[0]; + } + + @Override + protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() { + return new InstanceMethodsInterceptPoint[] { + new InstanceMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(DO_EXECUTE_METHOD_NAME); + } + + @Override public String getMethodsInterceptor() { + return DO_EXECUTE_INTERCEPTOR; + } + + @Override public boolean isOverrideArgs() { + return false; + } + }, + new InstanceMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(HANDLE_REQUEST_METHOD_NAME); + } + + @Override public String getMethodsInterceptor() { + return HAND_REQUEST_INTERCEPTOR; + } + + @Override public boolean isOverrideArgs() { + return false; + } + }, + new InstanceMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(CREATE_REQUEST_METHOD_NAME); + } + + @Override public String getMethodsInterceptor() { + return CREATE_REQUEST_INTERCEPTOR; + } + + @Override public boolean isOverrideArgs() { + return false; + } + } + }; + } + + @Override + protected ClassMatch enhanceClass() { + return byName(ENHANCE_CLASS); + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/springframework/http/client/RestRequestInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/springframework/http/client/RestRequestInterceptor.java new file mode 100644 index 000000000..1ce1744c1 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/springframework/http/client/RestRequestInterceptor.java @@ -0,0 +1,26 @@ +package org.springframework.http.client; + +import java.util.List; +import org.skywalking.apm.agent.core.conf.Config; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; + +public class RestRequestInterceptor implements InstanceMethodsAroundInterceptor { + @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + + } + + @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Object ret) throws Throwable { + AbstractAsyncClientHttpRequest clientHttpRequest = (AbstractAsyncClientHttpRequest)ret; + clientHttpRequest.getHeaders().set(Config.Plugin.Propagation.HEADER_NAME, String.valueOf(((List)objInst.getSkyWalkingDynamicField()).get(1))); + return ret; + } + + @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + Class[] argumentsTypes, Throwable t) { + + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/resources/skywalking-plugin.def b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/resources/skywalking-plugin.def new file mode 100644 index 000000000..4b5ab45bc --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/resources/skywalking-plugin.def @@ -0,0 +1,3 @@ +spring-resttemplate-4.3.8=org.skywalking.apm.plugin.spring.resttemplate.async.define.RestTemplateInstrumentation +spring-resttemplate-4.3.8=org.skywalking.apm.plugin.spring.resttemplate.async.define.ResponseExtractorFutureInstrumentation +spring-resttemplate-4.3.8=org.skywalking.apm.plugin.spring.resttemplate.sync.define.RestTemplateInstrumentation From 6aebdcdbc617bd7402660b4b94909e3043791466 Mon Sep 17 00:00:00 2001 From: pengys5 <8082209@qq.com> Date: Wed, 9 Aug 2017 22:45:46 +0800 Subject: [PATCH 02/12] Change the data type of application instance id from int 64 to int 32 in jvm metric service --- apm-network/src/main/proto/JVMMetricsService.proto | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/apm-network/src/main/proto/JVMMetricsService.proto b/apm-network/src/main/proto/JVMMetricsService.proto index 6e5973efb..4a32135d7 100644 --- a/apm-network/src/main/proto/JVMMetricsService.proto +++ b/apm-network/src/main/proto/JVMMetricsService.proto @@ -12,7 +12,7 @@ service JVMMetricsService { message JVMMetrics { repeated JVMMetric metrics = 1; - int64 applicationInstanceId = 2; + int32 applicationInstanceId = 2; } message JVMMetric { From a897c950e2605bc7af3f28e101a3a0e7d7bdb051 Mon Sep 17 00:00:00 2001 From: wusheng Date: Thu, 10 Aug 2017 17:54:08 +0800 Subject: [PATCH 03/12] Refactor the interceptor method parameter list for SpringMVC plugin. --- .../interceptor/enhance/InstMethodsInter.java | 6 ++-- .../InstMethodsInterWithOverrideArgs.java | 6 ++-- .../InstanceMethodsAroundInterceptor.java | 13 +++++-- .../StaticMethodsAroundInterceptor.java | 12 +++++-- .../enhance/StaticMethodsInter.java | 6 ++-- .../StaticMethodsInterWithOverrideArgs.java | 6 ++-- .../apm/plugin/dubbo/DubboInterceptor.java | 7 ++-- .../plugin/dubbo/DubboInterceptorTest.java | 26 +++++++------- .../http/v9/DefaultHttpClientInterceptor.java | 11 ++++-- .../v9/DefaultHttpClientInterceptorTest.java | 14 ++++---- .../v4/HttpClientExecuteInterceptor.java | 7 ++-- .../v4/HttpClientExecuteInterceptorTest.java | 14 ++++---- .../jdbc/define/JDBCDriverInterceptor.java | 7 ++-- .../jedis/v2/JedisMethodInterceptor.java | 11 +++--- .../jedis/v2/JedisMethodInterceptorTest.java | 35 +++++++++++++++---- .../mongodb/v3/MongoDBMethodInterceptor.java | 11 +++--- .../v3/MongoDBMethodInterceptorTest.java | 26 +++++++++----- .../motan/MotanConsumerInterceptor.java | 7 ++-- .../motan/MotanProviderInterceptor.java | 7 ++-- .../motan/MotanConsumerInterceptorTest.java | 14 ++++---- .../motan/MotanProviderInterceptorTest.java | 18 +++++----- .../plugin/okhttp/v3/RealCallInterceptor.java | 11 ++++-- .../okhttp/v3/RealCallInterceptorTest.java | 14 ++++---- .../plugin/resin/v3/ResinV3Interceptor.java | 7 ++-- .../resin/v3/ResinV3InterceptorTest.java | 14 ++++---- .../plugin/resin/v4/ResinV4Interceptor.java | 7 ++-- .../resin/v4/ResinV4InterceptorTest.java | 14 ++++---- .../plugin/tomcat78x/TomcatInterceptor.java | 9 ++--- .../tomcat78x/TomcatInterceptorTest.java | 14 ++++---- .../log4j/v1/x/PrintTraceIdInterceptor.java | 7 ++-- .../log4j/v2/x/PrintTraceIdInterceptor.java | 8 +++-- .../logback/v1/x/PrintTraceIdInterceptor.java | 7 ++-- .../continuation/ActivateInterceptor.java | 7 ++-- .../span/SpanFinishInterceptor.java | 7 ++-- .../opentracing/span/SpanLogInterceptor.java | 7 ++-- .../span/SpanSetOperationNameInterceptor.java | 7 ++-- .../span/SpanSetTagInterceptor.java | 7 ++-- .../SkywalkingTracerExtractInterceptor.java | 7 ++-- .../SkywalkingTracerInjectInterceptor.java | 7 ++-- .../SkywalkingSpanActivationTest.java | 19 ++++++---- .../trace/TraceContextInterceptor.java | 7 ++-- 41 files changed, 266 insertions(+), 185 deletions(-) diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/InstMethodsInter.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/InstMethodsInter.java index 6b99d4d26..b6242b03a 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/InstMethodsInter.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/InstMethodsInter.java @@ -57,7 +57,7 @@ public class InstMethodsInter { MethodInterceptResult result = new MethodInterceptResult(); try { - interceptor.beforeMethod(targetObject, method.getName(), allArguments, method.getParameterTypes(), + interceptor.beforeMethod(targetObject, method, allArguments, method.getParameterTypes(), result); } catch (Throwable t) { logger.error(t, "class[{}] before method[{}] intercept failure", obj.getClass(), method.getName()); @@ -72,7 +72,7 @@ public class InstMethodsInter { } } catch (Throwable t) { try { - interceptor.handleMethodException(targetObject, method.getName(), allArguments, method.getParameterTypes(), + interceptor.handleMethodException(targetObject, method, allArguments, method.getParameterTypes(), t); } catch (Throwable t2) { logger.error(t2, "class[{}] handle method[{}] exception failure", obj.getClass(), method.getName()); @@ -80,7 +80,7 @@ public class InstMethodsInter { throw t; } finally { try { - ret = interceptor.afterMethod(targetObject, method.getName(), allArguments, method.getParameterTypes(), + ret = interceptor.afterMethod(targetObject, method, allArguments, method.getParameterTypes(), ret); } catch (Throwable t) { logger.error(t, "class[{}] after method[{}] intercept failure", obj.getClass(), method.getName()); diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/InstMethodsInterWithOverrideArgs.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/InstMethodsInterWithOverrideArgs.java index 3f5cc9b69..21da4bf6e 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/InstMethodsInterWithOverrideArgs.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/InstMethodsInterWithOverrideArgs.java @@ -59,7 +59,7 @@ public class InstMethodsInterWithOverrideArgs { MethodInterceptResult result = new MethodInterceptResult(); try { - interceptor.beforeMethod(targetObject, method.getName(), allArguments, method.getParameterTypes(), + interceptor.beforeMethod(targetObject, method, allArguments, method.getParameterTypes(), result); } catch (Throwable t) { logger.error(t, "class[{}] before method[{}] intercept failure", obj.getClass(), method.getName()); @@ -74,7 +74,7 @@ public class InstMethodsInterWithOverrideArgs { } } catch (Throwable t) { try { - interceptor.handleMethodException(targetObject, method.getName(), allArguments, method.getParameterTypes(), + interceptor.handleMethodException(targetObject, method, allArguments, method.getParameterTypes(), t); } catch (Throwable t2) { logger.error(t2, "class[{}] handle method[{}] exception failure", obj.getClass(), method.getName()); @@ -82,7 +82,7 @@ public class InstMethodsInterWithOverrideArgs { throw t; } finally { try { - ret = interceptor.afterMethod(targetObject, method.getName(), allArguments, method.getParameterTypes(), + ret = interceptor.afterMethod(targetObject, method, allArguments, method.getParameterTypes(), ret); } catch (Throwable t) { logger.error(t, "class[{}] after method[{}] intercept failure", obj.getClass(), method.getName()); diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/InstanceMethodsAroundInterceptor.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/InstanceMethodsAroundInterceptor.java index 3697e3965..b137b447b 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/InstanceMethodsAroundInterceptor.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/InstanceMethodsAroundInterceptor.java @@ -1,5 +1,7 @@ package org.skywalking.apm.agent.core.plugin.interceptor.enhance; +import java.lang.reflect.Method; + /** * A interceptor, which intercept method's invocation. The target methods will be defined in {@link * ClassEnhancePluginDefine}'s subclass, most likely in {@link ClassInstanceMethodsEnhancePluginDefine} @@ -10,27 +12,32 @@ public interface InstanceMethodsAroundInterceptor { /** * called before target method invocation. * + * + * @param method * @param result change this result, if you want to truncate the method. * @throws Throwable */ - void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, Class[] argumentsTypes, + void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable; /** * called after target method invocation. Even method's invocation triggers an exception. * + * + * @param method * @param ret the method's original return value. * @return the method's actual return value. * @throws Throwable */ - Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, Class[] argumentsTypes, + Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable; /** * called when occur exception. * + * @param method * @param t the exception occur. */ - void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, Class[] argumentsTypes, + void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t); } diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/StaticMethodsAroundInterceptor.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/StaticMethodsAroundInterceptor.java index fe26ac239..5148b3f24 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/StaticMethodsAroundInterceptor.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/StaticMethodsAroundInterceptor.java @@ -1,5 +1,7 @@ package org.skywalking.apm.agent.core.plugin.interceptor.enhance; +import java.lang.reflect.Method; + /** * The static method's interceptor interface. * Any plugin, which wants to intercept static methods, must implement this interface. @@ -10,24 +12,28 @@ public interface StaticMethodsAroundInterceptor { /** * called before target method invocation. * + * @param method * @param result change this result, if you want to truncate the method. */ - void beforeMethod(Class clazz, String methodName, Object[] allArguments, Class[] parameterTypes, + void beforeMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, MethodInterceptResult result); /** * called after target method invocation. Even method's invocation triggers an exception. * + * + * @param method * @param ret the method's original return value. * @return the method's actual return value. */ - Object afterMethod(Class clazz, String methodName, Object[] allArguments, Class[] parameterTypes, Object ret); + Object afterMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, Object ret); /** * called when occur exception. * + * @param method * @param t the exception occur. */ - void handleMethodException(Class clazz, String methodName, Object[] allArguments, Class[] parameterTypes, + void handleMethodException(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, Throwable t); } diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/StaticMethodsInter.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/StaticMethodsInter.java index f93fdb620..d68992092 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/StaticMethodsInter.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/StaticMethodsInter.java @@ -55,7 +55,7 @@ public class StaticMethodsInter { MethodInterceptResult result = new MethodInterceptResult(); try { - interceptor.beforeMethod(clazz, method.getName(), allArguments, method.getParameterTypes(), result); + interceptor.beforeMethod(clazz, method, allArguments, method.getParameterTypes(), result); } catch (Throwable t) { logger.error(t, "class[{}] before static method[{}] intercept failure", clazz, method.getName()); } @@ -69,14 +69,14 @@ public class StaticMethodsInter { } } catch (Throwable t) { try { - interceptor.handleMethodException(clazz, method.getName(), allArguments, method.getParameterTypes(), t); + interceptor.handleMethodException(clazz, method, allArguments, method.getParameterTypes(), t); } catch (Throwable t2) { logger.error(t2, "class[{}] handle static method[{}] exception failure", clazz, method.getName(), t2.getMessage()); } throw t; } finally { try { - ret = interceptor.afterMethod(clazz, method.getName(), allArguments, method.getParameterTypes(), ret); + ret = interceptor.afterMethod(clazz, method, allArguments, method.getParameterTypes(), ret); } catch (Throwable t) { logger.error(t, "class[{}] after static method[{}] intercept failure:{}", clazz, method.getName(), t.getMessage()); } diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/StaticMethodsInterWithOverrideArgs.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/StaticMethodsInterWithOverrideArgs.java index 13a94f9dc..3fc2fa5f6 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/StaticMethodsInterWithOverrideArgs.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/interceptor/enhance/StaticMethodsInterWithOverrideArgs.java @@ -53,7 +53,7 @@ public class StaticMethodsInterWithOverrideArgs { MethodInterceptResult result = new MethodInterceptResult(); try { - interceptor.beforeMethod(clazz, method.getName(), allArguments, method.getParameterTypes(), result); + interceptor.beforeMethod(clazz, method, allArguments, method.getParameterTypes(), result); } catch (Throwable t) { logger.error(t, "class[{}] before static method[{}] intercept failure", clazz, method.getName()); } @@ -67,14 +67,14 @@ public class StaticMethodsInterWithOverrideArgs { } } catch (Throwable t) { try { - interceptor.handleMethodException(clazz, method.getName(), allArguments, method.getParameterTypes(), t); + interceptor.handleMethodException(clazz, method, allArguments, method.getParameterTypes(), t); } catch (Throwable t2) { logger.error(t2, "class[{}] handle static method[{}] exception failure", clazz, method.getName(), t2.getMessage()); } throw t; } finally { try { - ret = interceptor.afterMethod(clazz, method.getName(), allArguments, method.getParameterTypes(), ret); + ret = interceptor.afterMethod(clazz, method, allArguments, method.getParameterTypes(), ret); } catch (Throwable t) { logger.error(t, "class[{}] after static method[{}] intercept failure:{}", clazz, method.getName(), t.getMessage()); } diff --git a/apm-sniffer/apm-sdk-plugin/dubbo-plugin/src/main/java/org/skywalking/apm/plugin/dubbo/DubboInterceptor.java b/apm-sniffer/apm-sdk-plugin/dubbo-plugin/src/main/java/org/skywalking/apm/plugin/dubbo/DubboInterceptor.java index c5a727b1d..352b85bfa 100644 --- a/apm-sniffer/apm-sdk-plugin/dubbo-plugin/src/main/java/org/skywalking/apm/plugin/dubbo/DubboInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/dubbo-plugin/src/main/java/org/skywalking/apm/plugin/dubbo/DubboInterceptor.java @@ -5,6 +5,7 @@ import com.alibaba.dubbo.rpc.Invocation; import com.alibaba.dubbo.rpc.Invoker; import com.alibaba.dubbo.rpc.Result; import com.alibaba.dubbo.rpc.RpcContext; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.conf.Config; import org.skywalking.apm.agent.core.context.ContextCarrier; import org.skywalking.apm.agent.core.context.ContextManager; @@ -40,7 +41,7 @@ public class DubboInterceptor implements InstanceMethodsAroundInterceptor { * {@link RpcContext#attachments}. current trace segment will ref if the serialize context data is not null. */ @Override - public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { Invoker invoker = (Invoker)allArguments[0]; Invocation invocation = (Invocation)allArguments[1]; @@ -80,7 +81,7 @@ public class DubboInterceptor implements InstanceMethodsAroundInterceptor { } @Override - public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { Result result = (Result)ret; if (result != null && result.getException() != null) { @@ -92,7 +93,7 @@ public class DubboInterceptor implements InstanceMethodsAroundInterceptor { } @Override - public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { dealException(t); } diff --git a/apm-sniffer/apm-sdk-plugin/dubbo-plugin/src/test/java/org/skywalking/apm/plugin/dubbo/DubboInterceptorTest.java b/apm-sniffer/apm-sdk-plugin/dubbo-plugin/src/test/java/org/skywalking/apm/plugin/dubbo/DubboInterceptorTest.java index 3db3f120e..84ef579f2 100644 --- a/apm-sniffer/apm-sdk-plugin/dubbo-plugin/src/test/java/org/skywalking/apm/plugin/dubbo/DubboInterceptorTest.java +++ b/apm-sniffer/apm-sdk-plugin/dubbo-plugin/src/test/java/org/skywalking/apm/plugin/dubbo/DubboInterceptorTest.java @@ -97,8 +97,8 @@ public class DubboInterceptorTest { public void testConsumerBelow283() throws Throwable { BugFixActive.active(); - dubboInterceptor.beforeMethod(enhancedInstance, "invoke", allArguments, argumentTypes, methodInterceptResult); - dubboInterceptor.afterMethod(enhancedInstance, "invoke", allArguments, argumentTypes, result); + dubboInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentTypes, methodInterceptResult); + dubboInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentTypes, result); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -113,8 +113,8 @@ public class DubboInterceptorTest { @Test public void testConsumerWithAttachment() throws Throwable { - dubboInterceptor.beforeMethod(enhancedInstance, "invoke", allArguments, argumentTypes, methodInterceptResult); - dubboInterceptor.afterMethod(enhancedInstance, "invoke", allArguments, argumentTypes, result); + dubboInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentTypes, methodInterceptResult); + dubboInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentTypes, result); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -125,9 +125,9 @@ public class DubboInterceptorTest { @Test public void testConsumerWithException() throws Throwable { - dubboInterceptor.beforeMethod(enhancedInstance, "invoke", allArguments, argumentTypes, methodInterceptResult); - dubboInterceptor.handleMethodException(enhancedInstance, "invoke", allArguments, argumentTypes, new RuntimeException()); - dubboInterceptor.afterMethod(enhancedInstance, "invoke", allArguments, argumentTypes, result); + dubboInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentTypes, methodInterceptResult); + dubboInterceptor.handleMethodException(enhancedInstance, null, allArguments, argumentTypes, new RuntimeException()); + dubboInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentTypes, result); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); assertConsumerTraceSegmentInErrorCase(traceSegment); @@ -137,8 +137,8 @@ public class DubboInterceptorTest { public void testConsumerWithResultHasException() throws Throwable { when(result.getException()).thenReturn(new RuntimeException()); - dubboInterceptor.beforeMethod(enhancedInstance, "invoke", allArguments, argumentTypes, methodInterceptResult); - dubboInterceptor.afterMethod(enhancedInstance, "invoke", allArguments, argumentTypes, result); + dubboInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentTypes, methodInterceptResult); + dubboInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentTypes, result); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -150,8 +150,8 @@ public class DubboInterceptorTest { when(rpcContext.isConsumerSide()).thenReturn(false); when(rpcContext.getAttachment(Config.Plugin.Propagation.HEADER_NAME)).thenReturn("#AQA*#AQA*4WcWe0tQNQA*|3|1|1|#192.168.1.8 :18002|#/portal/|#/testEntrySpan|#AQA*#AQA*Et0We0tQNQA*"); - dubboInterceptor.beforeMethod(enhancedInstance, "invoke", allArguments, argumentTypes, methodInterceptResult); - dubboInterceptor.afterMethod(enhancedInstance, "invoke", allArguments, argumentTypes, result); + dubboInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentTypes, methodInterceptResult); + dubboInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentTypes, result); assertProvider(); } @@ -162,8 +162,8 @@ public class DubboInterceptorTest { testParam.setTraceContext("#AQA*#AQA*4WcWe0tQNQA*|3|1|1|#192.168.1.8 :18002|#/portal/|#/testEntrySpan|#AQA*#AQA*Et0We0tQNQA*"); - dubboInterceptor.beforeMethod(enhancedInstance, "invoke", allArguments, argumentTypes, methodInterceptResult); - dubboInterceptor.afterMethod(enhancedInstance, "invoke", allArguments, argumentTypes, result); + dubboInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentTypes, methodInterceptResult); + dubboInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentTypes, result); assertProvider(); } diff --git a/apm-sniffer/apm-sdk-plugin/feign-default-http-9.x-plugin/src/main/java/org/skywalking/apm/plugin/feign/http/v9/DefaultHttpClientInterceptor.java b/apm-sniffer/apm-sdk-plugin/feign-default-http-9.x-plugin/src/main/java/org/skywalking/apm/plugin/feign/http/v9/DefaultHttpClientInterceptor.java index 0c30d8ec4..a9b0271e9 100644 --- a/apm-sniffer/apm-sdk-plugin/feign-default-http-9.x-plugin/src/main/java/org/skywalking/apm/plugin/feign/http/v9/DefaultHttpClientInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/feign-default-http-9.x-plugin/src/main/java/org/skywalking/apm/plugin/feign/http/v9/DefaultHttpClientInterceptor.java @@ -3,6 +3,7 @@ package org.skywalking.apm.plugin.feign.http.v9; import feign.Request; import feign.Response; import java.lang.reflect.Field; +import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.net.URL; import java.util.ArrayList; @@ -36,10 +37,12 @@ public class DefaultHttpClientInterceptor implements InstanceMethodsAroundInterc * port, kind, component, url from {@link feign.Request}. * Through the reflection of the way, set the http header of context data into {@link feign.Request#headers}. * + * + * @param method * @param result change this result, if you want to truncate the method. * @throws Throwable */ - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { Request request = (Request)allArguments[0]; @@ -73,11 +76,13 @@ public class DefaultHttpClientInterceptor implements InstanceMethodsAroundInterc * the server. * Finish the {@link AbstractSpan}. * + * + * @param method * @param ret the method's original return value. * @return * @throws Throwable */ - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { Response response = (Response)ret; int statusCode = response.status(); @@ -93,7 +98,7 @@ public class DefaultHttpClientInterceptor implements InstanceMethodsAroundInterc return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { AbstractSpan activeSpan = ContextManager.activeSpan(); activeSpan.log(t); diff --git a/apm-sniffer/apm-sdk-plugin/feign-default-http-9.x-plugin/src/test/java/org/skywalking/apm/plugin/feign/http/v9/DefaultHttpClientInterceptorTest.java b/apm-sniffer/apm-sdk-plugin/feign-default-http-9.x-plugin/src/test/java/org/skywalking/apm/plugin/feign/http/v9/DefaultHttpClientInterceptorTest.java index 2382b71cd..399409c21 100644 --- a/apm-sniffer/apm-sdk-plugin/feign-default-http-9.x-plugin/src/test/java/org/skywalking/apm/plugin/feign/http/v9/DefaultHttpClientInterceptorTest.java +++ b/apm-sniffer/apm-sdk-plugin/feign-default-http-9.x-plugin/src/test/java/org/skywalking/apm/plugin/feign/http/v9/DefaultHttpClientInterceptorTest.java @@ -80,8 +80,8 @@ public class DefaultHttpClientInterceptorTest { public void testMethodsAround() throws Throwable { Response response = mock(Response.class); when(response.status()).thenReturn(200); - defaultHttpClientInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentTypes, result); - defaultHttpClientInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentTypes, response); + defaultHttpClientInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentTypes, result); + defaultHttpClientInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentTypes, response); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -101,11 +101,11 @@ public class DefaultHttpClientInterceptorTest { @Test public void testMethodsAroundError() throws Throwable { - defaultHttpClientInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentTypes, result); + defaultHttpClientInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentTypes, result); Response response = mock(Response.class); when(response.status()).thenReturn(404); - defaultHttpClientInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentTypes, response); + defaultHttpClientInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentTypes, response); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -130,13 +130,13 @@ public class DefaultHttpClientInterceptorTest { @Test public void testException() throws Throwable { - defaultHttpClientInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentTypes, result); + defaultHttpClientInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentTypes, result); - defaultHttpClientInterceptor.handleMethodException(enhancedInstance, "execute", allArguments, argumentTypes, new NullPointerException("testException")); + defaultHttpClientInterceptor.handleMethodException(enhancedInstance, null, allArguments, argumentTypes, new NullPointerException("testException")); Response response = mock(Response.class); when(response.status()).thenReturn(200); - defaultHttpClientInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentTypes, response); + defaultHttpClientInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentTypes, response); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); diff --git a/apm-sniffer/apm-sdk-plugin/httpClient-4.x-plugin/src/main/java/org/skywalking/apm/plugin/httpClient/v4/HttpClientExecuteInterceptor.java b/apm-sniffer/apm-sdk-plugin/httpClient-4.x-plugin/src/main/java/org/skywalking/apm/plugin/httpClient/v4/HttpClientExecuteInterceptor.java index c619cb9d3..2b0d6ccec 100644 --- a/apm-sniffer/apm-sdk-plugin/httpClient-4.x-plugin/src/main/java/org/skywalking/apm/plugin/httpClient/v4/HttpClientExecuteInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/httpClient-4.x-plugin/src/main/java/org/skywalking/apm/plugin/httpClient/v4/HttpClientExecuteInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.plugin.httpClient.v4; +import java.lang.reflect.Method; import java.net.MalformedURLException; import java.net.URL; import org.apache.http.HttpHost; @@ -18,7 +19,7 @@ import org.skywalking.apm.network.trace.component.ComponentsDefine; public class HttpClientExecuteInterceptor implements InstanceMethodsAroundInterceptor { - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { if (allArguments[0] == null || allArguments[1] == null) { // illegal args, can't trace. ignore. @@ -44,7 +45,7 @@ public class HttpClientExecuteInterceptor implements InstanceMethodsAroundInterc httpRequest.setHeader(Config.Plugin.Propagation.HEADER_NAME, contextCarrier.serialize()); } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { if (allArguments[0] == null || allArguments[1] == null) { return ret; @@ -62,7 +63,7 @@ public class HttpClientExecuteInterceptor implements InstanceMethodsAroundInterc return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { AbstractSpan activeSpan = ContextManager.activeSpan(); activeSpan.errorOccurred(); diff --git a/apm-sniffer/apm-sdk-plugin/httpClient-4.x-plugin/src/test/java/org/skywalking/apm/plugin/httpClient/v4/HttpClientExecuteInterceptorTest.java b/apm-sniffer/apm-sdk-plugin/httpClient-4.x-plugin/src/test/java/org/skywalking/apm/plugin/httpClient/v4/HttpClientExecuteInterceptorTest.java index 8c5809ebc..0b0fd9325 100644 --- a/apm-sniffer/apm-sdk-plugin/httpClient-4.x-plugin/src/test/java/org/skywalking/apm/plugin/httpClient/v4/HttpClientExecuteInterceptorTest.java +++ b/apm-sniffer/apm-sdk-plugin/httpClient-4.x-plugin/src/test/java/org/skywalking/apm/plugin/httpClient/v4/HttpClientExecuteInterceptorTest.java @@ -101,8 +101,8 @@ public class HttpClientExecuteInterceptorTest { @Test public void testHttpClient() throws Throwable { - httpClientExecuteInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentsType, null); - httpClientExecuteInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentsType, httpResponse); + httpClientExecuteInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentsType, null); + httpClientExecuteInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentsType, httpResponse); Assert.assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -115,8 +115,8 @@ public class HttpClientExecuteInterceptorTest { @Test public void testStatusCodeNotEquals200() throws Throwable { when(statusLine.getStatusCode()).thenReturn(500); - httpClientExecuteInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentsType, null); - httpClientExecuteInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentsType, httpResponse); + httpClientExecuteInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentsType, null); + httpClientExecuteInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentsType, httpResponse); Assert.assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -135,9 +135,9 @@ public class HttpClientExecuteInterceptorTest { @Test public void testHttpClientWithException() throws Throwable { - httpClientExecuteInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentsType, null); - httpClientExecuteInterceptor.handleMethodException(enhancedInstance, "execute", allArguments, argumentsType, new RuntimeException("testException")); - httpClientExecuteInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentsType, httpResponse); + httpClientExecuteInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentsType, null); + httpClientExecuteInterceptor.handleMethodException(enhancedInstance, null, allArguments, argumentsType, new RuntimeException("testException")); + httpClientExecuteInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentsType, httpResponse); Assert.assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); diff --git a/apm-sniffer/apm-sdk-plugin/jdbc-plugin/src/main/java/org/skywalking/apm/plugin/jdbc/define/JDBCDriverInterceptor.java b/apm-sniffer/apm-sdk-plugin/jdbc-plugin/src/main/java/org/skywalking/apm/plugin/jdbc/define/JDBCDriverInterceptor.java index 15ae0c2a5..535b04e88 100644 --- a/apm-sniffer/apm-sdk-plugin/jdbc-plugin/src/main/java/org/skywalking/apm/plugin/jdbc/define/JDBCDriverInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/jdbc-plugin/src/main/java/org/skywalking/apm/plugin/jdbc/define/JDBCDriverInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.plugin.jdbc.define; +import java.lang.reflect.Method; import java.sql.Connection; import java.util.Properties; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; @@ -15,18 +16,18 @@ import org.skywalking.apm.plugin.jdbc.SWConnection; */ public class JDBCDriverInterceptor implements InstanceMethodsAroundInterceptor { - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { return new SWConnection((String)allArguments[0], (Properties)allArguments[1], (Connection)ret); } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { } diff --git a/apm-sniffer/apm-sdk-plugin/jedis-2.x-plugin/src/main/java/org/skywalking/apm/plugin/jedis/v2/JedisMethodInterceptor.java b/apm-sniffer/apm-sdk-plugin/jedis-2.x-plugin/src/main/java/org/skywalking/apm/plugin/jedis/v2/JedisMethodInterceptor.java index b0c9f1388..83b3c41ee 100644 --- a/apm-sniffer/apm-sdk-plugin/jedis-2.x-plugin/src/main/java/org/skywalking/apm/plugin/jedis/v2/JedisMethodInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/jedis-2.x-plugin/src/main/java/org/skywalking/apm/plugin/jedis/v2/JedisMethodInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.plugin.jedis.v2; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.context.ContextCarrier; import org.skywalking.apm.agent.core.context.ContextManager; import org.skywalking.apm.agent.core.context.tag.Tags; @@ -12,26 +13,26 @@ import org.skywalking.apm.network.trace.component.ComponentsDefine; public class JedisMethodInterceptor implements InstanceMethodsAroundInterceptor { - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { String peer = String.valueOf(objInst.getSkyWalkingDynamicField()); - AbstractSpan span = ContextManager.createExitSpan("Jedis/" + methodName, new ContextCarrier(), peer); + AbstractSpan span = ContextManager.createExitSpan("Jedis/" + method.getName(), new ContextCarrier(), peer); span.setComponent(ComponentsDefine.REDIS); Tags.DB_TYPE.set(span, "Redis"); SpanLayer.asDB(span); if (allArguments.length > 0 && allArguments[0] instanceof String) { - Tags.DB_STATEMENT.set(span, methodName + " " + allArguments[0]); + Tags.DB_STATEMENT.set(span, method.getName() + " " + allArguments[0]); } } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { ContextManager.stopSpan(); return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { AbstractSpan span = ContextManager.activeSpan(); span.errorOccurred(); diff --git a/apm-sniffer/apm-sdk-plugin/jedis-2.x-plugin/src/test/java/org/skywalking/apm/plugin/jedis/v2/JedisMethodInterceptorTest.java b/apm-sniffer/apm-sdk-plugin/jedis-2.x-plugin/src/test/java/org/skywalking/apm/plugin/jedis/v2/JedisMethodInterceptorTest.java index ee287ddd1..0af6c4bff 100644 --- a/apm-sniffer/apm-sdk-plugin/jedis-2.x-plugin/src/test/java/org/skywalking/apm/plugin/jedis/v2/JedisMethodInterceptorTest.java +++ b/apm-sniffer/apm-sdk-plugin/jedis-2.x-plugin/src/test/java/org/skywalking/apm/plugin/jedis/v2/JedisMethodInterceptorTest.java @@ -1,5 +1,6 @@ package org.skywalking.apm.plugin.jedis.v2; +import java.lang.reflect.Method; import java.util.List; import org.hamcrest.CoreMatchers; import org.junit.Assert; @@ -8,6 +9,7 @@ import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; +import org.powermock.api.mockito.PowerMockito; import org.powermock.modules.junit4.PowerMockRunner; import org.powermock.modules.junit4.PowerMockRunnerDelegate; import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan; @@ -22,6 +24,7 @@ import org.skywalking.apm.agent.test.tools.AgentServiceRule; import org.skywalking.apm.agent.test.tools.SegmentStorage; import org.skywalking.apm.agent.test.tools.SegmentStoragePoint; import org.skywalking.apm.agent.test.tools.TracingSegmentRunner; +import redis.clients.jedis.Jedis; import static junit.framework.TestCase.assertNotNull; import static org.hamcrest.CoreMatchers.is; @@ -58,8 +61,8 @@ public class JedisMethodInterceptorTest { @Test public void testIntercept() throws Throwable { - interceptor.beforeMethod(enhancedInstance, "set", allArgument, argumentType, null); - interceptor.afterMethod(enhancedInstance, "set", allArgument, argumentType, null); + interceptor.beforeMethod(enhancedInstance, getMockSetMethod(), allArgument, argumentType, null); + interceptor.afterMethod(enhancedInstance, getMockGetMethod(), allArgument, argumentType, null); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); List spans = SegmentHelper.getSpans(traceSegment); @@ -71,8 +74,8 @@ public class JedisMethodInterceptorTest { public void testInterceptWithMultiHost() throws Throwable { when(enhancedInstance.getSkyWalkingDynamicField()).thenReturn("127.0.0.1:6379;127.0.0.1:16379;"); - interceptor.beforeMethod(enhancedInstance, "set", allArgument, argumentType, null); - interceptor.afterMethod(enhancedInstance, "set", allArgument, argumentType, null); + interceptor.beforeMethod(enhancedInstance, getMockSetMethod(), allArgument, argumentType, null); + interceptor.afterMethod(enhancedInstance, getMockSetMethod(), allArgument, argumentType, null); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); List spans = SegmentHelper.getSpans(traceSegment); @@ -82,9 +85,9 @@ public class JedisMethodInterceptorTest { @Test public void testInterceptWithException() throws Throwable { - interceptor.beforeMethod(enhancedInstance, "set", allArgument, argumentType, null); - interceptor.handleMethodException(enhancedInstance, "set", allArgument, argumentType, new RuntimeException()); - interceptor.afterMethod(enhancedInstance, "set", allArgument, argumentType, null); + interceptor.beforeMethod(enhancedInstance, getMockSetMethod(), allArgument, argumentType, null); + interceptor.handleMethodException(enhancedInstance, getMockSetMethod(), allArgument, argumentType, new RuntimeException()); + interceptor.afterMethod(enhancedInstance, getMockSetMethod(), allArgument, argumentType, null); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); List spans = SegmentHelper.getSpans(traceSegment); @@ -114,4 +117,22 @@ public class JedisMethodInterceptorTest { assertThat(SpanHelper.getLayer(span), is(SpanLayer.DB)); } + private Method getMockSetMethod() { + try { + return Jedis.class.getMethod("set", String.class, String.class); + } catch (NoSuchMethodException e) { + e.printStackTrace(); + return null; + } + } + + private Method getMockGetMethod() { + try { + return Jedis.class.getMethod("get", String.class); + } catch (NoSuchMethodException e) { + e.printStackTrace(); + return null; + } + } + } diff --git a/apm-sniffer/apm-sdk-plugin/mongodb-3.x-plugin/src/main/java/org/skywalking/apm/plugin/mongodb/v3/MongoDBMethodInterceptor.java b/apm-sniffer/apm-sdk-plugin/mongodb-3.x-plugin/src/main/java/org/skywalking/apm/plugin/mongodb/v3/MongoDBMethodInterceptor.java index 6a188b16d..256d030bb 100644 --- a/apm-sniffer/apm-sdk-plugin/mongodb-3.x-plugin/src/main/java/org/skywalking/apm/plugin/mongodb/v3/MongoDBMethodInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/mongodb-3.x-plugin/src/main/java/org/skywalking/apm/plugin/mongodb/v3/MongoDBMethodInterceptor.java @@ -27,6 +27,7 @@ import com.mongodb.operation.MixedBulkWriteOperation; import com.mongodb.operation.ReadOperation; import com.mongodb.operation.UpdateOperation; import com.mongodb.operation.WriteOperation; +import java.lang.reflect.Method; import java.util.List; import org.bson.BsonDocument; import org.skywalking.apm.agent.core.conf.Config; @@ -52,7 +53,7 @@ public class MongoDBMethodInterceptor implements InstanceMethodsAroundIntercepto private static final String DB_TYPE = "MongoDB"; - private static final String METHOD = "MongoDB/"; + private static final String MONGO_DB_OP_PREFIX = "MongoDB/"; private static final int FILTER_LENGTH_LIMIT = 256; @@ -147,13 +148,13 @@ public class MongoDBMethodInterceptor implements InstanceMethodsAroundIntercepto } } - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { Object[] arguments = allArguments; String executeMethod = arguments[0].getClass().getSimpleName(); String remotePeer = (String)objInst.getSkyWalkingDynamicField(); - AbstractSpan span = ContextManager.createExitSpan(METHOD + methodName, new ContextCarrier(), remotePeer); + AbstractSpan span = ContextManager.createExitSpan(MONGO_DB_OP_PREFIX + method.getName(), new ContextCarrier(), remotePeer); span.setComponent(ComponentsDefine.MONGODB); Tags.DB_TYPE.set(span, DB_TYPE); SpanLayer.asDB(span); @@ -164,13 +165,13 @@ public class MongoDBMethodInterceptor implements InstanceMethodsAroundIntercepto } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { ContextManager.stopSpan(); return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { AbstractSpan activeSpan = ContextManager.activeSpan(); activeSpan.errorOccurred(); diff --git a/apm-sniffer/apm-sdk-plugin/mongodb-3.x-plugin/src/test/java/org/skywalking/apm/plugin/mongodb/v3/MongoDBMethodInterceptorTest.java b/apm-sniffer/apm-sdk-plugin/mongodb-3.x-plugin/src/test/java/org/skywalking/apm/plugin/mongodb/v3/MongoDBMethodInterceptorTest.java index 9d3abeb5d..29a9850a4 100644 --- a/apm-sniffer/apm-sdk-plugin/mongodb-3.x-plugin/src/test/java/org/skywalking/apm/plugin/mongodb/v3/MongoDBMethodInterceptorTest.java +++ b/apm-sniffer/apm-sdk-plugin/mongodb-3.x-plugin/src/test/java/org/skywalking/apm/plugin/mongodb/v3/MongoDBMethodInterceptorTest.java @@ -1,14 +1,15 @@ package org.skywalking.apm.plugin.mongodb.v3; +import com.mongodb.Mongo; import com.mongodb.MongoNamespace; import com.mongodb.operation.FindOperation; +import com.mongodb.operation.WriteOperation; +import java.lang.reflect.Method; import java.util.List; import org.bson.BsonDocument; import org.bson.BsonString; import org.bson.codecs.Decoder; -import org.hamcrest.CoreMatchers; import org.hamcrest.MatcherAssert; -import org.junit.Assert; import org.junit.Before; import org.junit.Rule; import org.junit.Test; @@ -78,8 +79,8 @@ public class MongoDBMethodInterceptorTest { @Test public void testIntercept() throws Throwable { - interceptor.beforeMethod(enhancedInstance, "FindOperation", arguments, argumentTypes, null); - interceptor.afterMethod(enhancedInstance, "FindOperation", arguments, argumentTypes, null); + interceptor.beforeMethod(enhancedInstance, getExecuteMethod(), arguments, argumentTypes, null); + interceptor.afterMethod(enhancedInstance, getExecuteMethod(), arguments, argumentTypes, null); MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -89,9 +90,9 @@ public class MongoDBMethodInterceptorTest { @Test public void testInterceptWithException() throws Throwable { - interceptor.beforeMethod(enhancedInstance, "FindOperation", arguments, argumentTypes, null); - interceptor.handleMethodException(enhancedInstance, "FindOperation", arguments, argumentTypes, new RuntimeException()); - interceptor.afterMethod(enhancedInstance, "FindOperation", arguments, argumentTypes, null); + interceptor.beforeMethod(enhancedInstance, getExecuteMethod(), arguments, argumentTypes, null); + interceptor.handleMethodException(enhancedInstance, getExecuteMethod(), arguments, argumentTypes, new RuntimeException()); + interceptor.afterMethod(enhancedInstance, getExecuteMethod(), arguments, argumentTypes, null); MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -103,7 +104,7 @@ public class MongoDBMethodInterceptorTest { } private void assertRedisSpan(AbstractTracingSpan span) { - assertThat(span.getOperationName(), is("MongoDB/FindOperation")); + assertThat(span.getOperationName(), is("MongoDB/getUsedDatabases")); assertThat(SpanHelper.getComponentId(span), is(9)); List tags = SpanHelper.getTags(span); assertThat(tags.get(1).getValue(), is("FindOperation { \"name\" : \"by\" }")); @@ -112,4 +113,13 @@ public class MongoDBMethodInterceptorTest { assertThat(SpanHelper.getLayer(span), is(SpanLayer.DB)); } + private Method getExecuteMethod(){ + try { + return Mongo.class.getMethod("getUsedDatabases"); + } catch (NoSuchMethodException e) { + e.printStackTrace(); + return null; + } + } + } diff --git a/apm-sniffer/apm-sdk-plugin/motan-plugin/src/main/java/org/skywalking/apm/plugin/motan/MotanConsumerInterceptor.java b/apm-sniffer/apm-sdk-plugin/motan-plugin/src/main/java/org/skywalking/apm/plugin/motan/MotanConsumerInterceptor.java index 6111041fa..890ff43f6 100644 --- a/apm-sniffer/apm-sdk-plugin/motan-plugin/src/main/java/org/skywalking/apm/plugin/motan/MotanConsumerInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/motan-plugin/src/main/java/org/skywalking/apm/plugin/motan/MotanConsumerInterceptor.java @@ -3,6 +3,7 @@ package org.skywalking.apm.plugin.motan; import com.weibo.api.motan.rpc.Request; import com.weibo.api.motan.rpc.Response; import com.weibo.api.motan.rpc.URL; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.conf.Config; import org.skywalking.apm.agent.core.context.ContextCarrier; import org.skywalking.apm.agent.core.context.ContextManager; @@ -29,7 +30,7 @@ public class MotanConsumerInterceptor implements InstanceConstructorInterceptor, } @Override - public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { URL url = (URL)objInst.getSkyWalkingDynamicField(); @@ -45,7 +46,7 @@ public class MotanConsumerInterceptor implements InstanceConstructorInterceptor, } } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { Response response = (Response)ret; if (response != null && response.getException() != null) { @@ -57,7 +58,7 @@ public class MotanConsumerInterceptor implements InstanceConstructorInterceptor, return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { AbstractSpan span = ContextManager.activeSpan(); span.errorOccurred(); diff --git a/apm-sniffer/apm-sdk-plugin/motan-plugin/src/main/java/org/skywalking/apm/plugin/motan/MotanProviderInterceptor.java b/apm-sniffer/apm-sdk-plugin/motan-plugin/src/main/java/org/skywalking/apm/plugin/motan/MotanProviderInterceptor.java index 58bb0bf54..b77377cf6 100644 --- a/apm-sniffer/apm-sdk-plugin/motan-plugin/src/main/java/org/skywalking/apm/plugin/motan/MotanProviderInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/motan-plugin/src/main/java/org/skywalking/apm/plugin/motan/MotanProviderInterceptor.java @@ -2,6 +2,7 @@ package org.skywalking.apm.plugin.motan; import com.weibo.api.motan.rpc.Request; import com.weibo.api.motan.rpc.Response; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.conf.Config; import org.skywalking.apm.agent.core.context.ContextCarrier; import org.skywalking.apm.agent.core.context.ContextManager; @@ -23,7 +24,7 @@ import org.skywalking.apm.network.trace.component.ComponentsDefine; */ public class MotanProviderInterceptor implements InstanceMethodsAroundInterceptor { - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { Request request = (Request)allArguments[0]; String serializedContextData = request.getAttachments().get(Config.Plugin.Propagation.HEADER_NAME); @@ -33,7 +34,7 @@ public class MotanProviderInterceptor implements InstanceMethodsAroundIntercepto span.setComponent(ComponentsDefine.MOTAN); } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { Response response = (Response)ret; if (response != null && response.getException() != null) { @@ -46,7 +47,7 @@ public class MotanProviderInterceptor implements InstanceMethodsAroundIntercepto return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { AbstractSpan activeSpan = ContextManager.activeSpan(); activeSpan.errorOccurred(); diff --git a/apm-sniffer/apm-sdk-plugin/motan-plugin/src/test/java/org/skywalking/apm/plugin/motan/MotanConsumerInterceptorTest.java b/apm-sniffer/apm-sdk-plugin/motan-plugin/src/test/java/org/skywalking/apm/plugin/motan/MotanConsumerInterceptorTest.java index b54e59018..02dfc828e 100644 --- a/apm-sniffer/apm-sdk-plugin/motan-plugin/src/test/java/org/skywalking/apm/plugin/motan/MotanConsumerInterceptorTest.java +++ b/apm-sniffer/apm-sdk-plugin/motan-plugin/src/test/java/org/skywalking/apm/plugin/motan/MotanConsumerInterceptorTest.java @@ -70,8 +70,8 @@ public class MotanConsumerInterceptorTest { @Test public void testInvokeInterceptor() throws Throwable { - invokeInterceptor.beforeMethod(enhancedInstance, "execute", new Object[] {request}, new Class[] {request.getClass()}, null); - invokeInterceptor.afterMethod(enhancedInstance, "execute", new Object[] {request}, new Class[] {request.getClass()}, response); + invokeInterceptor.beforeMethod(enhancedInstance, null, new Object[] {request}, new Class[] {request.getClass()}, null); + invokeInterceptor.afterMethod(enhancedInstance, null, new Object[] {request}, new Class[] {request.getClass()}, response); MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -84,8 +84,8 @@ public class MotanConsumerInterceptorTest { public void testResponseWithException() throws Throwable { when(response.getException()).thenReturn(new RuntimeException()); - invokeInterceptor.beforeMethod(enhancedInstance, "execute", new Object[] {request}, new Class[] {request.getClass()}, null); - invokeInterceptor.afterMethod(enhancedInstance, "execute", new Object[] {request}, new Class[] {request.getClass()}, response); + invokeInterceptor.beforeMethod(enhancedInstance, null, new Object[] {request}, new Class[] {request.getClass()}, null); + invokeInterceptor.afterMethod(enhancedInstance, null, new Object[] {request}, new Class[] {request.getClass()}, response); MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -104,9 +104,9 @@ public class MotanConsumerInterceptorTest { @Test public void testInvokeInterceptorWithException() throws Throwable { - invokeInterceptor.beforeMethod(enhancedInstance, "execute", new Object[] {request}, new Class[] {request.getClass()}, null); - invokeInterceptor.handleMethodException(enhancedInstance, "execute", new Object[] {request}, new Class[] {request.getClass()}, new RuntimeException()); - invokeInterceptor.afterMethod(enhancedInstance, "execute", new Object[] {request}, new Class[] {request.getClass()}, response); + invokeInterceptor.beforeMethod(enhancedInstance, null, new Object[] {request}, new Class[] {request.getClass()}, null); + invokeInterceptor.handleMethodException(enhancedInstance, null, new Object[] {request}, new Class[] {request.getClass()}, new RuntimeException()); + invokeInterceptor.afterMethod(enhancedInstance, null, new Object[] {request}, new Class[] {request.getClass()}, response); MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); diff --git a/apm-sniffer/apm-sdk-plugin/motan-plugin/src/test/java/org/skywalking/apm/plugin/motan/MotanProviderInterceptorTest.java b/apm-sniffer/apm-sdk-plugin/motan-plugin/src/test/java/org/skywalking/apm/plugin/motan/MotanProviderInterceptorTest.java index e90f0b65f..f04984fbb 100644 --- a/apm-sniffer/apm-sdk-plugin/motan-plugin/src/test/java/org/skywalking/apm/plugin/motan/MotanProviderInterceptorTest.java +++ b/apm-sniffer/apm-sdk-plugin/motan-plugin/src/test/java/org/skywalking/apm/plugin/motan/MotanProviderInterceptorTest.java @@ -77,8 +77,8 @@ public class MotanProviderInterceptorTest { @Test public void testInvokerWithoutRefSegment() throws Throwable { - invokeInterceptor.beforeMethod(enhancedInstance, "execute", arguments, argumentType, null); - invokeInterceptor.afterMethod(enhancedInstance, "execute", arguments, argumentType, response); + invokeInterceptor.beforeMethod(enhancedInstance, null, arguments, argumentType, null); + invokeInterceptor.afterMethod(enhancedInstance, null, arguments, argumentType, response); MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -94,8 +94,8 @@ public class MotanProviderInterceptorTest { attachments.put(Config.Plugin.Propagation.HEADER_NAME, "#AQA*#AQA*4WcWe0tQNQA*|3|1|1|#192.168.1.8:18002|#/portal/|#/testEntrySpan|#AQA*#AQA*Et0We0tQNQA*"); when(request.getAttachments()).thenReturn(attachments); - invokeInterceptor.beforeMethod(enhancedInstance, "execute", arguments, argumentType, null); - invokeInterceptor.afterMethod(enhancedInstance, "execute", arguments, argumentType, response); + invokeInterceptor.beforeMethod(enhancedInstance, null, arguments, argumentType, null); + invokeInterceptor.afterMethod(enhancedInstance, null, arguments, argumentType, response); MatcherAssert.assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -108,8 +108,8 @@ public class MotanProviderInterceptorTest { public void testResponseWithException() throws Throwable { when(response.getException()).thenReturn(new RuntimeException()); - invokeInterceptor.beforeMethod(enhancedInstance, "execute", arguments, argumentType, null); - invokeInterceptor.afterMethod(enhancedInstance, "execute", arguments, argumentType, response); + invokeInterceptor.beforeMethod(enhancedInstance, null, arguments, argumentType, null); + invokeInterceptor.afterMethod(enhancedInstance, null, arguments, argumentType, response); assertTraceSegmentWhenOccurException(); } @@ -117,9 +117,9 @@ public class MotanProviderInterceptorTest { @Test public void testOccurException() throws Throwable { - invokeInterceptor.beforeMethod(enhancedInstance, "execute", arguments, argumentType, null); - invokeInterceptor.handleMethodException(enhancedInstance, "execute", arguments, argumentType, new RuntimeException()); - invokeInterceptor.afterMethod(enhancedInstance, "execute", arguments, argumentType, response); + invokeInterceptor.beforeMethod(enhancedInstance, null, arguments, argumentType, null); + invokeInterceptor.handleMethodException(enhancedInstance, null, arguments, argumentType, new RuntimeException()); + invokeInterceptor.afterMethod(enhancedInstance, null, arguments, argumentType, response); assertTraceSegmentWhenOccurException(); } diff --git a/apm-sniffer/apm-sdk-plugin/okhttp-3.x-plugin/src/main/java/org/skywalking/apm/plugin/okhttp/v3/RealCallInterceptor.java b/apm-sniffer/apm-sdk-plugin/okhttp-3.x-plugin/src/main/java/org/skywalking/apm/plugin/okhttp/v3/RealCallInterceptor.java index d976902d4..fb48195f8 100644 --- a/apm-sniffer/apm-sdk-plugin/okhttp-3.x-plugin/src/main/java/org/skywalking/apm/plugin/okhttp/v3/RealCallInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/okhttp-3.x-plugin/src/main/java/org/skywalking/apm/plugin/okhttp/v3/RealCallInterceptor.java @@ -1,6 +1,7 @@ package org.skywalking.apm.plugin.okhttp.v3; import java.lang.reflect.Field; +import java.lang.reflect.Method; import java.lang.reflect.Modifier; import okhttp3.Headers; import okhttp3.HttpUrl; @@ -43,10 +44,12 @@ public class RealCallInterceptor implements InstanceMethodsAroundInterceptor, In * port, kind, component, url from {@link okhttp3.Request}. * Through the reflection of the way, set the http header of context data into {@link okhttp3.Request#headers}. * + * + * @param method * @param result change this result, if you want to truncate the method. * @throws Throwable */ - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { Request request = (Request)objInst.getSkyWalkingDynamicField(); @@ -73,12 +76,14 @@ public class RealCallInterceptor implements InstanceMethodsAroundInterceptor, In * the server. * Finish the {@link AbstractSpan}. * + * + * @param method * @param ret the method's original return value. * @return * @throws Throwable */ @Override - public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { Response response = (Response)ret; int statusCode = response.code(); @@ -94,7 +99,7 @@ public class RealCallInterceptor implements InstanceMethodsAroundInterceptor, In return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { AbstractSpan abstractSpan = ContextManager.activeSpan(); abstractSpan.errorOccurred(); diff --git a/apm-sniffer/apm-sdk-plugin/okhttp-3.x-plugin/src/test/java/org/skywalking/apm/plugin/okhttp/v3/RealCallInterceptorTest.java b/apm-sniffer/apm-sdk-plugin/okhttp-3.x-plugin/src/test/java/org/skywalking/apm/plugin/okhttp/v3/RealCallInterceptorTest.java index 757beea20..cc8bc54c2 100644 --- a/apm-sniffer/apm-sdk-plugin/okhttp-3.x-plugin/src/test/java/org/skywalking/apm/plugin/okhttp/v3/RealCallInterceptorTest.java +++ b/apm-sniffer/apm-sdk-plugin/okhttp-3.x-plugin/src/test/java/org/skywalking/apm/plugin/okhttp/v3/RealCallInterceptorTest.java @@ -93,11 +93,11 @@ public class RealCallInterceptorTest { @Test public void testMethodsAround() throws Throwable { realCallInterceptor.onConstruct(enhancedInstance, allArguments); - realCallInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentTypes, null); + realCallInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentTypes, null); Response response = mock(Response.class); when(response.code()).thenReturn(200); - realCallInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentTypes, response); + realCallInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentTypes, response); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -110,11 +110,11 @@ public class RealCallInterceptorTest { @Test public void testMethodsAroundError() throws Throwable { realCallInterceptor.onConstruct(enhancedInstance, allArguments); - realCallInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentTypes, null); + realCallInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentTypes, null); Response response = mock(Response.class); when(response.code()).thenReturn(404); - realCallInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentTypes, response); + realCallInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentTypes, response); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -136,13 +136,13 @@ public class RealCallInterceptorTest { @Test public void testException() throws Throwable { realCallInterceptor.onConstruct(enhancedInstance, allArguments); - realCallInterceptor.beforeMethod(enhancedInstance, "execute", allArguments, argumentTypes, null); + realCallInterceptor.beforeMethod(enhancedInstance, null, allArguments, argumentTypes, null); - realCallInterceptor.handleMethodException(enhancedInstance, "execute", allArguments, argumentTypes, new NullPointerException("testException")); + realCallInterceptor.handleMethodException(enhancedInstance, null, allArguments, argumentTypes, new NullPointerException("testException")); Response response = mock(Response.class); when(response.code()).thenReturn(200); - realCallInterceptor.afterMethod(enhancedInstance, "execute", allArguments, argumentTypes, response); + realCallInterceptor.afterMethod(enhancedInstance, null, allArguments, argumentTypes, response); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); diff --git a/apm-sniffer/apm-sdk-plugin/resin-3.x-plugin/src/main/java/org/skywalking/apm/plugin/resin/v3/ResinV3Interceptor.java b/apm-sniffer/apm-sdk-plugin/resin-3.x-plugin/src/main/java/org/skywalking/apm/plugin/resin/v3/ResinV3Interceptor.java index f7aa984a6..dbdd8293b 100644 --- a/apm-sniffer/apm-sdk-plugin/resin-3.x-plugin/src/main/java/org/skywalking/apm/plugin/resin/v3/ResinV3Interceptor.java +++ b/apm-sniffer/apm-sdk-plugin/resin-3.x-plugin/src/main/java/org/skywalking/apm/plugin/resin/v3/ResinV3Interceptor.java @@ -2,6 +2,7 @@ package org.skywalking.apm.plugin.resin.v3; import com.caucho.server.connection.CauchoRequest; import com.caucho.server.http.HttpResponse; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.conf.Config; import org.skywalking.apm.agent.core.context.ContextCarrier; import org.skywalking.apm.agent.core.context.ContextManager; @@ -21,7 +22,7 @@ import org.skywalking.apm.network.trace.component.ComponentsDefine; */ public class ResinV3Interceptor implements InstanceMethodsAroundInterceptor { - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { CauchoRequest request = (CauchoRequest)allArguments[0]; String tracingHeaderValue = request.getHeader(Config.Plugin.Propagation.HEADER_NAME); @@ -32,7 +33,7 @@ public class ResinV3Interceptor implements InstanceMethodsAroundInterceptor { SpanLayer.asHttp(span); } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { HttpResponse response = (HttpResponse)allArguments[1]; AbstractSpan span = ContextManager.activeSpan(); @@ -46,7 +47,7 @@ public class ResinV3Interceptor implements InstanceMethodsAroundInterceptor { } @Override - public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { AbstractSpan activeSpan = ContextManager.activeSpan(); activeSpan.log(t); diff --git a/apm-sniffer/apm-sdk-plugin/resin-3.x-plugin/src/test/java/org/skywalking/apm/plugin/resin/v3/ResinV3InterceptorTest.java b/apm-sniffer/apm-sdk-plugin/resin-3.x-plugin/src/test/java/org/skywalking/apm/plugin/resin/v3/ResinV3InterceptorTest.java index f36301c83..f52879d6a 100644 --- a/apm-sniffer/apm-sdk-plugin/resin-3.x-plugin/src/test/java/org/skywalking/apm/plugin/resin/v3/ResinV3InterceptorTest.java +++ b/apm-sniffer/apm-sdk-plugin/resin-3.x-plugin/src/test/java/org/skywalking/apm/plugin/resin/v3/ResinV3InterceptorTest.java @@ -78,8 +78,8 @@ public class ResinV3InterceptorTest { @Test public void testWithoutSerializedContextData() throws Throwable { - interceptor.beforeMethod(enhancedInstance, "service", arguments, argumentType, methodInterceptResult); - interceptor.afterMethod(enhancedInstance, "service", arguments, argumentType, null); + interceptor.beforeMethod(enhancedInstance, null, arguments, argumentType, methodInterceptResult); + interceptor.afterMethod(enhancedInstance, null, arguments, argumentType, null); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -92,8 +92,8 @@ public class ResinV3InterceptorTest { public void testWithSerializedContextData() throws Throwable { when(request.getHeader(Config.Plugin.Propagation.HEADER_NAME)).thenReturn("#AQA*#AQA*4WcWe0tQNQA*|3|1|1|#192.168.1.8:18002|#/portal/|#/testEntrySpan|#AQA*#AQA*Et0We0tQNQA*"); - interceptor.beforeMethod(enhancedInstance, "service", arguments, argumentType, methodInterceptResult); - interceptor.afterMethod(enhancedInstance, "service", arguments, argumentType, null); + interceptor.beforeMethod(enhancedInstance, null, arguments, argumentType, methodInterceptResult); + interceptor.afterMethod(enhancedInstance, null, arguments, argumentType, null); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -105,9 +105,9 @@ public class ResinV3InterceptorTest { @Test public void testWithOccurException() throws Throwable { - interceptor.beforeMethod(enhancedInstance, "service", arguments, argumentType, methodInterceptResult); - interceptor.handleMethodException(enhancedInstance, "service", arguments, argumentType, new RuntimeException()); - interceptor.afterMethod(enhancedInstance, "service", arguments, argumentType, null); + interceptor.beforeMethod(enhancedInstance, null, arguments, argumentType, methodInterceptResult); + interceptor.handleMethodException(enhancedInstance, null, arguments, argumentType, new RuntimeException()); + interceptor.afterMethod(enhancedInstance, null, arguments, argumentType, null); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); diff --git a/apm-sniffer/apm-sdk-plugin/resin-4.x-plugin/src/main/java/org/skywalking/apm/plugin/resin/v4/ResinV4Interceptor.java b/apm-sniffer/apm-sdk-plugin/resin-4.x-plugin/src/main/java/org/skywalking/apm/plugin/resin/v4/ResinV4Interceptor.java index a080a33f9..8e7f31ce0 100644 --- a/apm-sniffer/apm-sdk-plugin/resin-4.x-plugin/src/main/java/org/skywalking/apm/plugin/resin/v4/ResinV4Interceptor.java +++ b/apm-sniffer/apm-sdk-plugin/resin-4.x-plugin/src/main/java/org/skywalking/apm/plugin/resin/v4/ResinV4Interceptor.java @@ -1,6 +1,7 @@ package org.skywalking.apm.plugin.resin.v4; import com.caucho.server.http.CauchoRequest; +import java.lang.reflect.Method; import javax.servlet.http.HttpServletResponse; import org.skywalking.apm.agent.core.conf.Config; import org.skywalking.apm.agent.core.context.ContextCarrier; @@ -18,7 +19,7 @@ import org.skywalking.apm.network.trace.component.ComponentsDefine; */ public class ResinV4Interceptor implements InstanceMethodsAroundInterceptor { @Override - public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { CauchoRequest request = (CauchoRequest)allArguments[0]; String tracingHeaderValue = request.getHeader(Config.Plugin.Propagation.HEADER_NAME); @@ -31,7 +32,7 @@ public class ResinV4Interceptor implements InstanceMethodsAroundInterceptor { } @Override - public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { HttpServletResponse response = (HttpServletResponse)allArguments[1]; AbstractSpan span = ContextManager.activeSpan(); @@ -44,7 +45,7 @@ public class ResinV4Interceptor implements InstanceMethodsAroundInterceptor { return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { AbstractSpan activeSpan = ContextManager.activeSpan(); activeSpan.log(t); diff --git a/apm-sniffer/apm-sdk-plugin/resin-4.x-plugin/src/test/java/org/skywalking/apm/plugin/resin/v4/ResinV4InterceptorTest.java b/apm-sniffer/apm-sdk-plugin/resin-4.x-plugin/src/test/java/org/skywalking/apm/plugin/resin/v4/ResinV4InterceptorTest.java index aeed0ffa3..e46e4365d 100644 --- a/apm-sniffer/apm-sdk-plugin/resin-4.x-plugin/src/test/java/org/skywalking/apm/plugin/resin/v4/ResinV4InterceptorTest.java +++ b/apm-sniffer/apm-sdk-plugin/resin-4.x-plugin/src/test/java/org/skywalking/apm/plugin/resin/v4/ResinV4InterceptorTest.java @@ -80,8 +80,8 @@ public class ResinV4InterceptorTest { @Test public void testWithoutSerializedContextData() throws Throwable { - interceptor.beforeMethod(enhancedInstance, "service", arguments, argumentType, methodInterceptResult); - interceptor.afterMethod(enhancedInstance, "service", arguments, argumentType, null); + interceptor.beforeMethod(enhancedInstance, null, arguments, argumentType, methodInterceptResult); + interceptor.afterMethod(enhancedInstance, null, arguments, argumentType, null); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -94,8 +94,8 @@ public class ResinV4InterceptorTest { public void testWithSerializedContextData() throws Throwable { when(request.getHeader(Config.Plugin.Propagation.HEADER_NAME)).thenReturn("#AQA*#AQA*4WcWe0tQNQA*|3|1|1|#192.168.1.8:18002|#/portal/|#/testEntrySpan|#AQA*#AQA*Et0We0tQNQA*"); - interceptor.beforeMethod(enhancedInstance, "service", arguments, argumentType, methodInterceptResult); - interceptor.afterMethod(enhancedInstance, "service", arguments, argumentType, null); + interceptor.beforeMethod(enhancedInstance, null, arguments, argumentType, methodInterceptResult); + interceptor.afterMethod(enhancedInstance, null, arguments, argumentType, null); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -107,9 +107,9 @@ public class ResinV4InterceptorTest { @Test public void testWithOccurException() throws Throwable { - interceptor.beforeMethod(enhancedInstance, "service", arguments, argumentType, methodInterceptResult); - interceptor.handleMethodException(enhancedInstance, "service", arguments, argumentType, new RuntimeException()); - interceptor.afterMethod(enhancedInstance, "service", arguments, argumentType, null); + interceptor.beforeMethod(enhancedInstance, null, arguments, argumentType, methodInterceptResult); + interceptor.handleMethodException(enhancedInstance, null, arguments, argumentType, new RuntimeException()); + interceptor.afterMethod(enhancedInstance, null, arguments, argumentType, null); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); diff --git a/apm-sniffer/apm-sdk-plugin/tomcat-7.x-8.x-plugin/src/main/java/org/skywalking/apm/plugin/tomcat78x/TomcatInterceptor.java b/apm-sniffer/apm-sdk-plugin/tomcat-7.x-8.x-plugin/src/main/java/org/skywalking/apm/plugin/tomcat78x/TomcatInterceptor.java index 803635b7a..fed1f7f1c 100644 --- a/apm-sniffer/apm-sdk-plugin/tomcat-7.x-8.x-plugin/src/main/java/org/skywalking/apm/plugin/tomcat78x/TomcatInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/tomcat-7.x-8.x-plugin/src/main/java/org/skywalking/apm/plugin/tomcat78x/TomcatInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.plugin.tomcat78x; +import java.lang.reflect.Method; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.skywalking.apm.agent.core.conf.Config; @@ -26,13 +27,13 @@ public class TomcatInterceptor implements InstanceMethodsAroundInterceptor { * trace segment id of the previous level if the serialized context is not null. * * @param objInst - * @param methodName + * @param method * @param allArguments * @param argumentsTypes * @param result change this result, if you want to truncate the method. * @throws Throwable */ - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { HttpServletRequest request = (HttpServletRequest)allArguments[0]; String tracingHeaderValue = request.getHeader(Config.Plugin.Propagation.HEADER_NAME); @@ -45,7 +46,7 @@ public class TomcatInterceptor implements InstanceMethodsAroundInterceptor { } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { HttpServletResponse response = (HttpServletResponse)allArguments[1]; @@ -58,7 +59,7 @@ public class TomcatInterceptor implements InstanceMethodsAroundInterceptor { return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { AbstractSpan span = ContextManager.activeSpan(); span.log(t); diff --git a/apm-sniffer/apm-sdk-plugin/tomcat-7.x-8.x-plugin/src/test/java/org/skywalking/apm/plugin/tomcat78x/TomcatInterceptorTest.java b/apm-sniffer/apm-sdk-plugin/tomcat-7.x-8.x-plugin/src/test/java/org/skywalking/apm/plugin/tomcat78x/TomcatInterceptorTest.java index 3bd02a897..f83414042 100644 --- a/apm-sniffer/apm-sdk-plugin/tomcat-7.x-8.x-plugin/src/test/java/org/skywalking/apm/plugin/tomcat78x/TomcatInterceptorTest.java +++ b/apm-sniffer/apm-sdk-plugin/tomcat-7.x-8.x-plugin/src/test/java/org/skywalking/apm/plugin/tomcat78x/TomcatInterceptorTest.java @@ -71,8 +71,8 @@ public class TomcatInterceptorTest { @Test public void testWithoutSerializedContextData() throws Throwable { - tomcatInterceptor.beforeMethod(enhancedInstance, "invoke", arguments, argumentType, methodInterceptResult); - tomcatInterceptor.afterMethod(enhancedInstance, "invoke", arguments, argumentType, null); + tomcatInterceptor.beforeMethod(enhancedInstance, null, arguments, argumentType, methodInterceptResult); + tomcatInterceptor.afterMethod(enhancedInstance, null, arguments, argumentType, null); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -84,8 +84,8 @@ public class TomcatInterceptorTest { public void testWithSerializedContextData() throws Throwable { when(request.getHeader(Config.Plugin.Propagation.HEADER_NAME)).thenReturn("#AQA*#AQA*4WcWe0tQNQA*|3|1|1|#192.168.1.8:18002|#/portal/|#/testEntrySpan|#AQA*#AQA*Et0We0tQNQA*"); - tomcatInterceptor.beforeMethod(enhancedInstance, "invoke", arguments, argumentType, methodInterceptResult); - tomcatInterceptor.afterMethod(enhancedInstance, "invoke", arguments, argumentType, null); + tomcatInterceptor.beforeMethod(enhancedInstance, null, arguments, argumentType, methodInterceptResult); + tomcatInterceptor.afterMethod(enhancedInstance, null, arguments, argumentType, null); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); @@ -97,9 +97,9 @@ public class TomcatInterceptorTest { @Test public void testWithOccurException() throws Throwable { - tomcatInterceptor.beforeMethod(enhancedInstance, "invoke", arguments, argumentType, methodInterceptResult); - tomcatInterceptor.handleMethodException(enhancedInstance, "invoke", arguments, argumentType, new RuntimeException()); - tomcatInterceptor.afterMethod(enhancedInstance, "invoke", arguments, argumentType, null); + tomcatInterceptor.beforeMethod(enhancedInstance, null, arguments, argumentType, methodInterceptResult); + tomcatInterceptor.handleMethodException(enhancedInstance, null, arguments, argumentType, new RuntimeException()); + tomcatInterceptor.afterMethod(enhancedInstance, null, arguments, argumentType, null); assertThat(segmentStorage.getTraceSegments().size(), is(1)); TraceSegment traceSegment = segmentStorage.getTraceSegments().get(0); diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-log4j-1.x-activation/src/main/java/org/skywalking/apm/toolkit/activation/log/log4j/v1/x/PrintTraceIdInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-log4j-1.x-activation/src/main/java/org/skywalking/apm/toolkit/activation/log/log4j/v1/x/PrintTraceIdInterceptor.java index ea5693c31..8b60fd602 100644 --- a/apm-sniffer/apm-toolkit-activation/apm-toolkit-log4j-1.x-activation/src/main/java/org/skywalking/apm/toolkit/activation/log/log4j/v1/x/PrintTraceIdInterceptor.java +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-log4j-1.x-activation/src/main/java/org/skywalking/apm/toolkit/activation/log/log4j/v1/x/PrintTraceIdInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.toolkit.activation.log.log4j.v1.x; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.context.ContextManager; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; @@ -10,17 +11,17 @@ import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptR */ public class PrintTraceIdInterceptor implements InstanceMethodsAroundInterceptor { - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { return "TID:" + ContextManager.getGlobalTraceId(); } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { } diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-log4j-2.x-activation/src/main/java/org/skywalking/apm/toolkit/activation/log/log4j/v2/x/PrintTraceIdInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-log4j-2.x-activation/src/main/java/org/skywalking/apm/toolkit/activation/log/log4j/v2/x/PrintTraceIdInterceptor.java index a17c6b929..226544939 100644 --- a/apm-sniffer/apm-toolkit-activation/apm-toolkit-log4j-2.x-activation/src/main/java/org/skywalking/apm/toolkit/activation/log/log4j/v2/x/PrintTraceIdInterceptor.java +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-log4j-2.x-activation/src/main/java/org/skywalking/apm/toolkit/activation/log/log4j/v2/x/PrintTraceIdInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.toolkit.activation.log.log4j.v2.x; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.context.ContextManager; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.StaticMethodsAroundInterceptor; @@ -11,9 +12,10 @@ public class PrintTraceIdInterceptor implements StaticMethodsAroundInterceptor { /** * Override org.skywalking.apm.toolkit.log.log4j.v2.x.Log4j2OutputAppender.append(), * + * @param method * @param result change this result, to output the traceId. The origin append() method will not invoke. */ - @Override public void beforeMethod(Class clazz, String methodName, Object[] allArguments, Class[] parameterTypes, + @Override public void beforeMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, MethodInterceptResult result) { ((StringBuilder)allArguments[0]).append("TID:" + ContextManager.getGlobalTraceId()); @@ -22,13 +24,13 @@ public class PrintTraceIdInterceptor implements StaticMethodsAroundInterceptor { } @Override - public Object afterMethod(Class clazz, String methodName, Object[] allArguments, Class[] parameterTypes, + public Object afterMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, Object ret) { return null; } @Override - public void handleMethodException(Class clazz, String methodName, Object[] allArguments, Class[] parameterTypes, + public void handleMethodException(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, Throwable t) { } diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-logback-1.x-activation/src/main/java/org/skywalking/apm/toolkit/activation/log/logback/v1/x/PrintTraceIdInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-logback-1.x-activation/src/main/java/org/skywalking/apm/toolkit/activation/log/logback/v1/x/PrintTraceIdInterceptor.java index 277f36248..e83b9bb4d 100644 --- a/apm-sniffer/apm-toolkit-activation/apm-toolkit-logback-1.x-activation/src/main/java/org/skywalking/apm/toolkit/activation/log/logback/v1/x/PrintTraceIdInterceptor.java +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-logback-1.x-activation/src/main/java/org/skywalking/apm/toolkit/activation/log/logback/v1/x/PrintTraceIdInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.toolkit.activation.log.logback.v1.x; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.context.ContextManager; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; @@ -10,17 +11,17 @@ import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptR */ public class PrintTraceIdInterceptor implements InstanceMethodsAroundInterceptor { - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { return "TID:" + ContextManager.getGlobalTraceId(); } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { } diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/continuation/ActivateInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/continuation/ActivateInterceptor.java index cc90a182b..e352d0dab 100644 --- a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/continuation/ActivateInterceptor.java +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/continuation/ActivateInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.toolkit.activation.opentracing.continuation; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.context.ContextManager; import org.skywalking.apm.agent.core.context.ContextSnapshot; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; @@ -7,11 +8,11 @@ import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsA import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; public class ActivateInterceptor implements InstanceMethodsAroundInterceptor { - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { Object contextSnapshot = objInst.getSkyWalkingDynamicField(); if (contextSnapshot != null) { @@ -20,7 +21,7 @@ public class ActivateInterceptor implements InstanceMethodsAroundInterceptor { return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { } diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanFinishInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanFinishInterceptor.java index f3163b475..e7a27db54 100644 --- a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanFinishInterceptor.java +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanFinishInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.toolkit.activation.opentracing.span; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.context.ContextManager; import org.skywalking.apm.agent.core.context.trace.AbstractSpan; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; @@ -8,13 +9,13 @@ import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptR public class SpanFinishInterceptor implements InstanceMethodsAroundInterceptor { @Override - public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { } @Override - public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { AbstractSpan abstractSpan = (AbstractSpan)objInst.getSkyWalkingDynamicField(); if (abstractSpan != null) { @@ -24,7 +25,7 @@ public class SpanFinishInterceptor implements InstanceMethodsAroundInterceptor { } @Override - public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { } diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanLogInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanLogInterceptor.java index bd665f0c5..97931e915 100644 --- a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanLogInterceptor.java +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanLogInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.toolkit.activation.opentracing.span; +import java.lang.reflect.Method; import java.util.Map; import org.skywalking.apm.agent.core.context.trace.AbstractSpan; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; @@ -11,13 +12,13 @@ import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptR */ public class SpanLogInterceptor implements InstanceMethodsAroundInterceptor { @Override - public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { } @Override - public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { AbstractSpan abstractSpan = (AbstractSpan)objInst.getSkyWalkingDynamicField(); if (abstractSpan != null) { @@ -27,7 +28,7 @@ public class SpanLogInterceptor implements InstanceMethodsAroundInterceptor { } @Override - public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { } diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanSetOperationNameInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanSetOperationNameInterceptor.java index 3611b4160..ed1bff350 100644 --- a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanSetOperationNameInterceptor.java +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanSetOperationNameInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.toolkit.activation.opentracing.span; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.context.trace.AbstractSpan; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; @@ -7,13 +8,13 @@ import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptR public class SpanSetOperationNameInterceptor implements InstanceMethodsAroundInterceptor { @Override - public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { } @Override - public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { AbstractSpan tracingSpan = (AbstractSpan)objInst.getSkyWalkingDynamicField(); if (tracingSpan != null) { @@ -23,7 +24,7 @@ public class SpanSetOperationNameInterceptor implements InstanceMethodsAroundInt } @Override - public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { } diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanSetTagInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanSetTagInterceptor.java index 3abc0ebde..7dd89c2a8 100644 --- a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanSetTagInterceptor.java +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanSetTagInterceptor.java @@ -1,6 +1,7 @@ package org.skywalking.apm.toolkit.activation.opentracing.span; import io.opentracing.tag.Tags; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.context.ContextManager; import org.skywalking.apm.agent.core.context.trace.AbstractSpan; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; @@ -9,12 +10,12 @@ import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptR public class SpanSetTagInterceptor implements InstanceMethodsAroundInterceptor { @Override - public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { } @Override - public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { AbstractSpan activeSpan = ContextManager.activeSpan(); String tagKey = String.valueOf(allArguments[0]); @@ -30,7 +31,7 @@ public class SpanSetTagInterceptor implements InstanceMethodsAroundInterceptor { } @Override - public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { } diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/tracer/SkywalkingTracerExtractInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/tracer/SkywalkingTracerExtractInterceptor.java index ae71b4d00..d91d29144 100644 --- a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/tracer/SkywalkingTracerExtractInterceptor.java +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/tracer/SkywalkingTracerExtractInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.toolkit.activation.opentracing.tracer; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.context.ContextCarrier; import org.skywalking.apm.agent.core.context.ContextManager; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; @@ -8,13 +9,13 @@ import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptR public class SkywalkingTracerExtractInterceptor implements InstanceMethodsAroundInterceptor { @Override - public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { } @Override - public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { String carrier = (String)allArguments[0]; ContextCarrier contextCarrier = new ContextCarrier().deserialize(carrier); @@ -23,7 +24,7 @@ public class SkywalkingTracerExtractInterceptor implements InstanceMethodsAround } @Override - public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { } diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/tracer/SkywalkingTracerInjectInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/tracer/SkywalkingTracerInjectInterceptor.java index dcdead7c5..34a44c21e 100644 --- a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/tracer/SkywalkingTracerInjectInterceptor.java +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/tracer/SkywalkingTracerInjectInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.toolkit.activation.opentracing.tracer; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.context.ContextCarrier; import org.skywalking.apm.agent.core.context.ContextManager; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; @@ -8,13 +9,13 @@ import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptR public class SkywalkingTracerInjectInterceptor implements InstanceMethodsAroundInterceptor { @Override - public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { } @Override - public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { ContextCarrier contextCarrier = new ContextCarrier(); ContextManager.inject(contextCarrier); @@ -22,7 +23,7 @@ public class SkywalkingTracerInjectInterceptor implements InstanceMethodsAroundI } @Override - public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { } diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/test/java/org/skywalking/apm/toolkit/activation/opentracing/SkywalkingSpanActivationTest.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/test/java/org/skywalking/apm/toolkit/activation/opentracing/SkywalkingSpanActivationTest.java index b09e5c1e1..c8c5e9eec 100644 --- a/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/test/java/org/skywalking/apm/toolkit/activation/opentracing/SkywalkingSpanActivationTest.java +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/test/java/org/skywalking/apm/toolkit/activation/opentracing/SkywalkingSpanActivationTest.java @@ -4,6 +4,7 @@ import io.opentracing.Tracer; import io.opentracing.tag.Tags; import java.util.HashMap; import java.util.List; +import java.util.Map; import org.junit.Before; import org.junit.Rule; import org.junit.Test; @@ -30,7 +31,10 @@ import org.skywalking.apm.toolkit.activation.opentracing.span.SpanLogInterceptor import org.skywalking.apm.toolkit.activation.opentracing.span.SpanSetOperationNameInterceptor; import org.skywalking.apm.toolkit.activation.opentracing.tracer.SkywalkingTracerExtractInterceptor; import org.skywalking.apm.toolkit.activation.opentracing.tracer.SkywalkingTracerInjectInterceptor; +import org.skywalking.apm.toolkit.opentracing.SkywalkingContinuation; +import org.skywalking.apm.toolkit.opentracing.SkywalkingSpan; import org.skywalking.apm.toolkit.opentracing.SkywalkingSpanBuilder; +import org.skywalking.apm.toolkit.opentracing.SkywalkingTracer; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.MatcherAssert.assertThat; @@ -166,7 +170,7 @@ public class SkywalkingSpanActivationTest { .withTag(Tags.PEER_HOST_IPV4.getKey(), "127.0.0.1").withTag(Tags.PEER_PORT.getKey(), 8080); startSpan(); - String extractValue = (String)injectInterceptor.afterMethod(enhancedInstance, "extract", + String extractValue = (String)injectInterceptor.afterMethod(enhancedInstance, null, null, null, null); ContextCarrier contextCarrier = new ContextCarrier().deserialize(extractValue); @@ -182,7 +186,7 @@ public class SkywalkingSpanActivationTest { spanBuilder.withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT) .withTag(Tags.PEER_HOST_IPV4.getKey(), "127.0.0.1").withTag(Tags.PEER_PORT.getKey(), 8080); startSpan(); - extractInterceptor.afterMethod(enhancedInstance, "extract", + extractInterceptor.afterMethod(enhancedInstance, null, new Object[] {"#AQA*#AQA*4WcWe0tQNQA*|3|1|1|#127.0.0.1:8080|#/portal/|#/testEntrySpan|#AQA*#AQA*Et0We0tQNQA*"}, new Class[] {String.class}, null); stopSpan(); @@ -197,12 +201,13 @@ public class SkywalkingSpanActivationTest { assertThat(spans.size(), is(1)); assertSpanCommonsAttribute(spans.get(0)); } + @Test public void testExtractWithInValidateContext() throws Throwable { spanBuilder.withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT) .withTag(Tags.PEER_HOST_IPV4.getKey(), "127.0.0.1").withTag(Tags.PEER_PORT.getKey(), 8080); startSpan(); - extractInterceptor.afterMethod(enhancedInstance, "extract", + extractInterceptor.afterMethod(enhancedInstance, null, new Object[] {"#AQA*#AQA*4WcWe0tQNQA*|3|#192.168.1.8:18002|#/portal/|#/testEntrySpan|#AQA*#AQA*Et0We0tQNQA*"}, new Class[] {String.class}, null); stopSpan(); @@ -223,7 +228,7 @@ public class SkywalkingSpanActivationTest { MockEnhancedInstance enhancedInstance = new MockEnhancedInstance(); try { startSpan(enhancedInstance); - activateInterceptor.afterMethod(continuationHolder, "activate", null, null, null); + activateInterceptor.afterMethod(continuationHolder, SkywalkingContinuation.class.getMethod("activate"), null, null, null); } catch (Throwable throwable) { throwable.printStackTrace(); } finally { @@ -258,7 +263,7 @@ public class SkywalkingSpanActivationTest { } private void stopSpan(EnhancedInstance enhancedInstance) throws Throwable { - spanFinishInterceptor.afterMethod(enhancedInstance, "finish", null, null, null); + spanFinishInterceptor.afterMethod(enhancedInstance, null, null, null, null); } private void startSpan() throws Throwable { @@ -267,9 +272,9 @@ public class SkywalkingSpanActivationTest { private void startSpan(MockEnhancedInstance enhancedInstance) throws Throwable { constructorWithSpanBuilderInterceptor.onConstruct(enhancedInstance, new Object[] {spanBuilder}); - spanLogInterceptor.afterMethod(enhancedInstance, "log", logArgument, logArgumentType, null); + spanLogInterceptor.afterMethod(enhancedInstance, null, logArgument, logArgumentType, null); - setOperationNameInterceptor.afterMethod(enhancedInstance, "setOperationName", + setOperationNameInterceptor.afterMethod(enhancedInstance, SkywalkingSpan.class.getMethod("setOperationName", String.class), setOperationNameArgument, setOperationNameArgumentType, null); } diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-context-activation/src/main/java/org/skywalking/apm/toolkit/activation/trace/TraceContextInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-context-activation/src/main/java/org/skywalking/apm/toolkit/activation/trace/TraceContextInterceptor.java index 4b0907663..418aa35b3 100644 --- a/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-context-activation/src/main/java/org/skywalking/apm/toolkit/activation/trace/TraceContextInterceptor.java +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-context-activation/src/main/java/org/skywalking/apm/toolkit/activation/trace/TraceContextInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.toolkit.activation.trace; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.context.ContextManager; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.StaticMethodsAroundInterceptor; @@ -10,19 +11,19 @@ public class TraceContextInterceptor implements StaticMethodsAroundInterceptor { private ILog logger = LogManager.getLogger(TraceContextInterceptor.class); - @Override public void beforeMethod(Class clazz, String methodName, Object[] allArguments, Class[] parameterTypes, + @Override public void beforeMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, MethodInterceptResult result) { } @Override - public Object afterMethod(Class clazz, String methodName, Object[] allArguments, Class[] parameterTypes, + public Object afterMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, Object ret) { return ContextManager.getGlobalTraceId(); } @Override - public void handleMethodException(Class clazz, String methodName, Object[] allArguments, Class[] parameterTypes, + public void handleMethodException(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, Throwable t) { logger.error("Failed to get trace Id.", t); } From e0442497c00e601d638fa60e337b49e5fda89923 Mon Sep 17 00:00:00 2001 From: wusheng Date: Thu, 10 Aug 2017 20:45:43 +0800 Subject: [PATCH 04/12] Reset some comments. --- .../apm/agent/core/plugin/PluginResourcesResolver.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/PluginResourcesResolver.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/PluginResourcesResolver.java index 84c2955a7..34e56e93f 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/PluginResourcesResolver.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/PluginResourcesResolver.java @@ -27,7 +27,7 @@ public class PluginResourcesResolver { while (urls.hasMoreElements()) { URL pluginUrl = urls.nextElement(); cfgUrlPaths.add(pluginUrl); - logger.info("findOrPrepare4Register skywalking plugin define in {}", pluginUrl); + logger.info("find skywalking plugin define in {}", pluginUrl); } return cfgUrlPaths; @@ -42,7 +42,7 @@ public class PluginResourcesResolver { * First get current thread's classloader, * if fail, get {@link PluginResourcesResolver}'s classloader. * - * @return the classloader to findOrPrepare4Register plugin definitions. + * @return the classloader to find plugin definitions. */ private ClassLoader getDefaultClassLoader() { ClassLoader cl = null; From f5d5cd3b9b97eade250642d444e22b488f6ad4c5 Mon Sep 17 00:00:00 2001 From: wusheng Date: Thu, 10 Aug 2017 20:49:22 +0800 Subject: [PATCH 05/12] Reset some comments. --- .../agent/core/plugin/AbstractClassEnhancePluginDefine.java | 4 ++-- .../org/skywalking/apm/agent/core/plugin/PluginFinder.java | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/AbstractClassEnhancePluginDefine.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/AbstractClassEnhancePluginDefine.java index 29cafff54..87bfae3ed 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/AbstractClassEnhancePluginDefine.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/AbstractClassEnhancePluginDefine.java @@ -37,7 +37,7 @@ public abstract class AbstractClassEnhancePluginDefine { logger.debug("prepare to enhance class {} by {}.", transformClassName, interceptorDefineClassName); /** - * findOrPrepare4Register witness classes for enhance class + * find witness classes for enhance class */ String[] witnessClasses = witnessClasses(); if (witnessClasses != null) { @@ -51,7 +51,7 @@ public abstract class AbstractClassEnhancePluginDefine { } /** - * findOrPrepare4Register origin class source code for interceptor + * find origin class source code for interceptor */ DynamicType.Builder newClassBuilder = this.enhance(transformClassName, builder, classLoader); diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/PluginFinder.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/PluginFinder.java index 4adaaaa6d..271b32cee 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/PluginFinder.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/PluginFinder.java @@ -16,7 +16,7 @@ import static net.bytebuddy.matcher.ElementMatchers.isInterface; import static net.bytebuddy.matcher.ElementMatchers.not; /** - * The PluginFinder represents a finder , which assist to findOrPrepare4Register the one + * The PluginFinder represents a finder , which assist to find the one * from the given {@link AbstractClassEnhancePluginDefine} list. * * @author wusheng From 0a5dd6691c8e2f88ad413f47b336a3b77a63d566 Mon Sep 17 00:00:00 2001 From: ascrutae Date: Fri, 11 Aug 2017 07:12:50 +0800 Subject: [PATCH 06/12] no message --- .../concurrent-util-4.3.x-plugin/pom.xml | 2 +- .../FailureCallbackInterceptor.java | 13 +++++----- .../SuccessCallbackInterceptor.java | 14 +++++----- ...stenableFutureCallbackInstrumentation.java | 26 +++++++++++-------- .../SuccessCallbackInstrumentation.java | 7 +++-- .../apm-sdk-plugin/spring-plugins/pom.xml | 2 ++ .../resttemplate-4.3.x-plugin/pom.xml | 2 +- .../async/FutureGetInterceptor.java | 14 +++++----- .../async/ResponseCallBackInterceptor.java | 13 ++++++---- .../async/RestExecuteInterceptor.java | 12 ++++----- .../define/RestTemplateInstrumentation.java | 2 -- .../sync/RestExecuteInterceptor.java | 14 +++++----- .../sync/RestRequestInterceptor.java | 14 ++++++---- .../sync/RestResponseInterceptor.java | 14 ++++++---- .../http/client/RestRequestInterceptor.java | 14 ++++++---- 15 files changed, 92 insertions(+), 71 deletions(-) diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/pom.xml b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/pom.xml index 2e3fd3b4f..cc6855d02 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/pom.xml +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/pom.xml @@ -7,7 +7,7 @@ 4.0.0 - apm-spring-concurrent-util-plugin + apm-spring-concurrent-util-4.3.x-plugin jar concurrent-util-4.3.x-plugin diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java index 56ae40584..ed8a2205d 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.plugin.spring.concurrent; +import java.lang.reflect.Method; import java.net.URI; import org.skywalking.apm.agent.core.context.ContextManager; import org.skywalking.apm.agent.core.context.ContextSnapshot; @@ -14,8 +15,8 @@ import org.skywalking.apm.network.trace.component.ComponentsDefine; public class FailureCallbackInterceptor implements InstanceMethodsAroundInterceptor { @Override - public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + MethodInterceptResult result) throws Throwable { Object[] cacheValues = (Object[])objInst.getSkyWalkingDynamicField(); if (cacheValues == null) { return; @@ -29,16 +30,14 @@ public class FailureCallbackInterceptor implements InstanceMethodsAroundIntercep } @Override - public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, Object ret) throws Throwable { + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + Object ret) throws Throwable { ContextManager.stopSpan(); return ret; } - @Override - public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { ContextManager.activeSpan().errorOccurred().log(t); } - } diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java index 482a88638..951a40582 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.plugin.spring.concurrent; +import java.lang.reflect.Method; import java.net.URI; import org.skywalking.apm.agent.core.context.ContextManager; import org.skywalking.apm.agent.core.context.ContextSnapshot; @@ -13,8 +14,9 @@ import org.skywalking.apm.network.trace.component.ComponentsDefine; public class SuccessCallbackInterceptor implements InstanceMethodsAroundInterceptor { - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + @Override + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + MethodInterceptResult result) throws Throwable { Object[] cacheValues = (Object[])objInst.getSkyWalkingDynamicField(); if (cacheValues == null) { return; @@ -27,15 +29,15 @@ public class SuccessCallbackInterceptor implements InstanceMethodsAroundIntercep ContextManager.continued((ContextSnapshot)cacheValues[2]); } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, Object ret) throws Throwable { + @Override + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + Object ret) throws Throwable { ContextManager.stopSpan(); return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { ContextManager.activeSpan().errorOccurred().log(t); } - } diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/ListenableFutureCallbackInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/ListenableFutureCallbackInstrumentation.java index 74ebbcad7..fc1b27111 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/ListenableFutureCallbackInstrumentation.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/ListenableFutureCallbackInstrumentation.java @@ -6,41 +6,44 @@ import org.skywalking.apm.agent.core.plugin.interceptor.ConstructorInterceptPoin import org.skywalking.apm.agent.core.plugin.interceptor.InstanceMethodsInterceptPoint; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.ClassInstanceMethodsEnhancePluginDefine; import org.skywalking.apm.agent.core.plugin.match.ClassMatch; -import org.skywalking.apm.plugin.spring.concurrent.FailureCallbackInterceptor; -import org.skywalking.apm.plugin.spring.concurrent.SuccessCallbackInterceptor; import static net.bytebuddy.matcher.ElementMatchers.named; import static org.skywalking.apm.plugin.spring.concurrent.match.ListenableFutureCallbackMatch.listenableFutureCallbackMatch; /** * {@link ListenableFutureCallbackInstrumentation} enhance onSuccess method and oonFailure - * that class inherited org.springframework.util.concurrent.ListenableFutureCallback by {@link - * SuccessCallbackInterceptor} and {@link FailureCallbackInterceptor }. + * that class inherited org.springframework.util.concurrent.ListenableFutureCallback by + * org.skywalking.apm.plugin.spring.concurrent.SuccessCallbackInterceptor and + * org.skywalking.apm.plugin.spring.concurrent.FailureCallbackInterceptor. * * @author zhangxin */ public class ListenableFutureCallbackInstrumentation extends ClassInstanceMethodsEnhancePluginDefine { - @Override protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() { + @Override + protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() { return new ConstructorInterceptPoint[0]; } - @Override protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() { + @Override + protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() { return new InstanceMethodsInterceptPoint[] { new InstanceMethodsInterceptPoint() { - @Override public ElementMatcher getMethodsMatcher() { + @Override + public ElementMatcher getMethodsMatcher() { return named(SuccessCallbackInstrumentation.SUCCESS_METHOD_NAME); } - @Override public String getMethodsInterceptor() { + @Override + public String getMethodsInterceptor() { return SuccessCallbackInstrumentation.SUCCESS_CALLBACK_INTERCEPTOR; } - @Override public boolean isOverrideArgs() { + @Override + public boolean isOverrideArgs() { return false; } }, new InstanceMethodsInterceptPoint() { - @Override public ElementMatcher getMethodsMatcher() { return named(FailureCallbackInstrumentation.FAILURE_METHOD_NAME); @@ -59,7 +62,8 @@ public class ListenableFutureCallbackInstrumentation extends ClassInstanceMethod }; } - @Override protected ClassMatch enhanceClass() { + @Override + protected ClassMatch enhanceClass() { return listenableFutureCallbackMatch(); } } diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/SuccessCallbackInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/SuccessCallbackInstrumentation.java index 4be5c3381..51c7db24d 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/SuccessCallbackInstrumentation.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/SuccessCallbackInstrumentation.java @@ -6,21 +6,20 @@ import org.skywalking.apm.agent.core.plugin.interceptor.ConstructorInterceptPoin import org.skywalking.apm.agent.core.plugin.interceptor.InstanceMethodsInterceptPoint; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.ClassInstanceMethodsEnhancePluginDefine; import org.skywalking.apm.agent.core.plugin.match.ClassMatch; -import org.skywalking.apm.plugin.spring.concurrent.FailureCallbackInterceptor; -import org.skywalking.apm.plugin.spring.concurrent.SuccessCallbackInterceptor; import static net.bytebuddy.matcher.ElementMatchers.named; import static org.skywalking.apm.plugin.spring.concurrent.match.SuccessCallbackMatch.successCallbackMatch; /** * {@link SuccessCallbackInstrumentation} enhance the onSuccess method that class inherited - * org.springframework.util.concurrent.SuccessCallback by {@link SuccessCallbackInterceptor}. + * org.springframework.util.concurrent.SuccessCallback by org.skywalking.apm.plugin.spring.concurrent.SuccessCallbackInterceptor. * * @author zhangxin */ public class SuccessCallbackInstrumentation extends ClassInstanceMethodsEnhancePluginDefine { - public static final String SUCCESS_CALLBACK_INTERCEPTOR = "org.skywalking.apm.plugin.spring.concurrent.SuccessCallbackInterceptor"; + public static final String SUCCESS_CALLBACK_INTERCEPTOR = + "org.skywalking.apm.plugin.spring.concurrent.SuccessCallbackInterceptor"; public static final String SUCCESS_METHOD_NAME = "onSuccess"; @Override protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() { diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml b/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml index a7558877d..4417a3e14 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml @@ -11,6 +11,8 @@ spring-plugins + concurrent-util-4.3.x-plugin resttemplate-4.3.x-plugin diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/pom.xml b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/pom.xml index 3dde8eb50..f0700056a 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/pom.xml +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/pom.xml @@ -7,7 +7,7 @@ 4.0.0 - apm-resttemplate-plugin + apm-resttemplate-4.3.x-plugin jar resttemplate-4.3.x-plugin diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java index 102ba4e3b..d32fab57b 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java @@ -1,6 +1,6 @@ package org.skywalking.apm.plugin.spring.resttemplate.async; -import com.google.instrumentation.trace.Span; +import java.lang.reflect.Method; import java.net.URI; import java.util.List; import org.skywalking.apm.agent.core.context.ContextManager; @@ -10,22 +10,22 @@ import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsA import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; public class FutureGetInterceptor implements InstanceMethodsAroundInterceptor { + @Override - public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + MethodInterceptResult result) throws Throwable { List cacheValues = (List)objInst.getSkyWalkingDynamicField(); ContextManager.createLocalSpan("future/get:" + ((URI)cacheValues.get(0)).getPath()); } @Override - public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, Object ret) throws Throwable { + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + Object ret) throws Throwable { ContextManager.stopSpan(); return ret; } - @Override - public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { AbstractSpan activeSpan = ContextManager.activeSpan(); activeSpan.errorOccurred().log(t); diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/ResponseCallBackInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/ResponseCallBackInterceptor.java index ab4cc2dd8..421312ebe 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/ResponseCallBackInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/ResponseCallBackInterceptor.java @@ -1,13 +1,15 @@ package org.skywalking.apm.plugin.spring.resttemplate.async; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; public class ResponseCallBackInterceptor implements InstanceMethodsAroundInterceptor { - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + @Override + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + MethodInterceptResult result) throws Throwable { EnhancedInstance successCallBak = (EnhancedInstance)allArguments[0]; successCallBak.setSkyWalkingDynamicField(objInst.getSkyWalkingDynamicField()); @@ -17,12 +19,13 @@ public class ResponseCallBackInterceptor implements InstanceMethodsAroundInterce } } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, Object ret) throws Throwable { + @Override + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + Object ret) throws Throwable { return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { } diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java index 378ad6da6..9e4693997 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.plugin.spring.resttemplate.async; +import java.lang.reflect.Method; import java.net.URI; import org.skywalking.apm.agent.core.context.ContextCarrier; import org.skywalking.apm.agent.core.context.ContextManager; @@ -15,8 +16,8 @@ import org.springframework.http.HttpMethod; public class RestExecuteInterceptor implements InstanceMethodsAroundInterceptor { @Override - public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + MethodInterceptResult result) throws Throwable { final URI requestURL = (URI)allArguments[0]; final HttpMethod httpMethod = (HttpMethod)allArguments[1]; final ContextCarrier contextCarrier = new ContextCarrier(); @@ -34,8 +35,8 @@ public class RestExecuteInterceptor implements InstanceMethodsAroundInterceptor } @Override - public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, Object ret) throws Throwable { + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + Object ret) throws Throwable { Object[] cacheValues = (Object[])objInst.getSkyWalkingDynamicField(); cacheValues[3] = ContextManager.capture(); ((EnhancedInstance)ret).setSkyWalkingDynamicField(cacheValues); @@ -43,8 +44,7 @@ public class RestExecuteInterceptor implements InstanceMethodsAroundInterceptor return ret; } - @Override - public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { ContextManager.activeSpan().errorOccurred().log(t); } diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/RestTemplateInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/RestTemplateInstrumentation.java index 622ee4fe8..1cb6a20b0 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/RestTemplateInstrumentation.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/RestTemplateInstrumentation.java @@ -8,8 +8,6 @@ import org.skywalking.apm.agent.core.plugin.interceptor.ConstructorInterceptPoin import org.skywalking.apm.agent.core.plugin.interceptor.InstanceMethodsInterceptPoint; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.ClassInstanceMethodsEnhancePluginDefine; import org.skywalking.apm.agent.core.plugin.match.ClassMatch; -import org.skywalking.apm.plugin.spring.resttemplate.async.FutureGetInterceptor; -import org.skywalking.apm.plugin.spring.resttemplate.async.ResponseCallBackInterceptor; import static net.bytebuddy.matcher.ElementMatchers.named; import static org.skywalking.apm.agent.core.plugin.match.NameMatch.byName; diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java index 0fb1bec8f..c0567cba2 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.plugin.spring.resttemplate.sync; +import java.lang.reflect.Method; import java.net.URI; import org.skywalking.apm.agent.core.context.ContextCarrier; import org.skywalking.apm.agent.core.context.ContextManager; @@ -13,9 +14,10 @@ import org.skywalking.apm.network.trace.component.ComponentsDefine; import org.springframework.http.HttpMethod; public class RestExecuteInterceptor implements InstanceMethodsAroundInterceptor { - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + @Override + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + MethodInterceptResult result) throws Throwable { final URI requestURL = (URI)allArguments[0]; final HttpMethod httpMethod = (HttpMethod)allArguments[1]; final ContextCarrier contextCarrier = new ContextCarrier(); @@ -30,15 +32,15 @@ public class RestExecuteInterceptor implements InstanceMethodsAroundInterceptor objInst.setSkyWalkingDynamicField(contextCarrier.serialize()); } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, Object ret) throws Throwable { + @Override + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + Object ret) throws Throwable { ContextManager.stopSpan(); return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { ContextManager.activeSpan().errorOccurred().log(t); - } } diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestRequestInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestRequestInterceptor.java index ad8b709d3..23e062c5b 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestRequestInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestRequestInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.plugin.spring.resttemplate.sync; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.conf.Config; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; @@ -8,13 +9,16 @@ import org.springframework.http.client.AbstractClientHttpRequest; import org.springframework.http.client.ClientHttpRequest; public class RestRequestInterceptor implements InstanceMethodsAroundInterceptor { - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + + @Override + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + MethodInterceptResult result) throws Throwable { } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, Object ret) throws Throwable { + @Override + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + Object ret) throws Throwable { ClientHttpRequest clientHttpRequest = (ClientHttpRequest)ret; if (clientHttpRequest instanceof AbstractClientHttpRequest) { AbstractClientHttpRequest httpRequest = (AbstractClientHttpRequest)clientHttpRequest; @@ -23,7 +27,7 @@ public class RestRequestInterceptor implements InstanceMethodsAroundInterceptor return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { } diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestResponseInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestResponseInterceptor.java index f15bc56e8..80e554f52 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestResponseInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestResponseInterceptor.java @@ -1,5 +1,6 @@ package org.skywalking.apm.plugin.spring.resttemplate.sync; +import java.lang.reflect.Method; import org.skywalking.apm.agent.core.context.ContextManager; import org.skywalking.apm.agent.core.context.tag.Tags; import org.skywalking.apm.agent.core.context.trace.AbstractSpan; @@ -9,13 +10,16 @@ import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptR import org.springframework.http.client.ClientHttpResponse; public class RestResponseInterceptor implements InstanceMethodsAroundInterceptor { - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + + @Override + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + MethodInterceptResult result) throws Throwable { } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, Object ret) throws Throwable { + @Override + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + Object ret) throws Throwable { ClientHttpResponse response = (ClientHttpResponse)allArguments[2]; int statusCode = response.getStatusCode().value(); @@ -27,7 +31,7 @@ public class RestResponseInterceptor implements InstanceMethodsAroundInterceptor return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { ContextManager.activeSpan().errorOccurred().log(t); } diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/springframework/http/client/RestRequestInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/springframework/http/client/RestRequestInterceptor.java index 1ce1744c1..17218adfb 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/springframework/http/client/RestRequestInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/springframework/http/client/RestRequestInterceptor.java @@ -1,5 +1,6 @@ package org.springframework.http.client; +import java.lang.reflect.Method; import java.util.List; import org.skywalking.apm.agent.core.conf.Config; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; @@ -7,19 +8,22 @@ import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsA import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; public class RestRequestInterceptor implements InstanceMethodsAroundInterceptor { - @Override public void beforeMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { + + @Override + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + MethodInterceptResult result) throws Throwable { } - @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments, - Class[] argumentsTypes, Object ret) throws Throwable { + @Override + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + Object ret) throws Throwable { AbstractAsyncClientHttpRequest clientHttpRequest = (AbstractAsyncClientHttpRequest)ret; clientHttpRequest.getHeaders().set(Config.Plugin.Propagation.HEADER_NAME, String.valueOf(((List)objInst.getSkyWalkingDynamicField()).get(1))); return ret; } - @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments, + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Throwable t) { } From 78bbfd0f9f11881c68548797f68b9b171bdf276b Mon Sep 17 00:00:00 2001 From: ascrutae Date: Fri, 11 Aug 2017 10:00:32 +0800 Subject: [PATCH 07/12] modify support spring version --- apm-sniffer/apm-agent/pom.xml | 4 ++-- .../src/main/resources/skywalking-plugin.def | 3 --- .../pom.xml | 6 +++--- .../spring/concurrent/FailureCallbackInterceptor.java | 0 .../spring/concurrent/SuccessCallbackInterceptor.java | 0 .../concurrent/define/FailureCallbackInstrumentation.java | 0 .../define/ListenableFutureCallbackInstrumentation.java | 0 .../concurrent/define/SuccessCallbackInstrumentation.java | 0 .../spring/concurrent/match/EitherInterfaceMatch.java | 0 .../plugin/spring/concurrent/match/FailedCallbackMatch.java | 0 .../concurrent/match/ListenableFutureCallbackMatch.java | 0 .../spring/concurrent/match/SuccessCallbackMatch.java | 0 .../src/main/resources/skywalking-plugin.def | 3 +++ apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml | 6 ++---- .../src/main/resources/skywalking-plugin.def | 3 --- .../pom.xml | 2 +- .../spring/resttemplate/async/FutureGetInterceptor.java | 5 ++--- .../resttemplate/async/ResponseCallBackInterceptor.java | 0 .../spring/resttemplate/async/RestExecuteInterceptor.java | 6 ++++-- .../define/ResponseExtractorFutureInstrumentation.java | 0 .../async/define/RestTemplateInstrumentation.java | 0 .../spring/resttemplate/sync/RestExecuteInterceptor.java | 0 .../spring/resttemplate/sync/RestRequestInterceptor.java | 0 .../spring/resttemplate/sync/RestResponseInterceptor.java | 0 .../sync/define/RestTemplateInstrumentation.java | 0 .../springframework/http/client/RestRequestInterceptor.java | 5 +++-- .../src/main/resources/skywalking-plugin.def | 3 +++ 27 files changed, 23 insertions(+), 23 deletions(-) delete mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/resources/skywalking-plugin.def rename apm-sniffer/apm-sdk-plugin/spring-plugins/{concurrent-util-4.3.x-plugin => concurrent-util-4.x-plugin}/pom.xml (81%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{concurrent-util-4.3.x-plugin => concurrent-util-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{concurrent-util-4.3.x-plugin => concurrent-util-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{concurrent-util-4.3.x-plugin => concurrent-util-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/FailureCallbackInstrumentation.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{concurrent-util-4.3.x-plugin => concurrent-util-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/ListenableFutureCallbackInstrumentation.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{concurrent-util-4.3.x-plugin => concurrent-util-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/SuccessCallbackInstrumentation.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{concurrent-util-4.3.x-plugin => concurrent-util-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/EitherInterfaceMatch.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{concurrent-util-4.3.x-plugin => concurrent-util-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/FailedCallbackMatch.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{concurrent-util-4.3.x-plugin => concurrent-util-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/ListenableFutureCallbackMatch.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{concurrent-util-4.3.x-plugin => concurrent-util-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/SuccessCallbackMatch.java (100%) create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/resources/skywalking-plugin.def delete mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/resources/skywalking-plugin.def rename apm-sniffer/apm-sdk-plugin/spring-plugins/{resttemplate-4.3.x-plugin => resttemplate-4.x-plugin}/pom.xml (94%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{resttemplate-4.3.x-plugin => resttemplate-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java (90%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{resttemplate-4.3.x-plugin => resttemplate-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/ResponseCallBackInterceptor.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{resttemplate-4.3.x-plugin => resttemplate-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java (93%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{resttemplate-4.3.x-plugin => resttemplate-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/ResponseExtractorFutureInstrumentation.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{resttemplate-4.3.x-plugin => resttemplate-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/RestTemplateInstrumentation.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{resttemplate-4.3.x-plugin => resttemplate-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{resttemplate-4.3.x-plugin => resttemplate-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestRequestInterceptor.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{resttemplate-4.3.x-plugin => resttemplate-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestResponseInterceptor.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{resttemplate-4.3.x-plugin => resttemplate-4.x-plugin}/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/define/RestTemplateInstrumentation.java (100%) rename apm-sniffer/apm-sdk-plugin/spring-plugins/{resttemplate-4.3.x-plugin => resttemplate-4.x-plugin}/src/main/java/org/springframework/http/client/RestRequestInterceptor.java (85%) create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/resources/skywalking-plugin.def diff --git a/apm-sniffer/apm-agent/pom.xml b/apm-sniffer/apm-agent/pom.xml index 11c5388f8..8645e42dc 100644 --- a/apm-sniffer/apm-agent/pom.xml +++ b/apm-sniffer/apm-agent/pom.xml @@ -82,12 +82,12 @@ org.skywalking - apm-resttemplate-plugin + apm-resttemplate-4.3.x-plugin ${project.version} org.skywalking - apm-spring-concurrent-util-plugin + apm-spring-concurrent-util-4.x-plugin ${project.version} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/resources/skywalking-plugin.def b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/resources/skywalking-plugin.def deleted file mode 100644 index 8c9426546..000000000 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/resources/skywalking-plugin.def +++ /dev/null @@ -1,3 +0,0 @@ -spring-concurrent-util-4.3.8=org.skywalking.apm.plugin.spring.concurrent.define.FailureCallbackInstrumentation -spring-concurrent-util-4.3.8=org.skywalking.apm.plugin.spring.concurrent.define.SuccessCallbackInstrumentation -spring-concurrent-util-4.3.8=org.skywalking.apm.plugin.spring.concurrent.define.ListenableFutureCallbackInstrumentation diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/pom.xml b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/pom.xml similarity index 81% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/pom.xml rename to apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/pom.xml index cc6855d02..d399599fb 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/pom.xml +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/pom.xml @@ -7,17 +7,17 @@ 4.0.0 - apm-spring-concurrent-util-4.3.x-plugin + apm-spring-concurrent-util-4.x-plugin jar - concurrent-util-4.3.x-plugin + concurrent-util-4.x-plugin http://maven.apache.org org.springframework spring-core - 4.3.8.RELEASE + 4.3.10.RELEASE provided diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/FailureCallbackInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/FailureCallbackInstrumentation.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/FailureCallbackInstrumentation.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/FailureCallbackInstrumentation.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/ListenableFutureCallbackInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/ListenableFutureCallbackInstrumentation.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/ListenableFutureCallbackInstrumentation.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/ListenableFutureCallbackInstrumentation.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/SuccessCallbackInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/SuccessCallbackInstrumentation.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/SuccessCallbackInstrumentation.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/define/SuccessCallbackInstrumentation.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/EitherInterfaceMatch.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/EitherInterfaceMatch.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/EitherInterfaceMatch.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/EitherInterfaceMatch.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/FailedCallbackMatch.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/FailedCallbackMatch.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/FailedCallbackMatch.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/FailedCallbackMatch.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/ListenableFutureCallbackMatch.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/ListenableFutureCallbackMatch.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/ListenableFutureCallbackMatch.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/ListenableFutureCallbackMatch.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/SuccessCallbackMatch.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/SuccessCallbackMatch.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/SuccessCallbackMatch.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/match/SuccessCallbackMatch.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/resources/skywalking-plugin.def b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/resources/skywalking-plugin.def new file mode 100644 index 000000000..795a7685c --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/resources/skywalking-plugin.def @@ -0,0 +1,3 @@ +spring-concurrent-util-4.x=org.skywalking.apm.plugin.spring.concurrent.define.FailureCallbackInstrumentation +spring-concurrent-util-4.x=org.skywalking.apm.plugin.spring.concurrent.define.SuccessCallbackInstrumentation +spring-concurrent-util-4.x=org.skywalking.apm.plugin.spring.concurrent.define.ListenableFutureCallbackInstrumentation diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml b/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml index 4417a3e14..1b22d7b9d 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml @@ -11,10 +11,8 @@ spring-plugins - - concurrent-util-4.3.x-plugin - resttemplate-4.3.x-plugin + concurrent-util-4.x-plugin + resttemplate-4.x-plugin pom diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/resources/skywalking-plugin.def b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/resources/skywalking-plugin.def deleted file mode 100644 index 4b5ab45bc..000000000 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/resources/skywalking-plugin.def +++ /dev/null @@ -1,3 +0,0 @@ -spring-resttemplate-4.3.8=org.skywalking.apm.plugin.spring.resttemplate.async.define.RestTemplateInstrumentation -spring-resttemplate-4.3.8=org.skywalking.apm.plugin.spring.resttemplate.async.define.ResponseExtractorFutureInstrumentation -spring-resttemplate-4.3.8=org.skywalking.apm.plugin.spring.resttemplate.sync.define.RestTemplateInstrumentation diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/pom.xml b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/pom.xml similarity index 94% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/pom.xml rename to apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/pom.xml index f0700056a..874a25df4 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/pom.xml +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/pom.xml @@ -17,7 +17,7 @@ org.springframework spring-web - 4.3.8.RELEASE + 4.3.10.RELEASE provided diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java similarity index 90% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java index d32fab57b..218113022 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/FutureGetInterceptor.java @@ -2,7 +2,6 @@ package org.skywalking.apm.plugin.spring.resttemplate.async; import java.lang.reflect.Method; import java.net.URI; -import java.util.List; import org.skywalking.apm.agent.core.context.ContextManager; import org.skywalking.apm.agent.core.context.trace.AbstractSpan; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; @@ -14,8 +13,8 @@ public class FutureGetInterceptor implements InstanceMethodsAroundInterceptor { @Override public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { - List cacheValues = (List)objInst.getSkyWalkingDynamicField(); - ContextManager.createLocalSpan("future/get:" + ((URI)cacheValues.get(0)).getPath()); + Object[] cacheValues = (Object[])objInst.getSkyWalkingDynamicField(); + ContextManager.createLocalSpan("future/get:" + ((URI)cacheValues[0]).getPath()); } @Override diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/ResponseCallBackInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/ResponseCallBackInterceptor.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/ResponseCallBackInterceptor.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/ResponseCallBackInterceptor.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java similarity index 93% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java index 9e4693997..7c6058d7e 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java @@ -38,8 +38,10 @@ public class RestExecuteInterceptor implements InstanceMethodsAroundInterceptor public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { Object[] cacheValues = (Object[])objInst.getSkyWalkingDynamicField(); - cacheValues[3] = ContextManager.capture(); - ((EnhancedInstance)ret).setSkyWalkingDynamicField(cacheValues); + cacheValues[2] = ContextManager.capture(); + if (ret != null) { + ((EnhancedInstance)ret).setSkyWalkingDynamicField(cacheValues); + } ContextManager.stopSpan(); return ret; } diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/ResponseExtractorFutureInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/ResponseExtractorFutureInstrumentation.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/ResponseExtractorFutureInstrumentation.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/ResponseExtractorFutureInstrumentation.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/RestTemplateInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/RestTemplateInstrumentation.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/RestTemplateInstrumentation.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/define/RestTemplateInstrumentation.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestRequestInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestRequestInterceptor.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestRequestInterceptor.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestRequestInterceptor.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestResponseInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestResponseInterceptor.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestResponseInterceptor.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestResponseInterceptor.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/define/RestTemplateInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/define/RestTemplateInstrumentation.java similarity index 100% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/define/RestTemplateInstrumentation.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/define/RestTemplateInstrumentation.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/springframework/http/client/RestRequestInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/springframework/http/client/RestRequestInterceptor.java similarity index 85% rename from apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/springframework/http/client/RestRequestInterceptor.java rename to apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/springframework/http/client/RestRequestInterceptor.java index 17218adfb..f8bde0b91 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.3.x-plugin/src/main/java/org/springframework/http/client/RestRequestInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/springframework/http/client/RestRequestInterceptor.java @@ -1,7 +1,6 @@ package org.springframework.http.client; import java.lang.reflect.Method; -import java.util.List; import org.skywalking.apm.agent.core.conf.Config; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; @@ -19,7 +18,9 @@ public class RestRequestInterceptor implements InstanceMethodsAroundInterceptor public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, Object ret) throws Throwable { AbstractAsyncClientHttpRequest clientHttpRequest = (AbstractAsyncClientHttpRequest)ret; - clientHttpRequest.getHeaders().set(Config.Plugin.Propagation.HEADER_NAME, String.valueOf(((List)objInst.getSkyWalkingDynamicField()).get(1))); + if (ret != null) { + clientHttpRequest.getHeaders().set(Config.Plugin.Propagation.HEADER_NAME, String.valueOf(((Object[])objInst.getSkyWalkingDynamicField())[1])); + } return ret; } diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/resources/skywalking-plugin.def b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/resources/skywalking-plugin.def new file mode 100644 index 000000000..aa695c514 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/resources/skywalking-plugin.def @@ -0,0 +1,3 @@ +spring-resttemplate-4.x=org.skywalking.apm.plugin.spring.resttemplate.async.define.RestTemplateInstrumentation +spring-resttemplate-4.x=org.skywalking.apm.plugin.spring.resttemplate.async.define.ResponseExtractorFutureInstrumentation +spring-resttemplate-4.x=org.skywalking.apm.plugin.spring.resttemplate.sync.define.RestTemplateInstrumentation From fe383773e93b149abf5f32034a59adf520138a91 Mon Sep 17 00:00:00 2001 From: ascrutae Date: Fri, 11 Aug 2017 18:07:30 +0800 Subject: [PATCH 08/12] support spring mvc annotation plugin --- .../trace/component/ComponentsDefine.java | 9 ++- .../plugin/match/ClassAnnotationMatch.java | 3 +- apm-sniffer/apm-agent/pom.xml | 5 ++ .../FailureCallbackInterceptor.java | 2 +- .../SuccessCallbackInterceptor.java | 2 +- .../mvc-annotation-4.x-plugin/pom.xml | 36 +++++++++ .../mvc/ControllerConstructorInterceptor.java | 22 ++++++ .../ControllerServiceMethodInterceptor.java | 61 +++++++++++++++ .../AbstractControllerInstrumentation.java | 76 +++++++++++++++++++ .../mvc/define/ControllerInstrumentation.java | 10 +++ .../define/RestControllerInstrumentation.java | 10 +++ .../src/main/resources/skywalking-plugin.def | 2 + .../apm-sdk-plugin/spring-plugins/pom.xml | 1 + .../async/RestExecuteInterceptor.java | 2 +- .../sync/RestExecuteInterceptor.java | 2 +- 15 files changed, 235 insertions(+), 8 deletions(-) create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/pom.xml create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerConstructorInterceptor.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerServiceMethodInterceptor.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/define/AbstractControllerInstrumentation.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/define/ControllerInstrumentation.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/define/RestControllerInstrumentation.java create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/resources/skywalking-plugin.def diff --git a/apm-network/src/main/java/org/skywalking/apm/network/trace/component/ComponentsDefine.java b/apm-network/src/main/java/org/skywalking/apm/network/trace/component/ComponentsDefine.java index d70e56787..86a684b59 100644 --- a/apm-network/src/main/java/org/skywalking/apm/network/trace/component/ComponentsDefine.java +++ b/apm-network/src/main/java/org/skywalking/apm/network/trace/component/ComponentsDefine.java @@ -31,7 +31,9 @@ public class ComponentsDefine { public static final OfficialComponent OKHTTP = new OfficialComponent(12, "OKHttp"); - public static final OfficialComponent REST_TEMPLATE = new OfficialComponent(13, "RestTemplate"); + public static final OfficialComponent SPRING_REST_TEMPLATE = new OfficialComponent(13, "SpringRestTemplate"); + + public static final OfficialComponent SPRING_MVC_ANNOTATION = new OfficialComponent(14, "SpringMVCAnnotation"); private static ComponentsDefine instance = new ComponentsDefine(); @@ -42,7 +44,7 @@ public class ComponentsDefine { } public ComponentsDefine() { - components = new String[14]; + components = new String[15]; addComponent(TOMCAT); addComponent(HTTPCLIENT); addComponent(DUBBO); @@ -55,7 +57,8 @@ public class ComponentsDefine { addComponent(RESIN); addComponent(FEIGN); addComponent(OKHTTP); - addComponent(REST_TEMPLATE); + addComponent(SPRING_REST_TEMPLATE); + addComponent(SPRING_MVC_ANNOTATION); } private void addComponent(OfficialComponent component) { diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/match/ClassAnnotationMatch.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/match/ClassAnnotationMatch.java index 3cc7aabb0..894e37dfb 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/match/ClassAnnotationMatch.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/plugin/match/ClassAnnotationMatch.java @@ -1,5 +1,6 @@ package org.skywalking.apm.agent.core.plugin.match; +import java.util.ArrayList; import java.util.Arrays; import java.util.List; import net.bytebuddy.description.annotation.AnnotationDescription; @@ -43,7 +44,7 @@ public class ClassAnnotationMatch implements IndirectMatch { @Override public boolean isMatch(TypeDescription typeDescription) { - List annotationList = Arrays.asList(annotations); + List annotationList = new ArrayList(Arrays.asList(annotations)); AnnotationList declaredAnnotations = typeDescription.getDeclaredAnnotations(); for (AnnotationDescription annotation : declaredAnnotations) { annotationList.remove(annotation.getAnnotationType().getActualName()); diff --git a/apm-sniffer/apm-agent/pom.xml b/apm-sniffer/apm-agent/pom.xml index 8645e42dc..bda4d7137 100644 --- a/apm-sniffer/apm-agent/pom.xml +++ b/apm-sniffer/apm-agent/pom.xml @@ -90,6 +90,11 @@ apm-spring-concurrent-util-4.x-plugin ${project.version} + + org.skywalking + apm-springmvc-annotation-4.x-plugin + ${project.version} + diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java index ed8a2205d..6166756be 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/FailureCallbackInterceptor.java @@ -24,7 +24,7 @@ public class FailureCallbackInterceptor implements InstanceMethodsAroundIntercep URI uri = (URI)cacheValues[0]; AbstractSpan span = ContextManager.createLocalSpan("future/failureCallback:" + uri.getPath()); - span.errorOccurred().log((Throwable)allArguments[0]).setComponent(ComponentsDefine.REST_TEMPLATE).setLayer(SpanLayer.HTTP); + span.errorOccurred().log((Throwable)allArguments[0]).setComponent(ComponentsDefine.SPRING_REST_TEMPLATE).setLayer(SpanLayer.HTTP); Tags.URL.set(span, uri.getPath()); ContextManager.continued((ContextSnapshot)cacheValues[2]); } diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java index 951a40582..a2cdb5a11 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/concurrent-util-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/concurrent/SuccessCallbackInterceptor.java @@ -24,7 +24,7 @@ public class SuccessCallbackInterceptor implements InstanceMethodsAroundIntercep URI uri = (URI)cacheValues[0]; AbstractSpan span = ContextManager.createLocalSpan("future/successCallback:" + uri.getPath()); - span.setComponent(ComponentsDefine.REST_TEMPLATE).setLayer(SpanLayer.HTTP); + span.setComponent(ComponentsDefine.SPRING_REST_TEMPLATE).setLayer(SpanLayer.HTTP); Tags.URL.set(span, uri.getPath()); ContextManager.continued((ContextSnapshot)cacheValues[2]); } diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/pom.xml b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/pom.xml new file mode 100644 index 000000000..bb88c3441 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/pom.xml @@ -0,0 +1,36 @@ + + + spring-plugins + org.skywalking + 3.2-2017 + + 4.0.0 + + apm-springmvc-annotation-4.x-plugin + jar + + mvc-annotation-4.x-plugin + http://maven.apache.org + + + + org.springframework + spring-core + 4.3.10.RELEASE + provided + + + org.springframework + spring-webmvc + 4.3.8.RELEASE + provided + + + javax.servlet + javax.servlet-api + 4.0.0-b01 + provided + + + diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerConstructorInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerConstructorInterceptor.java new file mode 100644 index 000000000..8900112d5 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerConstructorInterceptor.java @@ -0,0 +1,22 @@ +package org.skywalking.apm.plugin.spring.mvc; + +import java.util.HashMap; +import java.util.Map; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceConstructorInterceptor; +import org.springframework.web.bind.annotation.RequestMapping; + +public class ControllerConstructorInterceptor implements InstanceConstructorInterceptor { + + @Override + public void onConstruct(EnhancedInstance objInst, Object[] allArguments) { + String basePath = ""; + RequestMapping basePathRequestMapping = objInst.getClass().getAnnotation(RequestMapping.class); + if (basePathRequestMapping != null) { + basePath = basePathRequestMapping.value()[0]; + } + Map cacheRequestPath = new HashMap(); + cacheRequestPath.put("BASE_PATH", basePath); + objInst.setSkyWalkingDynamicField(cacheRequestPath); + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerServiceMethodInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerServiceMethodInterceptor.java new file mode 100644 index 000000000..91731648a --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerServiceMethodInterceptor.java @@ -0,0 +1,61 @@ +package org.skywalking.apm.plugin.spring.mvc; + +import java.lang.reflect.Method; +import java.util.Map; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import org.skywalking.apm.agent.core.conf.Config; +import org.skywalking.apm.agent.core.context.ContextCarrier; +import org.skywalking.apm.agent.core.context.ContextManager; +import org.skywalking.apm.agent.core.context.tag.Tags; +import org.skywalking.apm.agent.core.context.trace.AbstractSpan; +import org.skywalking.apm.agent.core.context.trace.SpanLayer; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; +import org.skywalking.apm.network.trace.component.ComponentsDefine; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.context.request.RequestContextHolder; +import org.springframework.web.context.request.ServletRequestAttributes; + +public class ControllerServiceMethodInterceptor implements InstanceMethodsAroundInterceptor { + @Override + public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + MethodInterceptResult result) throws Throwable { + Map cacheRequestURL = (Map)objInst.getSkyWalkingDynamicField(); + String requestURL = cacheRequestURL.get(method); + if (requestURL == null) { + requestURL = new String(cacheRequestURL.get("BASE_PATH")); + requestURL += method.getAnnotation(RequestMapping.class).value()[0]; + cacheRequestURL.put(method, requestURL.toString()); + } + + HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest(); + String tracingHeaderValue = request.getHeader(Config.Plugin.Propagation.HEADER_NAME); + ContextCarrier contextCarrier = new ContextCarrier().deserialize(tracingHeaderValue); + AbstractSpan span = ContextManager.createEntrySpan(requestURL, contextCarrier); + Tags.URL.set(span, request.getRequestURL().toString()); + Tags.HTTP.METHOD.set(span, request.getMethod()); + span.setComponent(ComponentsDefine.SPRING_MVC_ANNOTATION); + SpanLayer.asHttp(span); + } + + @Override + public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, + Object ret) throws Throwable { + HttpServletResponse response = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getResponse(); + + AbstractSpan span = ContextManager.activeSpan(); + if (response.getStatus() >= 400) { + span.errorOccurred(); + Tags.STATUS_CODE.set(span, Integer.toString(response.getStatus())); + } + ContextManager.stopSpan(); + return ret; + } + + @Override public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, + Class[] argumentsTypes, Throwable t) { + ContextManager.activeSpan().errorOccurred().log(t); + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/define/AbstractControllerInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/define/AbstractControllerInstrumentation.java new file mode 100644 index 000000000..96f7715d7 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/define/AbstractControllerInstrumentation.java @@ -0,0 +1,76 @@ +package org.skywalking.apm.plugin.spring.mvc.define; + +import net.bytebuddy.description.method.MethodDescription; +import net.bytebuddy.matcher.ElementMatcher; +import org.skywalking.apm.agent.core.plugin.interceptor.ConstructorInterceptPoint; +import org.skywalking.apm.agent.core.plugin.interceptor.InstanceMethodsInterceptPoint; +import org.skywalking.apm.agent.core.plugin.interceptor.enhance.ClassInstanceMethodsEnhancePluginDefine; +import org.skywalking.apm.agent.core.plugin.match.ClassMatch; + +import static net.bytebuddy.matcher.ElementMatchers.any; +import static net.bytebuddy.matcher.ElementMatchers.isAnnotatedWith; +import static net.bytebuddy.matcher.ElementMatchers.named; +import static org.skywalking.apm.agent.core.plugin.match.ClassAnnotationMatch.byClassAnnotationMatch; + +/** + * {@link ControllerInstrumentation} enhance all constructor and method annotated with + * org.springframework.web.bind.annotation.RequestMapping that class has + * org.springframework.stereotype.Controller annotation. + * + * org.skywalking.apm.plugin.spring.mvc.ControllerConstructorInterceptor set the controller base path to + * dynamic field before execute constructor. + * + * org.skywalking.apm.plugin.spring.mvc.ControllerServiceMethodInterceptor get the request path from + * dynamic field first, if not found, ControllerServiceMethodInterceptor generate request path that + * combine the path value of current annotation on current method and the base path and set the new path to the dynamic + * filed + * + * @author zhangxin + */ +public abstract class AbstractControllerInstrumentation extends ClassInstanceMethodsEnhancePluginDefine { + @Override + protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() { + return new ConstructorInterceptPoint[] { + new ConstructorInterceptPoint() { + @Override + public ElementMatcher getConstructorMatcher() { + return any(); + } + + @Override + public String getConstructorInterceptor() { + return "org.skywalking.apm.plugin.spring.mvc.ControllerConstructorInterceptor"; + } + } + }; + } + + @Override + protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() { + return new InstanceMethodsInterceptPoint[] { + new InstanceMethodsInterceptPoint() { + @Override + public ElementMatcher getMethodsMatcher() { + return isAnnotatedWith(named("org.springframework.web.bind.annotation.RequestMapping")); + } + + @Override + public String getMethodsInterceptor() { + return "org.skywalking.apm.plugin.spring.mvc.ControllerServiceMethodInterceptor"; + } + + @Override + public boolean isOverrideArgs() { + return false; + } + } + }; + } + + @Override + protected ClassMatch enhanceClass() { + return byClassAnnotationMatch(getEnhanceAnnotations()); + } + + protected abstract String[] getEnhanceAnnotations(); +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/define/ControllerInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/define/ControllerInstrumentation.java new file mode 100644 index 000000000..abfdf8e29 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/define/ControllerInstrumentation.java @@ -0,0 +1,10 @@ +package org.skywalking.apm.plugin.spring.mvc.define; + +public class ControllerInstrumentation extends AbstractControllerInstrumentation { + + public static final String ENHANCE_ANNOTATION = "org.springframework.stereotype.Controller"; + + @Override protected String[] getEnhanceAnnotations() { + return new String[] {ENHANCE_ANNOTATION}; + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/define/RestControllerInstrumentation.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/define/RestControllerInstrumentation.java new file mode 100644 index 000000000..8ce6e59e6 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/define/RestControllerInstrumentation.java @@ -0,0 +1,10 @@ +package org.skywalking.apm.plugin.spring.mvc.define; + +public class RestControllerInstrumentation extends AbstractControllerInstrumentation { + + public static final String ENHANCE_ANNOTATION = "org.springframework.web.bind.annotation.RestController"; + + @Override protected String[] getEnhanceAnnotations() { + return new String[] {ENHANCE_ANNOTATION}; + } +} diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/resources/skywalking-plugin.def b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/resources/skywalking-plugin.def new file mode 100644 index 000000000..92d3695ba --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/resources/skywalking-plugin.def @@ -0,0 +1,2 @@ +spring-mvc-annotation-4.x=org.skywalking.apm.plugin.spring.mvc.define.ControllerInstrumentation +spring-mvc-annotation-4.x=org.skywalking.apm.plugin.spring.mvc.define.RestControllerInstrumentation \ No newline at end of file diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml b/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml index 1b22d7b9d..0a91d8890 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/pom.xml @@ -13,6 +13,7 @@ concurrent-util-4.x-plugin resttemplate-4.x-plugin + mvc-annotation-4.x-plugin pom diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java index 7c6058d7e..4ee3e2581 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/async/RestExecuteInterceptor.java @@ -24,7 +24,7 @@ public class RestExecuteInterceptor implements InstanceMethodsAroundInterceptor String remotePeer = requestURL.getHost() + ":" + requestURL.getPort(); AbstractSpan span = ContextManager.createExitSpan(requestURL.getPath(), contextCarrier, remotePeer); - span.setComponent(ComponentsDefine.REST_TEMPLATE); + span.setComponent(ComponentsDefine.SPRING_REST_TEMPLATE); Tags.URL.set(span, requestURL.getScheme() + "://" + requestURL.getHost() + ":" + requestURL.getPort() + requestURL.getPath()); Tags.HTTP.METHOD.set(span, httpMethod.toString()); SpanLayer.asHttp(span); diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java index c0567cba2..a0764191b 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/resttemplate-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/resttemplate/sync/RestExecuteInterceptor.java @@ -24,7 +24,7 @@ public class RestExecuteInterceptor implements InstanceMethodsAroundInterceptor String remotePeer = requestURL.getHost() + ":" + requestURL.getPort(); AbstractSpan span = ContextManager.createExitSpan(requestURL.getPath(), contextCarrier, remotePeer); - span.setComponent(ComponentsDefine.REST_TEMPLATE); + span.setComponent(ComponentsDefine.SPRING_REST_TEMPLATE); Tags.URL.set(span, requestURL.getScheme() + "://" + requestURL.getHost() + ":" + requestURL.getPort() + requestURL.getPath()); Tags.HTTP.METHOD.set(span, httpMethod.toString()); SpanLayer.asHttp(span); From ef8b5aaad152d35d6776e75fffa5ba950b35fc93 Mon Sep 17 00:00:00 2001 From: wusheng Date: Fri, 11 Aug 2017 19:12:28 +0800 Subject: [PATCH 09/12] Adjust the springMVC plugin. --- .../mvc/ControllerConstructorInterceptor.java | 20 +++++++++---- .../ControllerServiceMethodInterceptor.java | 15 ++++++---- .../plugin/spring/mvc/PathMappingCache.java | 28 +++++++++++++++++++ 3 files changed, 52 insertions(+), 11 deletions(-) create mode 100644 apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/PathMappingCache.java diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerConstructorInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerConstructorInterceptor.java index 8900112d5..5f3d39ed0 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerConstructorInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerConstructorInterceptor.java @@ -1,11 +1,22 @@ package org.skywalking.apm.plugin.spring.mvc; -import java.util.HashMap; -import java.util.Map; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceConstructorInterceptor; import org.springframework.web.bind.annotation.RequestMapping; +/** + * The ControllerConstructorInterceptor intercepts the Controller's constructor, in order to acquire the + * mapping annotation, if exist. + * + * But, you can see we only use the first mapping value, Why? + * + * Right now, we intercept the controller by annotation as you known, so we CAN'T know which uri patten is actually + * matched. Even we know, that costs a lot. + * + * If we want to resolve that, we must intercept the Spring MVC core codes, that is not a good choice for now. + * + * Comment by @wu-sheng + */ public class ControllerConstructorInterceptor implements InstanceConstructorInterceptor { @Override @@ -15,8 +26,7 @@ public class ControllerConstructorInterceptor implements InstanceConstructorInte if (basePathRequestMapping != null) { basePath = basePathRequestMapping.value()[0]; } - Map cacheRequestPath = new HashMap(); - cacheRequestPath.put("BASE_PATH", basePath); - objInst.setSkyWalkingDynamicField(cacheRequestPath); + PathMappingCache pathMappingCache = new PathMappingCache(basePath); + objInst.setSkyWalkingDynamicField(pathMappingCache); } } diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerServiceMethodInterceptor.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerServiceMethodInterceptor.java index 91731648a..32b4cb42d 100644 --- a/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerServiceMethodInterceptor.java +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/ControllerServiceMethodInterceptor.java @@ -1,7 +1,6 @@ package org.skywalking.apm.plugin.spring.mvc; import java.lang.reflect.Method; -import java.util.Map; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.skywalking.apm.agent.core.conf.Config; @@ -18,16 +17,20 @@ import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.context.request.RequestContextHolder; import org.springframework.web.context.request.ServletRequestAttributes; +/** + * The ControllerServiceMethodInterceptor only use the first mapping value. + * + * @See {@link ControllerConstructorInterceptor} to explain why we are doing this. + */ public class ControllerServiceMethodInterceptor implements InstanceMethodsAroundInterceptor { @Override public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class[] argumentsTypes, MethodInterceptResult result) throws Throwable { - Map cacheRequestURL = (Map)objInst.getSkyWalkingDynamicField(); - String requestURL = cacheRequestURL.get(method); + PathMappingCache pathMappingCache = (PathMappingCache)objInst.getSkyWalkingDynamicField(); + String requestURL = pathMappingCache.findPathMapping(method); if (requestURL == null) { - requestURL = new String(cacheRequestURL.get("BASE_PATH")); - requestURL += method.getAnnotation(RequestMapping.class).value()[0]; - cacheRequestURL.put(method, requestURL.toString()); + requestURL = method.getAnnotation(RequestMapping.class).value()[0]; + pathMappingCache.addPathMapping(method, requestURL.toString()); } HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest(); diff --git a/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/PathMappingCache.java b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/PathMappingCache.java new file mode 100644 index 000000000..591891433 --- /dev/null +++ b/apm-sniffer/apm-sdk-plugin/spring-plugins/mvc-annotation-4.x-plugin/src/main/java/org/skywalking/apm/plugin/spring/mvc/PathMappingCache.java @@ -0,0 +1,28 @@ +package org.skywalking.apm.plugin.spring.mvc; + +import java.lang.reflect.Method; +import java.util.concurrent.ConcurrentHashMap; + +/** + * The PathMappingCache represents a field + * + * + * @author wusheng + */ +public class PathMappingCache { + private String classPath = ""; + + private ConcurrentHashMap methodPathMapping = new ConcurrentHashMap(); + + public PathMappingCache(String classPath) { + this.classPath = classPath; + } + + public String findPathMapping(Method method) { + return methodPathMapping.get(method); + } + + public void addPathMapping(Method method, String methodPath) { + methodPathMapping.put(method, classPath + methodPath); + } +} From ec575ce007f8b886041e499a91abac66d13ba8e0 Mon Sep 17 00:00:00 2001 From: wusheng Date: Fri, 11 Aug 2017 21:22:25 +0800 Subject: [PATCH 10/12] Fix bugs and refactor EntrySpan and Exitspan. --- .../agent/core/context/TracingContext.java | 24 +++++++-- .../agent/core/context/trace/EntrySpan.java | 32 +----------- .../agent/core/context/trace/ExitSpan.java | 21 +++----- .../context/trace/StackBasedTracingSpan.java | 51 +++++++++++++++++++ .../util/AbstractTracingSpanHelper.java | 4 +- .../agent/core/context/util/FieldGetter.java | 5 +- .../agent/core/context/util/SpanHelper.java | 4 +- .../apm/agent/test/helper/FieldGetter.java | 8 +++ .../apm/agent/test/helper/SpanHelper.java | 49 +++++++++++++++--- 9 files changed, 135 insertions(+), 63 deletions(-) create mode 100644 apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/StackBasedTracingSpan.java diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/TracingContext.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/TracingContext.java index 10efeb9b4..9f87dbc15 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/TracingContext.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/TracingContext.java @@ -3,6 +3,7 @@ package org.skywalking.apm.agent.core.context; import java.util.LinkedList; import java.util.List; import org.skywalking.apm.agent.core.boot.ServiceManager; +import org.skywalking.apm.agent.core.conf.RemoteDownstreamConfig; import org.skywalking.apm.agent.core.context.trace.AbstractSpan; import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan; import org.skywalking.apm.agent.core.context.trace.EntrySpan; @@ -290,19 +291,19 @@ public class TracingContext implements AbstractTracerContext { .find(remotePeer).doInCondition( new PossibleFound.FoundAndObtain() { @Override - public Object doProcess(final int applicationId) { + public Object doProcess(final int peerId) { return DictionaryManager.findOperationNameCodeSection() - .findOrPrepare4Register(applicationId, operationName) + .findOnly(RemoteDownstreamConfig.Agent.APPLICATION_ID, operationName) .doInCondition( new PossibleFound.FoundAndObtain() { @Override public Object doProcess(int operationId) { - return new ExitSpan(spanIdGenerator++, parentSpanId, operationId, applicationId); + return new ExitSpan(spanIdGenerator++, parentSpanId, operationId, peerId); } }, new PossibleFound.NotFoundAndObtain() { @Override public Object doProcess() { - return new ExitSpan(spanIdGenerator++, parentSpanId, operationName, remotePeer); + return new ExitSpan(spanIdGenerator++, parentSpanId, operationName, peerId); } }); } @@ -310,7 +311,20 @@ public class TracingContext implements AbstractTracerContext { new PossibleFound.NotFoundAndObtain() { @Override public Object doProcess() { - return new ExitSpan(spanIdGenerator++, parentSpanId, operationName, remotePeer); + return DictionaryManager.findOperationNameCodeSection() + .findOnly(RemoteDownstreamConfig.Agent.APPLICATION_ID, operationName) + .doInCondition( + new PossibleFound.FoundAndObtain() { + @Override + public Object doProcess(int operationId) { + return new ExitSpan(spanIdGenerator++, parentSpanId, operationId, remotePeer); + } + }, new PossibleFound.NotFoundAndObtain() { + @Override + public Object doProcess() { + return new ExitSpan(spanIdGenerator++, parentSpanId, operationName, remotePeer); + } + }); } }); push(exitSpan); diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/EntrySpan.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/EntrySpan.java index 4b2d69cfc..13ebe887e 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/EntrySpan.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/EntrySpan.java @@ -1,8 +1,6 @@ package org.skywalking.apm.agent.core.context.trace; -import org.skywalking.apm.agent.core.dictionary.DictionaryManager; import org.skywalking.apm.agent.core.dictionary.DictionaryUtil; -import org.skywalking.apm.agent.core.dictionary.PossibleFound; import org.skywalking.apm.network.trace.component.Component; /** @@ -18,19 +16,16 @@ import org.skywalking.apm.network.trace.component.Component; * * @author wusheng */ -public class EntrySpan extends AbstractTracingSpan { - private int stackDepth; +public class EntrySpan extends StackBasedTracingSpan { private int currentMaxDepth; public EntrySpan(int spanId, int parentSpanId, String operationName) { super(spanId, parentSpanId, operationName); - this.stackDepth = 0; this.currentMaxDepth = 0; } public EntrySpan(int spanId, int parentSpanId, int operationId) { super(spanId, parentSpanId, operationId); - this.stackDepth = 0; this.currentMaxDepth = 0; } @@ -81,31 +76,6 @@ public class EntrySpan extends AbstractTracingSpan { } } - @Override - public boolean finish(TraceSegment owner) { - if (--stackDepth == 0) { - if (this.operationId == DictionaryUtil.nullValue()) { - this.operationId = (Integer)DictionaryManager.findOperationNameCodeSection() - .findOrPrepare4Register(owner.getApplicationId(), operationName) - .doInCondition( - new PossibleFound.FoundAndObtain() { - @Override public Object doProcess(int value) { - return value; - } - }, - new PossibleFound.NotFoundAndObtain() { - @Override public Object doProcess() { - return DictionaryUtil.nullValue(); - } - } - ); - } - return super.finish(owner); - } else { - return false; - } - } - @Override public AbstractTracingSpan setOperationName(String operationName) { if (stackDepth == currentMaxDepth) { diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/ExitSpan.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/ExitSpan.java index bed47ff12..de9851804 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/ExitSpan.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/ExitSpan.java @@ -17,32 +17,34 @@ import org.skywalking.apm.network.trace.component.Component; * * @author wusheng */ -public class ExitSpan extends AbstractTracingSpan { - private int stackDepth; +public class ExitSpan extends StackBasedTracingSpan { private String peer; private int peerId; public ExitSpan(int spanId, int parentSpanId, String operationName, String peer) { super(spanId, parentSpanId, operationName); - this.stackDepth = 0; this.peer = peer; this.peerId = DictionaryUtil.nullValue(); } public ExitSpan(int spanId, int parentSpanId, int operationId, int peerId) { super(spanId, parentSpanId, operationId); - this.stackDepth = 0; this.peer = null; this.peerId = peerId; } public ExitSpan(int spanId, int parentSpanId, int operationId, String peer) { super(spanId, parentSpanId, operationId); - this.stackDepth = 0; this.peer = peer; this.peerId = DictionaryUtil.nullValue(); } + public ExitSpan(int spanId, int parentSpanId, String operationName, int peerId) { + super(spanId, parentSpanId, operationName); + this.peer = null; + this.peerId = peerId; + } + /** * Set the {@link #startTime}, when the first start, which means the first service provided. */ @@ -62,15 +64,6 @@ public class ExitSpan extends AbstractTracingSpan { return this; } - @Override - public boolean finish(TraceSegment owner) { - if (--stackDepth == 0) { - return super.finish(owner); - } else { - return false; - } - } - @Override public AbstractTracingSpan setLayer(SpanLayer layer) { if (stackDepth == 1) { diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/StackBasedTracingSpan.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/StackBasedTracingSpan.java new file mode 100644 index 000000000..846e195ed --- /dev/null +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/StackBasedTracingSpan.java @@ -0,0 +1,51 @@ +package org.skywalking.apm.agent.core.context.trace; + +import org.skywalking.apm.agent.core.dictionary.DictionaryManager; +import org.skywalking.apm.agent.core.dictionary.DictionaryUtil; +import org.skywalking.apm.agent.core.dictionary.PossibleFound; + +/** + * The StackBasedTracingSpan represents a span with an inside stack construction. + * + * This kind of span can start and finish multi times in a stack-like invoke line. + * + * @author wusheng + */ +public abstract class StackBasedTracingSpan extends AbstractTracingSpan { + protected int stackDepth; + + protected StackBasedTracingSpan(int spanId, int parentSpanId, String operationName) { + super(spanId, parentSpanId, operationName); + this.stackDepth = 0; + } + + protected StackBasedTracingSpan(int spanId, int parentSpanId, int operationId) { + super(spanId, parentSpanId, operationId); + this.stackDepth = 0; + } + + @Override + public boolean finish(TraceSegment owner) { + if (--stackDepth == 0) { + if (this.operationId == DictionaryUtil.nullValue()) { + this.operationId = (Integer)DictionaryManager.findOperationNameCodeSection() + .findOrPrepare4Register(owner.getApplicationId(), operationName) + .doInCondition( + new PossibleFound.FoundAndObtain() { + @Override public Object doProcess(int value) { + return value; + } + }, + new PossibleFound.NotFoundAndObtain() { + @Override public Object doProcess() { + return DictionaryUtil.nullValue(); + } + } + ); + } + return super.finish(owner); + } else { + return false; + } + } +} diff --git a/apm-sniffer/apm-agent-core/src/test/java/org/skywalking/apm/agent/core/context/util/AbstractTracingSpanHelper.java b/apm-sniffer/apm-agent-core/src/test/java/org/skywalking/apm/agent/core/context/util/AbstractTracingSpanHelper.java index c16872e0a..44eaf57a2 100644 --- a/apm-sniffer/apm-agent-core/src/test/java/org/skywalking/apm/agent/core/context/util/AbstractTracingSpanHelper.java +++ b/apm-sniffer/apm-agent-core/src/test/java/org/skywalking/apm/agent/core/context/util/AbstractTracingSpanHelper.java @@ -8,7 +8,7 @@ import org.skywalking.apm.agent.core.context.trace.LogDataEntity; public class AbstractTracingSpanHelper { public static int getParentSpanId(AbstractTracingSpan tracingSpan) { try { - return FieldGetter.getParentFieldValue(tracingSpan, "parentSpanId"); + return FieldGetter.get2LevelParentFieldValue(tracingSpan, "parentSpanId"); } catch (Exception e) { } @@ -17,7 +17,7 @@ public class AbstractTracingSpanHelper { public static List getLogs(AbstractTracingSpan tracingSpan) { try { - return FieldGetter.getParentFieldValue(tracingSpan, "logs"); + return FieldGetter.get2LevelParentFieldValue(tracingSpan, "logs"); } catch (Exception e) { } diff --git a/apm-sniffer/apm-agent-core/src/test/java/org/skywalking/apm/agent/core/context/util/FieldGetter.java b/apm-sniffer/apm-agent-core/src/test/java/org/skywalking/apm/agent/core/context/util/FieldGetter.java index 0aeaad0b9..45c00518f 100644 --- a/apm-sniffer/apm-agent-core/src/test/java/org/skywalking/apm/agent/core/context/util/FieldGetter.java +++ b/apm-sniffer/apm-agent-core/src/test/java/org/skywalking/apm/agent/core/context/util/FieldGetter.java @@ -10,9 +10,10 @@ public class FieldGetter { return (T)field.get(instance); } - public static T getParentFieldValue(Object instance, + + public static T get2LevelParentFieldValue(Object instance, String fieldName) throws IllegalAccessException, NoSuchFieldException { - Field field = instance.getClass().getSuperclass().getDeclaredField(fieldName); + Field field = instance.getClass().getSuperclass().getSuperclass().getDeclaredField(fieldName); field.setAccessible(true); return (T)field.get(instance); } diff --git a/apm-sniffer/apm-agent-core/src/test/java/org/skywalking/apm/agent/core/context/util/SpanHelper.java b/apm-sniffer/apm-agent-core/src/test/java/org/skywalking/apm/agent/core/context/util/SpanHelper.java index 1ab112344..802b74215 100644 --- a/apm-sniffer/apm-agent-core/src/test/java/org/skywalking/apm/agent/core/context/util/SpanHelper.java +++ b/apm-sniffer/apm-agent-core/src/test/java/org/skywalking/apm/agent/core/context/util/SpanHelper.java @@ -7,7 +7,7 @@ public class SpanHelper { public static SpanLayer getLayer(AbstractSpan tracingSpan) { try { - return FieldGetter.getParentFieldValue(tracingSpan, "layer"); + return FieldGetter.get2LevelParentFieldValue(tracingSpan, "layer"); } catch (Exception e) { } @@ -16,7 +16,7 @@ public class SpanHelper { public static int getComponentId(AbstractSpan tracingSpan) { try { - return FieldGetter.getParentFieldValue(tracingSpan, "componentId"); + return FieldGetter.get2LevelParentFieldValue(tracingSpan, "componentId"); } catch (Exception e) { } diff --git a/apm-sniffer/apm-test-tools/src/main/java/org/skywalking/apm/agent/test/helper/FieldGetter.java b/apm-sniffer/apm-test-tools/src/main/java/org/skywalking/apm/agent/test/helper/FieldGetter.java index 1710b93ca..b2bb6f464 100644 --- a/apm-sniffer/apm-test-tools/src/main/java/org/skywalking/apm/agent/test/helper/FieldGetter.java +++ b/apm-sniffer/apm-test-tools/src/main/java/org/skywalking/apm/agent/test/helper/FieldGetter.java @@ -16,4 +16,12 @@ public class FieldGetter { field.setAccessible(true); return (T)field.get(instance); } + + + public static T get2LevelParentFieldValue(Object instance, + String fieldName) throws IllegalAccessException, NoSuchFieldException { + Field field = instance.getClass().getSuperclass().getSuperclass().getDeclaredField(fieldName); + field.setAccessible(true); + return (T)field.get(instance); + } } diff --git a/apm-sniffer/apm-test-tools/src/main/java/org/skywalking/apm/agent/test/helper/SpanHelper.java b/apm-sniffer/apm-test-tools/src/main/java/org/skywalking/apm/agent/test/helper/SpanHelper.java index 3620fa741..0b752e947 100644 --- a/apm-sniffer/apm-test-tools/src/main/java/org/skywalking/apm/agent/test/helper/SpanHelper.java +++ b/apm-sniffer/apm-test-tools/src/main/java/org/skywalking/apm/agent/test/helper/SpanHelper.java @@ -10,8 +10,13 @@ import org.skywalking.apm.agent.core.context.util.KeyValuePair; public class SpanHelper { public static int getParentSpanId(AbstractSpan tracingSpan) { try { - return FieldGetter.getParentFieldValue(tracingSpan, "parentSpanId"); + return FieldGetter.get2LevelParentFieldValue(tracingSpan, "parentSpanId"); } catch (Exception e) { + try { + return FieldGetter.getParentFieldValue(tracingSpan, "parentSpanId"); + } catch (Exception e1) { + + } } return -9999; @@ -19,8 +24,13 @@ public class SpanHelper { public static List getLogs(AbstractSpan tracingSpan) { try { - return FieldGetter.getParentFieldValue(tracingSpan, "logs"); + return FieldGetter.get2LevelParentFieldValue(tracingSpan, "logs"); } catch (Exception e) { + try { + return FieldGetter.getParentFieldValue(tracingSpan, "logs"); + } catch (Exception e1) { + + } } return Collections.emptyList(); @@ -28,8 +38,13 @@ public class SpanHelper { public static List getTags(AbstractSpan tracingSpan) { try { - return FieldGetter.getParentFieldValue(tracingSpan, "tags"); + return FieldGetter.get2LevelParentFieldValue(tracingSpan, "tags"); } catch (Exception e) { + try { + return FieldGetter.getParentFieldValue(tracingSpan, "tags"); + } catch (Exception e1) { + + } } return Collections.emptyList(); @@ -37,8 +52,13 @@ public class SpanHelper { public static SpanLayer getLayer(AbstractSpan tracingSpan) { try { - return FieldGetter.getParentFieldValue(tracingSpan, "layer"); + return FieldGetter.get2LevelParentFieldValue(tracingSpan, "layer"); } catch (Exception e) { + try { + return FieldGetter.getParentFieldValue(tracingSpan, "layer"); + } catch (Exception e1) { + + } } return null; @@ -46,8 +66,13 @@ public class SpanHelper { public static String getComponentName(AbstractSpan tracingSpan) { try { - return FieldGetter.getParentFieldValue(tracingSpan, "componentName"); + return FieldGetter.get2LevelParentFieldValue(tracingSpan, "componentName"); } catch (Exception e) { + try { + return FieldGetter.getParentFieldValue(tracingSpan, "componentName"); + } catch (Exception e1) { + + } } return null; @@ -55,8 +80,13 @@ public class SpanHelper { public static int getComponentId(AbstractSpan tracingSpan) { try { - return FieldGetter.getParentFieldValue(tracingSpan, "componentId"); + return FieldGetter.get2LevelParentFieldValue(tracingSpan, "componentId"); } catch (Exception e) { + try { + return FieldGetter.getParentFieldValue(tracingSpan, "componentId"); + } catch (Exception e1) { + + } } return -1; @@ -64,8 +94,13 @@ public class SpanHelper { public static boolean getErrorOccurred(AbstractSpan tracingSpan) { try { - return FieldGetter.getParentFieldValue(tracingSpan, "errorOccurred"); + return FieldGetter.get2LevelParentFieldValue(tracingSpan, "errorOccurred"); } catch (Exception e) { + try { + return FieldGetter.getParentFieldValue(tracingSpan, "errorOccurred"); + } catch (Exception e1) { + + } } return false; From a0b001db76d3ca972f7d2b4a4314490f8755de0e Mon Sep 17 00:00:00 2001 From: wusheng Date: Fri, 11 Aug 2017 21:42:05 +0800 Subject: [PATCH 11/12] no message --- .../org/skywalking/apm/agent/core/context/TracingContext.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/TracingContext.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/TracingContext.java index 9f87dbc15..61bc431f0 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/TracingContext.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/TracingContext.java @@ -293,7 +293,7 @@ public class TracingContext implements AbstractTracerContext { @Override public Object doProcess(final int peerId) { return DictionaryManager.findOperationNameCodeSection() - .findOnly(RemoteDownstreamConfig.Agent.APPLICATION_ID, operationName) + .findOnly(segment.getApplicationId(), operationName) .doInCondition( new PossibleFound.FoundAndObtain() { @Override @@ -312,7 +312,7 @@ public class TracingContext implements AbstractTracerContext { @Override public Object doProcess() { return DictionaryManager.findOperationNameCodeSection() - .findOnly(RemoteDownstreamConfig.Agent.APPLICATION_ID, operationName) + .findOnly(segment.getApplicationId(), operationName) .doInCondition( new PossibleFound.FoundAndObtain() { @Override From 604fcdeb7a199f7181c56b4d0bde8a12e6d574f3 Mon Sep 17 00:00:00 2001 From: wusheng Date: Fri, 11 Aug 2017 22:56:36 +0800 Subject: [PATCH 12/12] Fix CI fail. --- .../org/skywalking/apm/agent/core/context/TracingContext.java | 1 - 1 file changed, 1 deletion(-) diff --git a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/TracingContext.java b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/TracingContext.java index 61bc431f0..c6a8f9622 100644 --- a/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/TracingContext.java +++ b/apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/TracingContext.java @@ -3,7 +3,6 @@ package org.skywalking.apm.agent.core.context; import java.util.LinkedList; import java.util.List; import org.skywalking.apm.agent.core.boot.ServiceManager; -import org.skywalking.apm.agent.core.conf.RemoteDownstreamConfig; import org.skywalking.apm.agent.core.context.trace.AbstractSpan; import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan; import org.skywalking.apm.agent.core.context.trace.EntrySpan;