diff --git a/apm-application-toolkit/apm-toolkit-trace/src/main/java/org/apache/skywalking/apm/toolkit/trace/ActiveSpan.java b/apm-application-toolkit/apm-toolkit-trace/src/main/java/org/apache/skywalking/apm/toolkit/trace/ActiveSpan.java index 0c6e4956c..a34707fec 100644 --- a/apm-application-toolkit/apm-toolkit-trace/src/main/java/org/apache/skywalking/apm/toolkit/trace/ActiveSpan.java +++ b/apm-application-toolkit/apm-toolkit-trace/src/main/java/org/apache/skywalking/apm/toolkit/trace/ActiveSpan.java @@ -26,10 +26,24 @@ package org.apache.skywalking.apm.toolkit.trace; */ public class ActiveSpan { /** - * @param key tag key + * @param key tag key * @param value tag value */ public static void tag(String key, String value) { + } + public static void error() { + } + + public static void error(String errorMsg) { + } + + public static void error(Throwable throwable) { + } + + public static void debug(String debugMsg) { + } + + public static void info(String infoMsg) { } } diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanActivation.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanActivation.java new file mode 100644 index 000000000..79f3fba0d --- /dev/null +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanActivation.java @@ -0,0 +1,154 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + + +package org.apache.skywalking.apm.toolkit.activation.trace; + +import net.bytebuddy.description.method.MethodDescription; +import net.bytebuddy.matcher.ElementMatcher; +import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.ClassStaticMethodsEnhancePluginDefine; +import org.apache.skywalking.apm.agent.core.plugin.match.NameMatch; +import org.apache.skywalking.apm.agent.core.plugin.interceptor.ConstructorInterceptPoint; +import org.apache.skywalking.apm.agent.core.plugin.interceptor.StaticMethodsInterceptPoint; +import org.apache.skywalking.apm.agent.core.plugin.match.ClassMatch; + +import static net.bytebuddy.matcher.ElementMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.takesArguments; +import static org.apache.skywalking.apm.agent.core.plugin.bytebuddy.ArgumentTypeNameMatch.takesArgumentWithType; + +/** + * {@link TraceAnnotationActivation} enhance the tag method of ActiveSpan + * by ActiveSpanTagInterceptor. + * + * @author zhangxin + */ +public class ActiveSpanActivation extends ClassStaticMethodsEnhancePluginDefine { + + private static final String ENHANCE_CLASS = "org.apache.skywalking.apm.toolkit.trace.ActiveSpan"; + + private static final String TAG_INTERCEPTOR_CLASS = "org.apache.skywalking.apm.toolkit.activation.trace.ActiveSpanTagInterceptor"; + private static final String TAG_INTERCEPTOR_METHOD_NAME = "tag"; + + private static final String ERROR_INTERCEPTOR_METHOD_NAME = "error"; + private static final String ERROR_INTERCEPTOR_CLASS = "org.apache.skywalking.apm.toolkit.activation.trace.ActiveSpanErrorInterceptor"; + private static final String ERROR_MSG_INTERCEPTOR_CLASS = "org.apache.skywalking.apm.toolkit.activation.trace.ActiveSpanErrorMsgInterceptor"; + private static final String ERROR_THROWABLE_INTERCEPTOR_CLASS = "org.apache.skywalking.apm.toolkit.activation.trace.ActiveSpanErrorThrowableInteceptor"; + + private static final String DEBUG_INTERCEPTOR_METHOD_NAME = "debug"; + private static final String DEBUG_INTERCEPTOR_CLASS = "org.apache.skywalking.apm.toolkit.activation.trace.ActiveSpanDebugInterceptor"; + + private static final String INFO_INTERCEPTOR_METHOD_NAME = "info"; + private static final String INFO_INTERCEPTOR_CLASS = "org.apache.skywalking.apm.toolkit.activation.trace.ActiveSpanInfoInterceptor"; + + + @Override protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() { + return new ConstructorInterceptPoint[0]; + } + + @Override protected StaticMethodsInterceptPoint[] getStaticMethodsInterceptPoints() { + return new StaticMethodsInterceptPoint[] { + new StaticMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(TAG_INTERCEPTOR_METHOD_NAME); + } + + @Override public String getMethodsInterceptor() { + return TAG_INTERCEPTOR_CLASS; + } + + @Override public boolean isOverrideArgs() { + return false; + } + }, + new StaticMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(DEBUG_INTERCEPTOR_METHOD_NAME) + .and(takesArgumentWithType(0, "java.lang.String")); + } + + @Override public String getMethodsInterceptor() { + return DEBUG_INTERCEPTOR_CLASS; + } + + @Override public boolean isOverrideArgs() { + return false; + } + }, + new StaticMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(INFO_INTERCEPTOR_METHOD_NAME) + .and(takesArgumentWithType(0, "java.lang.String")); + } + + @Override public String getMethodsInterceptor() { + return INFO_INTERCEPTOR_CLASS; + } + + @Override public boolean isOverrideArgs() { + return false; + } + }, + new StaticMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(ERROR_INTERCEPTOR_METHOD_NAME) + .and(takesArgumentWithType(0, "java.lang.Throwable")); + } + + @Override public String getMethodsInterceptor() { + return ERROR_THROWABLE_INTERCEPTOR_CLASS; + } + + @Override public boolean isOverrideArgs() { + return false; + } + }, + new StaticMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(ERROR_INTERCEPTOR_METHOD_NAME) + .and(takesArgumentWithType(0, "java.lang.String")); + } + + @Override public String getMethodsInterceptor() { + return ERROR_MSG_INTERCEPTOR_CLASS; + } + + @Override public boolean isOverrideArgs() { + return false; + } + }, + new StaticMethodsInterceptPoint() { + @Override public ElementMatcher getMethodsMatcher() { + return named(ERROR_INTERCEPTOR_METHOD_NAME) + .and(takesArguments(0)); + } + + @Override public String getMethodsInterceptor() { + return ERROR_INTERCEPTOR_CLASS; + } + + @Override public boolean isOverrideArgs() { + return false; + } + } + }; + } + + @Override protected ClassMatch enhanceClass() { + return NameMatch.byName(ENHANCE_CLASS); + } +} diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanDebugInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanDebugInterceptor.java new file mode 100644 index 000000000..54b5bce33 --- /dev/null +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanDebugInterceptor.java @@ -0,0 +1,58 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package org.apache.skywalking.apm.toolkit.activation.trace; + +import org.apache.skywalking.apm.agent.core.context.ContextManager; +import org.apache.skywalking.apm.agent.core.context.trace.AbstractSpan; +import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; +import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.StaticMethodsAroundInterceptor; + +import java.lang.reflect.Method; +import java.util.HashMap; +import java.util.Map; + +/** + * @author caoyixiong + */ +public class ActiveSpanDebugInterceptor implements StaticMethodsAroundInterceptor { + @Override public void beforeMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + MethodInterceptResult result) { + AbstractSpan activeSpan = null; + try { + activeSpan = ContextManager.activeSpan(); + Map event = new HashMap(); + event.put("event", "debug"); + event.put("message", String.valueOf(allArguments[0])); + activeSpan.log(System.currentTimeMillis(), event); + + } catch (NullPointerException e) { + } + } + + @Override public Object afterMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + Object ret) { + return ret; + } + + @Override + public void handleMethodException(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + Throwable t) { + + } +} diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanErrorInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanErrorInterceptor.java new file mode 100644 index 000000000..9dd0363c1 --- /dev/null +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanErrorInterceptor.java @@ -0,0 +1,53 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + + +package org.apache.skywalking.apm.toolkit.activation.trace; + +import org.apache.skywalking.apm.agent.core.context.ContextManager; +import org.apache.skywalking.apm.agent.core.context.trace.AbstractSpan; +import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; +import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.StaticMethodsAroundInterceptor; + +import java.lang.reflect.Method; + +/** + * @author caoyixiong + */ +public class ActiveSpanErrorInterceptor implements StaticMethodsAroundInterceptor { + @Override public void beforeMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + MethodInterceptResult result) { + AbstractSpan activeSpan = null; + try { + activeSpan = ContextManager.activeSpan(); + activeSpan.errorOccurred(); + } catch (NullPointerException e) { + } + } + + @Override public Object afterMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + Object ret) { + return ret; + } + + @Override + public void handleMethodException(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + Throwable t) { + + } +} \ No newline at end of file diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanErrorMsgInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanErrorMsgInterceptor.java new file mode 100644 index 000000000..647b2f974 --- /dev/null +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanErrorMsgInterceptor.java @@ -0,0 +1,59 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package org.apache.skywalking.apm.toolkit.activation.trace; + +import org.apache.skywalking.apm.agent.core.context.ContextManager; +import org.apache.skywalking.apm.agent.core.context.trace.AbstractSpan; +import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; +import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.StaticMethodsAroundInterceptor; + +import java.lang.reflect.Method; +import java.util.HashMap; +import java.util.Map; + +/** + * @author caoyixiong + */ +public class ActiveSpanErrorMsgInterceptor implements StaticMethodsAroundInterceptor { + @Override public void beforeMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + MethodInterceptResult result) { + AbstractSpan activeSpan = null; + try { + activeSpan = ContextManager.activeSpan(); + activeSpan.errorOccurred(); + Map event = new HashMap(); + event.put("event", "error"); + event.put("message", String.valueOf(allArguments[0])); + activeSpan.log(System.currentTimeMillis(), event); + + } catch (NullPointerException e) { + } + } + + @Override public Object afterMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + Object ret) { + return ret; + } + + @Override + public void handleMethodException(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + Throwable t) { + + } +} \ No newline at end of file diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanErrorThrowableInteceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanErrorThrowableInteceptor.java new file mode 100644 index 000000000..e22f18b82 --- /dev/null +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanErrorThrowableInteceptor.java @@ -0,0 +1,53 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package org.apache.skywalking.apm.toolkit.activation.trace; + +import org.apache.skywalking.apm.agent.core.context.ContextManager; +import org.apache.skywalking.apm.agent.core.context.trace.AbstractSpan; +import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; +import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.StaticMethodsAroundInterceptor; + +import java.lang.reflect.Method; + +/** + * @author caoyixiong + */ +public class ActiveSpanErrorThrowableInteceptor implements StaticMethodsAroundInterceptor { + @Override public void beforeMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + MethodInterceptResult result) { + AbstractSpan activeSpan = null; + try { + activeSpan = ContextManager.activeSpan(); + activeSpan.errorOccurred(); + activeSpan.log((Throwable) allArguments[0]); + } catch (NullPointerException e) { + } + } + + @Override public Object afterMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + Object ret) { + return ret; + } + + @Override + public void handleMethodException(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + Throwable t) { + + } +} diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanInfoInterceptor.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanInfoInterceptor.java new file mode 100644 index 000000000..ddcb27ecd --- /dev/null +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanInfoInterceptor.java @@ -0,0 +1,58 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package org.apache.skywalking.apm.toolkit.activation.trace; + +import org.apache.skywalking.apm.agent.core.context.ContextManager; +import org.apache.skywalking.apm.agent.core.context.trace.AbstractSpan; +import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult; +import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.StaticMethodsAroundInterceptor; + +import java.lang.reflect.Method; +import java.util.HashMap; +import java.util.Map; + +/** + * @author caoyixiong + */ +public class ActiveSpanInfoInterceptor implements StaticMethodsAroundInterceptor { + @Override public void beforeMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + MethodInterceptResult result) { + AbstractSpan activeSpan = null; + try { + activeSpan = ContextManager.activeSpan(); + Map event = new HashMap(); + event.put("event", "info"); + event.put("message", String.valueOf(allArguments[0])); + activeSpan.log(System.currentTimeMillis(), event); + + } catch (NullPointerException e) { + } + } + + @Override public Object afterMethod(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + Object ret) { + return ret; + } + + @Override + public void handleMethodException(Class clazz, Method method, Object[] allArguments, Class[] parameterTypes, + Throwable t) { + + } +} diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanTagActivation.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanTagActivation.java deleted file mode 100644 index c71c435ba..000000000 --- a/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanTagActivation.java +++ /dev/null @@ -1,69 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - - -package org.apache.skywalking.apm.toolkit.activation.trace; - -import net.bytebuddy.description.method.MethodDescription; -import net.bytebuddy.matcher.ElementMatcher; -import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.ClassStaticMethodsEnhancePluginDefine; -import org.apache.skywalking.apm.agent.core.plugin.match.NameMatch; -import org.apache.skywalking.apm.agent.core.plugin.interceptor.ConstructorInterceptPoint; -import org.apache.skywalking.apm.agent.core.plugin.interceptor.StaticMethodsInterceptPoint; -import org.apache.skywalking.apm.agent.core.plugin.match.ClassMatch; - -import static net.bytebuddy.matcher.ElementMatchers.named; - -/** - * {@link TraceAnnotationActivation} enhance the tag method of ActiveSpan - * by ActiveSpanTagInterceptor. - * - * @author zhangxin - */ -public class ActiveSpanTagActivation extends ClassStaticMethodsEnhancePluginDefine { - - public static final String ENHANCE_CLASS = "org.apache.skywalking.apm.toolkit.trace.ActiveSpan"; - public static final String INTERCEPTOR_CLASS = "org.apache.skywalking.apm.toolkit.activation.trace.ActiveSpanTagInterceptor"; - public static final String INTERCEPTOR_METHOD_NAME = "tag"; - - @Override protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() { - return new ConstructorInterceptPoint[0]; - } - - @Override protected StaticMethodsInterceptPoint[] getStaticMethodsInterceptPoints() { - return new StaticMethodsInterceptPoint[] { - new StaticMethodsInterceptPoint() { - @Override public ElementMatcher getMethodsMatcher() { - return named(INTERCEPTOR_METHOD_NAME); - } - - @Override public String getMethodsInterceptor() { - return INTERCEPTOR_CLASS; - } - - @Override public boolean isOverrideArgs() { - return false; - } - } - }; - } - - @Override protected ClassMatch enhanceClass() { - return NameMatch.byName(ENHANCE_CLASS); - } -} diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/resources/skywalking-plugin.def b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/resources/skywalking-plugin.def index 2d540d5b8..a0e2fc8ed 100644 --- a/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/resources/skywalking-plugin.def +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/resources/skywalking-plugin.def @@ -14,7 +14,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -toolkit-trace=org.apache.skywalking.apm.toolkit.activation.trace.ActiveSpanTagActivation +toolkit-trace=org.apache.skywalking.apm.toolkit.activation.trace.ActiveSpanActivation toolkit-trace=org.apache.skywalking.apm.toolkit.activation.trace.TraceAnnotationActivation toolkit-trace=org.apache.skywalking.apm.toolkit.activation.trace.TraceContextActivation toolkit-trace=org.apache.skywalking.apm.toolkit.activation.trace.CallableOrRunnableActivation diff --git a/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/test/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanTest.java b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/test/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanTest.java new file mode 100644 index 000000000..de53303c6 --- /dev/null +++ b/apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/test/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanTest.java @@ -0,0 +1,187 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +package org.apache.skywalking.apm.toolkit.activation.trace; + +import org.apache.skywalking.apm.agent.core.context.trace.AbstractTracingSpan; +import org.apache.skywalking.apm.agent.core.context.trace.TraceSegment; +import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance; +import org.apache.skywalking.apm.agent.test.helper.SegmentHelper; +import org.apache.skywalking.apm.agent.test.tools.*; +import org.apache.skywalking.apm.toolkit.trace.ActiveSpan; +import org.apache.skywalking.apm.toolkit.trace.Trace; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.powermock.modules.junit4.PowerMockRunner; +import org.powermock.modules.junit4.PowerMockRunnerDelegate; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.List; + +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * @author caoyixiong + */ +@RunWith(PowerMockRunner.class) +@PowerMockRunnerDelegate(TracingSegmentRunner.class) +public class ActiveSpanTest { + + private TraceAnnotationMethodInterceptor methodInterceptor; + private ActiveSpanErrorInterceptor activeSpanErrorInterceptor; + private ActiveSpanErrorMsgInterceptor activeSpanErrorMsgInterceptor; + private ActiveSpanErrorThrowableInteceptor activeSpanErrorThrowableInteceptor; + private ActiveSpanInfoInterceptor activeSpanInfoInterceptor; + + + @Mock + private EnhancedInstance enhancedInstance; + @Rule + public AgentServiceRule serviceRule = new AgentServiceRule(); + @SegmentStoragePoint + private SegmentStorage storage; + + private Object[] tagParametersMsg; + private Class[] tagParameterTypesMsg; + + private Object[] tagParametersThrowable; + private Class[] tagParameterTypesThrowable; + + @Before + public void setUp() throws Exception { + methodInterceptor = new TraceAnnotationMethodInterceptor(); + activeSpanErrorInterceptor = new ActiveSpanErrorInterceptor(); + activeSpanErrorMsgInterceptor = new ActiveSpanErrorMsgInterceptor(); + activeSpanErrorThrowableInteceptor = new ActiveSpanErrorThrowableInteceptor(); + activeSpanInfoInterceptor = new ActiveSpanInfoInterceptor(); + + tagParametersMsg = new Object[]{"testMsgValue"}; + tagParameterTypesMsg = new Class[]{String.class}; + + tagParametersThrowable = new Object[]{new RuntimeException("test-Throwable")}; + tagParameterTypesThrowable = new Class[]{Throwable.class}; + } + + @Test + public void testActiveSpanError() throws Throwable { + Method withOperationNameMethod = MockActiveSpan.class.getDeclaredMethod("testErrorMethod"); + methodInterceptor.beforeMethod(enhancedInstance, withOperationNameMethod, null, null, null); + activeSpanErrorMsgInterceptor.beforeMethod(MockActiveSpan.class, withOperationNameMethod, tagParametersMsg, tagParameterTypesMsg, null); + activeSpanErrorMsgInterceptor.afterMethod(MockActiveSpan.class, withOperationNameMethod, tagParametersMsg, tagParameterTypesMsg, null); + methodInterceptor.afterMethod(enhancedInstance, withOperationNameMethod, null, null, null); + + assertThat(storage.getTraceSegments().size(), is(1)); + TraceSegment traceSegment = storage.getTraceSegments().get(0); + List spans = SegmentHelper.getSpans(traceSegment); + assertThat(spans.size(), is(1)); + + AbstractTracingSpan tracingSpan = spans.get(0); + Field field = AbstractTracingSpan.class.getDeclaredField("errorOccurred"); + field.setAccessible(true); + assertTrue(field.getBoolean(tracingSpan)); + SpanAssert.assertLogSize(tracingSpan, 1); + SpanAssert.assertTagSize(tracingSpan, 0); + } + + @Test + public void testActiveSpanErrorNoMsg() throws Throwable { + Method withOperationNameMethod = MockActiveSpan.class.getDeclaredMethod("testErrorNoMsgMethod"); + methodInterceptor.beforeMethod(enhancedInstance, withOperationNameMethod, null, null, null); + activeSpanErrorInterceptor.beforeMethod(MockActiveSpan.class, withOperationNameMethod, null, null, null); + activeSpanErrorInterceptor.afterMethod(MockActiveSpan.class, withOperationNameMethod, null, null, null); + methodInterceptor.afterMethod(enhancedInstance, withOperationNameMethod, null, null, null); + + assertThat(storage.getTraceSegments().size(), is(1)); + TraceSegment traceSegment = storage.getTraceSegments().get(0); + List spans = SegmentHelper.getSpans(traceSegment); + assertThat(spans.size(), is(1)); + + AbstractTracingSpan tracingSpan = spans.get(0); + Field field = AbstractTracingSpan.class.getDeclaredField("errorOccurred"); + field.setAccessible(true); + assertTrue(field.getBoolean(tracingSpan)); + SpanAssert.assertLogSize(tracingSpan, 0); + SpanAssert.assertTagSize(tracingSpan, 0); + } + + @Test + public void testActiveSpanErrorThrowable() throws Throwable { + Method withOperationNameMethod = MockActiveSpan.class.getDeclaredMethod("testErrorThrowableMethod"); + methodInterceptor.beforeMethod(enhancedInstance, withOperationNameMethod, null, null, null); + activeSpanErrorThrowableInteceptor.beforeMethod(MockActiveSpan.class, withOperationNameMethod, tagParametersThrowable, tagParameterTypesThrowable, null); + activeSpanErrorThrowableInteceptor.afterMethod(MockActiveSpan.class, withOperationNameMethod, tagParametersThrowable, tagParameterTypesThrowable, null); + methodInterceptor.afterMethod(enhancedInstance, withOperationNameMethod, null, null, null); + + assertThat(storage.getTraceSegments().size(), is(1)); + TraceSegment traceSegment = storage.getTraceSegments().get(0); + List spans = SegmentHelper.getSpans(traceSegment); + assertThat(spans.size(), is(1)); + AbstractTracingSpan tracingSpan = spans.get(0); + Field field = AbstractTracingSpan.class.getDeclaredField("errorOccurred"); + field.setAccessible(true); + assertTrue(field.getBoolean(tracingSpan)); + SpanAssert.assertLogSize(tracingSpan, 1); + SpanAssert.assertTagSize(tracingSpan, 0); + } + + @Test + public void testActiveSpanInfo() throws Throwable { + Method withOperationNameMethod = MockActiveSpan.class.getDeclaredMethod("testInfoMethod"); + methodInterceptor.beforeMethod(enhancedInstance, withOperationNameMethod, null, null, null); + activeSpanInfoInterceptor.beforeMethod(MockActiveSpan.class, withOperationNameMethod, tagParametersThrowable, tagParameterTypesThrowable, null); + activeSpanInfoInterceptor.afterMethod(MockActiveSpan.class, withOperationNameMethod, tagParametersThrowable, tagParameterTypesThrowable, null); + methodInterceptor.afterMethod(enhancedInstance, withOperationNameMethod, null, null, null); + + assertThat(storage.getTraceSegments().size(), is(1)); + TraceSegment traceSegment = storage.getTraceSegments().get(0); + List spans = SegmentHelper.getSpans(traceSegment); + assertThat(spans.size(), is(1)); + + AbstractTracingSpan tracingSpan = spans.get(0); + SpanAssert.assertLogSize(tracingSpan, 1); + SpanAssert.assertTagSize(tracingSpan, 0); + } + + private class MockActiveSpan { + @Trace + public void testErrorMethod() { + ActiveSpan.error("testValue"); + } + + @Trace + public void testInfoMethod() { + ActiveSpan.info("testValue"); + } + + @Trace + public void testErrorNoMsgMethod() { + ActiveSpan.error(); + } + + @Trace + public void testErrorThrowableMethod() { + ActiveSpan.error(new RuntimeException("test-Throwable")); + } + } +} diff --git a/docs/en/setup/service-agent/java-agent/Application-toolkit-trace.md b/docs/en/setup/service-agent/java-agent/Application-toolkit-trace.md index bbd8df6de..16b135e17 100644 --- a/docs/en/setup/service-agent/java-agent/Application-toolkit-trace.md +++ b/docs/en/setup/service-agent/java-agent/Application-toolkit-trace.md @@ -18,6 +18,20 @@ _Sample codes only_ * Add `@Trace` to any method you want to trace. After that, you can see the span in the Stack. * Add custom tag in the context of traced method . + +* `ActiveSpan.error()` Mark the current span as error status. +* `ActiveSpan.error(String errorMsg)` Mark the current span as error status with a message. +* `ActiveSpan.error(Throwable throwable)` Mark the current span as error status with a Throwable. +* `ActiveSpan.debug(String debugMsg)` Add a debug level log message in the current span. +* `ActiveSpan.info(String infoMsg)` Add an info level log message in the current span. + ```java ActiveSpan.tag("my_tag", "my_value"); +ActiveSpan.error(); +ActiveSpan.error("Test-Error-Reason"); + +ActiveSpan.error(new RuntimeException("Test-Error-Throwable")); +ActiveSpan.info("Test-Info-Msg"); +ActiveSpan.debug("Test-debug-Msg"); ``` +