Support span#error in toolkit (#2605)

* Fix #2546

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) {
     }
 }

apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanTagActivation.java → apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanActivation.java

@@ -28,6 +28,8 @@ import org.apache.skywalking.apm.agent.core.plugin.interceptor.StaticMethodsInte
 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 <code>tag</code> method of <code>ActiveSpan</code>
@@ -35,11 +37,24 @@ import static net.bytebuddy.matcher.ElementMatchers.named;
  *
  * @author zhangxin
  */
-public class ActiveSpanTagActivation extends ClassStaticMethodsEnhancePluginDefine {
+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";
 
-    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];
@@ -49,11 +64,81 @@ public class ActiveSpanTagActivation extends ClassStaticMethodsEnhancePluginDefi
         return new StaticMethodsInterceptPoint[] {
             new StaticMethodsInterceptPoint() {
                 @Override public ElementMatcher<MethodDescription> getMethodsMatcher() {
-                    return named(INTERCEPTOR_METHOD_NAME);
+                    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<MethodDescription> 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<MethodDescription> 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<MethodDescription> 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<MethodDescription> 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<MethodDescription> getMethodsMatcher() {
+                    return named(ERROR_INTERCEPTOR_METHOD_NAME)
+                            .and(takesArguments(0));
                 }
 
                 @Override public String getMethodsInterceptor() {
-                    return INTERCEPTOR_CLASS;
+                    return ERROR_INTERCEPTOR_CLASS;
                 }
 
                 @Override public boolean isOverrideArgs() {

apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanDebugInterceptor.java

+/*
+ * 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<String, String> event = new HashMap<String, String>();
+            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) {
+
+    }
+}

apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanErrorInterceptor.java

+/*
+ * 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

apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanErrorMsgInterceptor.java

+/*
+ * 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<String, String> event = new HashMap<String, String>();
+            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

apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanErrorThrowableInteceptor.java

+/*
+ * 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) {
+
+    }
+}

apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/main/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanInfoInterceptor.java

+/*
+ * 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<String, String> event = new HashMap<String, String>();
+            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) {
+
+    }
+}

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

apm-sniffer/apm-toolkit-activation/apm-toolkit-trace-activation/src/test/java/org/apache/skywalking/apm/toolkit/activation/trace/ActiveSpanTest.java

+/*
+ * 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<AbstractTracingSpan> 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<AbstractTracingSpan> 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<AbstractTracingSpan> 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<AbstractTracingSpan> 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"));
+        }
+    }
+}

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");
 ```
+