suport ot activation

apm-application-toolkit/apm-toolkit-opentracing/src/main/java/org/skywalking/apm/toolkit/opentracing/SkywalkingSpan.java

@@ -12,7 +12,7 @@ public class SkywalkingSpan implements Span {
     @NeedSnifferActivation(
         "1.ContextManager#createSpan (Entry,Exit,Local based on builder)." +
             "2.set the span reference to the dynamic field of enhanced SkywalkingSpan")
-    public SkywalkingSpan(SkywalkingSpanBuilder builder) {
+    SkywalkingSpan(SkywalkingSpanBuilder builder) {
     }
 
     /**

apm-application-toolkit/apm-toolkit-opentracing/src/main/java/org/skywalking/apm/toolkit/opentracing/SkywalkingSpanBuilder.java

@@ -38,7 +38,7 @@ public class SkywalkingSpanBuilder implements Tracer.SpanBuilder {
 
     @Override
     public Tracer.SpanBuilder asChildOf(BaseSpan<?> parent) {
-        if (parent instanceof SkywalkingSpan) {
+        if (parent instanceof SkywalkingSpan || parent instanceof SkywalkingActiveSpan) {
             return this;
         }
         throw new IllegalArgumentException("parent must be type of SkywalkingSpan");
@@ -61,23 +61,23 @@ public class SkywalkingSpanBuilder implements Tracer.SpanBuilder {
 
     @Override
     public Tracer.SpanBuilder withTag(String key, String value) {
-        if (Tags.COMPONENT.equals(key)) {
+        if (Tags.COMPONENT.getKey().equals(key)) {
             componentName = value;
-        } else if (Tags.SPAN_KIND.equals(key)) {
-            if (Tags.SPAN_KIND_CLIENT.equals(key) || Tags.SPAN_KIND_PRODUCER.equals(key)) {
+        } else if (Tags.SPAN_KIND.getKey().equals(key)) {
+            if (Tags.SPAN_KIND_CLIENT.equals(value) || Tags.SPAN_KIND_PRODUCER.equals(value)) {
                 isEntry = false;
                 isExit = true;
-            } else if (Tags.SPAN_KIND_SERVER.equals(key) || Tags.SPAN_KIND_CONSUMER.equals(key)) {
+            } else if (Tags.SPAN_KIND_SERVER.equals(value) || Tags.SPAN_KIND_CONSUMER.equals(value)) {
                 isEntry = true;
                 isExit = false;
             } else {
                 isEntry = false;
                 isExit = false;
             }
-        } else if (Tags.PEER_HOST_IPV4.equals(key) || Tags.PEER_HOST_IPV6.equals(key)
-            || Tags.PEER_HOSTNAME.equals(key)) {
+        } else if (Tags.PEER_HOST_IPV4.getKey().equals(key) || Tags.PEER_HOST_IPV6.getKey().equals(key)
+            || Tags.PEER_HOSTNAME.getKey().equals(key)) {
             peer = value;
-        } else if (Tags.PEER_SERVICE.equals(key)) {
+        } else if (Tags.PEER_SERVICE.getKey().equals(key)) {
             operationName = value;
         } else {
             tags.add(new Tag(key, value));
@@ -97,7 +97,7 @@ public class SkywalkingSpanBuilder implements Tracer.SpanBuilder {
 
     @Override
     public Tracer.SpanBuilder withTag(String key, Number value) {
-        if (Tags.PEER_PORT.equals(key)) {
+        if (Tags.PEER_PORT.getKey().equals(key)) {
             port = value.intValue();
         } else {
             tags.add(new Tag(key, value.toString()));

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/ContextManager.java

@@ -109,9 +109,7 @@ public class ContextManager implements TracingContextListener, BootService, Igno
     }
 
     public static void inject(ContextCarrier carrier) {
-        if (carrier != null && carrier.isValid()) {
-            get().inject(carrier);
-        }
+        get().inject(carrier);
     }
 
     public static void extract(ContextCarrier carrier) {

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/AbstractSpan.java

 package org.skywalking.apm.agent.core.context.trace;
 
+import java.util.Map;
 import org.skywalking.apm.network.trace.component.Component;
 
 /**
@@ -54,4 +55,20 @@ public interface AbstractSpan {
      * @return true if the actual span is an exit span.
      */
     boolean isExit();
+
+    /**
+     * Record an event at a specific timestamp.
+     *
+     * @param timestamp The explicit timestamp for the log record.
+     * @param event the events
+     * @return the Span, for chaining
+     */
+    AbstractSpan log(long timestamp, Map<String, ?> event);
+
+    /**
+     * Sets the string name for the logical operation this span represents.
+     *
+     * @return this Span instance, for chaining
+     */
+    AbstractSpan setOperationName(String operationName);
 }

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/AbstractTracingSpan.java

@@ -87,7 +87,7 @@ public abstract class AbstractTracingSpan implements AbstractSpan {
         return true;
     }
 
-    public AbstractSpan start() {
+    public AbstractTracingSpan start() {
         this.startTime = System.currentTimeMillis();
         return this;
     }
@@ -98,7 +98,8 @@ public abstract class AbstractTracingSpan implements AbstractSpan {
      * @param t any subclass of {@link Throwable}, which occurs in this span.
      * @return the Span, for chaining
      */
-    public AbstractSpan log(Throwable t) {
+    @Override
+    public AbstractTracingSpan log(Throwable t) {
         if (logs == null) {
             logs = new LinkedList<LogDataEntity>();
         }
@@ -117,7 +118,8 @@ public abstract class AbstractTracingSpan implements AbstractSpan {
      * @param fields
      * @return the Span, for chaining
      */
-    public AbstractSpan log(long timestampMicroseconds, Map<String, ?> fields) {
+    @Override
+    public AbstractTracingSpan log(long timestampMicroseconds, Map<String, ?> fields) {
         if (logs == null) {
             logs = new LinkedList<LogDataEntity>();
         }
@@ -135,7 +137,8 @@ public abstract class AbstractTracingSpan implements AbstractSpan {
      *
      * @return span instance, for chaining.
      */
-    public AbstractSpan errorOccurred() {
+    @Override
+    public AbstractTracingSpan errorOccurred() {
         this.errorOccurred = true;
         return this;
     }
@@ -147,6 +150,7 @@ public abstract class AbstractTracingSpan implements AbstractSpan {
      * @param operationName
      * @return span instance, for chaining.
      */
+    @Override
     public AbstractTracingSpan setOperationName(String operationName) {
         this.operationName = operationName;
         return this;
@@ -176,7 +180,7 @@ public abstract class AbstractTracingSpan implements AbstractSpan {
     }
 
     @Override
-    public AbstractSpan setLayer(SpanLayer layer) {
+    public AbstractTracingSpan setLayer(SpanLayer layer) {
         this.layer = layer;
         return this;
     }
@@ -189,7 +193,7 @@ public abstract class AbstractTracingSpan implements AbstractSpan {
      * @return span instance, for chaining.
      */
     @Override
-    public AbstractSpan setComponent(Component component) {
+    public AbstractTracingSpan setComponent(Component component) {
         this.componentId = component.getId();
         return this;
     }
@@ -202,7 +206,7 @@ public abstract class AbstractTracingSpan implements AbstractSpan {
      * @return span instance, for chaining.
      */
     @Override
-    public AbstractSpan setComponent(String componentName) {
+    public AbstractTracingSpan setComponent(String componentName) {
         this.componentName = componentName;
         return this;
     }

apm-sniffer/apm-agent-core/src/main/java/org/skywalking/apm/agent/core/context/trace/NoopSpan.java

 package org.skywalking.apm.agent.core.context.trace;
 
+import java.util.Map;
 import org.skywalking.apm.agent.core.context.IgnoredTracerContext;
 import org.skywalking.apm.network.trace.component.Component;
 
@@ -51,4 +52,12 @@ public class NoopSpan implements AbstractSpan {
     @Override public boolean isExit() {
         return false;
     }
+
+    @Override public AbstractSpan log(long timestamp, Map<String, ?> event) {
+        return this;
+    }
+
+    @Override public AbstractSpan setOperationName(String operationName) {
+        return this;
+    }
 }

apm-sniffer/apm-sdk-plugin/mongodb-3.x-plugin/src/main/java/org/skywalking/apm/plugin/mongodb/v3/MongoDBMethodInterceptor.java

@@ -50,11 +50,7 @@ import org.skywalking.apm.network.trace.component.ComponentsDefine;
  */
 public class MongoDBMethodInterceptor implements InstanceMethodsAroundInterceptor, InstanceConstructorInterceptor {
 
-    static final String MONGODB_HOST = "MONGODB_HOST";
-
-    static final String MONGODB_PORT = "MONGODB_PORT";
-
-    private static final String MONGODB_COMPONENT = "MongoDB";
+    private static final String DB_TYPE = "MongoDB";
 
     private static final String METHOD = "MongoDB/";
 
@@ -159,7 +155,7 @@ public class MongoDBMethodInterceptor implements InstanceMethodsAroundIntercepto
         String remotePeer = (String)objInst.getSkyWalkingDynamicField();
         AbstractSpan span = ContextManager.createExitSpan(METHOD + methodName, new ContextCarrier(), remotePeer);
         span.setComponent(ComponentsDefine.MONGODB);
-        Tags.DB_TYPE.set(span, MONGODB_COMPONENT);
+        Tags.DB_TYPE.set(span, DB_TYPE);
         SpanLayer.asDB(span);
 
         if (Config.Plugin.MongoDB.TRACE_PARAM) {

apm-sniffer/apm-test-tools/src/main/java/org/skywalking/apm/agent/test/tools/SegmentRefAssert.java

+package org.skywalking.apm.agent.test.tools;
+
+import org.skywalking.apm.agent.core.context.trace.TraceSegmentRef;
+import org.skywalking.apm.agent.test.helper.SegmentRefHelper;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class SegmentRefAssert {
+    public static void assertSegmentId(TraceSegmentRef ref, String segmentId) {
+        assertThat(SegmentRefHelper.getTraceSegmentId(ref), is(segmentId));
+    }
+
+    public static void assertSpanId(TraceSegmentRef ref, int spanId) {
+        assertThat(SegmentRefHelper.getSpanId(ref), is(spanId));
+    }
+
+    public static void assertPeerHost(TraceSegmentRef ref, String peerHost) {
+        assertThat(SegmentRefHelper.getPeerHost(ref), is(peerHost));
+    }
+}

apm-sniffer/apm-test-tools/src/main/java/org/skywalking/apm/agent/test/tools/SpanAssert.java

@@ -38,6 +38,10 @@ public class SpanAssert {
         assertThat(SpanHelper.getComponentId(span), is(component.getId()));
     }
 
+    public static void assertComponent(AbstractSpan span, String componentName) {
+        assertThat(SpanHelper.getComponentName(span), is(componentName));
+    }
+
     public static void assertLayer(AbstractSpan span, SpanLayer spanLayer) {
         assertThat(SpanHelper.getLayer(span), is(spanLayer));
     }

apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/continuation/ActivateInterceptor.java

+package org.skywalking.apm.toolkit.activation.opentracing.continuation;
+
+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;
+import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor;
+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,
+        Class<?>[] argumentsTypes, MethodInterceptResult result) throws Throwable {
+    }
+
+    @Override public Object afterMethod(EnhancedInstance objInst, String methodName, Object[] allArguments,
+        Class<?>[] argumentsTypes, Object ret) throws Throwable {
+        Object contextSnapshot = objInst.getSkyWalkingDynamicField();
+        if (contextSnapshot != null) {
+            ContextManager.continued((ContextSnapshot)contextSnapshot);
+        }
+        return ret;
+    }
+
+    @Override public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments,
+        Class<?>[] argumentsTypes, Throwable t) {
+
+    }
+}

apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/continuation/ConstructorInterceptor.java

+package org.skywalking.apm.toolkit.activation.opentracing.continuation;
+
+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.InstanceConstructorInterceptor;
+
+public class ConstructorInterceptor implements InstanceConstructorInterceptor {
+    @Override
+    public void onConstruct(EnhancedInstance objInst, Object[] allArguments) {
+        objInst.setSkyWalkingDynamicField(ContextManager.capture());
+    }
+}

apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/continuation/SkywalkingContinuationActivation.java

+package org.skywalking.apm.toolkit.activation.opentracing.continuation;
+
+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 static net.bytebuddy.matcher.ElementMatchers.any;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+
+/**
+ * {@link SkywalkingContinuationActivation} defines two interceptors to enhance the methods and constructor in class
+ * <code>org.skywalking.apm.toolkit.opentracing.SkywalkingContinuation</code>.
+ *
+ * 1. The <code>org.skywalking.apm.toolkit.activation.opentracing.continuation.ConstructorInterceptor</code>
+ * interceptor enhance the constructor.
+ *
+ * 2. The <code>org.skywalking.apm.toolkit.activation.opentracing.continuation.ActivateInterceptor</code>
+ * interceptor enhance the <code>activate</code>.
+ */
+public class SkywalkingContinuationActivation extends ClassInstanceMethodsEnhancePluginDefine {
+
+    private static final String ENHANCE_CLASS = "org.skywalking.apm.toolkit.opentracing.SkywalkingContinuation";
+    private static final String CONSTRUCTOR_INTERCEPTOR = "org.skywalking.apm.toolkit.activation.opentracing.continuation.ConstructorInterceptor";
+    private static final String ACTIVATE_METHOD_INTERCEPTOR = "org.skywalking.apm.toolkit.activation.opentracing.continuation.ActivateInterceptor";
+
+    @Override
+    protected String enhanceClassName() {
+        return ENHANCE_CLASS;
+    }
+
+    @Override
+    protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() {
+        return new ConstructorInterceptPoint[] {
+            new ConstructorInterceptPoint() {
+                @Override public ElementMatcher<MethodDescription> getConstructorMatcher() {
+                    return any();
+                }
+
+                @Override public String getConstructorInterceptor() {
+                    return CONSTRUCTOR_INTERCEPTOR;
+                }
+            }
+        };
+    }
+
+    @Override
+    protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() {
+        return new InstanceMethodsInterceptPoint[] {
+            new InstanceMethodsInterceptPoint() {
+                @Override public ElementMatcher<MethodDescription> getMethodsMatcher() {
+                    return named("activate");
+                }
+
+                @Override public String getMethodsInterceptor() {
+                    return ACTIVATE_METHOD_INTERCEPTOR;
+                }
+
+                @Override public boolean isOverrideArgs() {
+                    return false;
+                }
+            }
+        };
+    }
+}

apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/ConstructorWithSpanBuilderInterceptor.java

+package org.skywalking.apm.toolkit.activation.opentracing.span;
+
+import org.skywalking.apm.agent.core.context.ContextCarrier;
+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.InstanceConstructorInterceptor;
+import org.skywalking.apm.toolkit.opentracing.SkywalkingSpanBuilder;
+import org.skywalking.apm.toolkit.opentracing.Tag;
+import org.skywalking.apm.util.StringUtil;
+
+public class ConstructorWithSpanBuilderInterceptor implements InstanceConstructorInterceptor {
+
+    @Override
+    public void onConstruct(EnhancedInstance objInst, Object[] allArguments) {
+        SkywalkingSpanBuilder spanBuilder = (SkywalkingSpanBuilder)allArguments[0];
+
+        AbstractSpan span;
+        if (spanBuilder.isEntry()) {
+            span = ContextManager.createEntrySpan(spanBuilder.getOperationName(), null);
+        } else if (spanBuilder.isExit() && (!StringUtil.isEmpty(spanBuilder.getPeer()))) {
+            span = ContextManager.createExitSpan(spanBuilder.getOperationName(),
+                new ContextCarrier(), buildRemotePeer(spanBuilder));
+        } else {
+            span = ContextManager.createLocalSpan(spanBuilder.getOperationName());
+        }
+
+        for (Tag tag : spanBuilder.getTags()) {
+            span.tag(tag.getKey(), tag.getValue());
+        }
+        span.setComponent(spanBuilder.getComponentName());
+        if (spanBuilder.isError()) {
+            span.errorOccurred();
+        }
+
+        objInst.setSkyWalkingDynamicField(span);
+    }
+
+    private String buildRemotePeer(SkywalkingSpanBuilder spanBuilder) {
+        return spanBuilder.getPeer() + (spanBuilder.getPort() == 0 ? "" : ":" + spanBuilder.getPort());
+    }
+}

apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/ConstructorWithTracerInterceptor.java

+package org.skywalking.apm.toolkit.activation.opentracing.span;
+
+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.InstanceConstructorInterceptor;
+
+public class ConstructorWithTracerInterceptor implements InstanceConstructorInterceptor {
+
+    @Override
+    public void onConstruct(EnhancedInstance objInst, Object[] allArguments) {
+        objInst.setSkyWalkingDynamicField(ContextManager.activeSpan());
+    }
+}

apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SkywalkingSpanActivation.java

+package org.skywalking.apm.toolkit.activation.opentracing.span;
+
+import java.util.Map;
+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 static net.bytebuddy.matcher.ElementMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.takesArgument;
+import static org.skywalking.apm.agent.core.plugin.bytebuddy.ArgumentTypeNameMatch.takesArgumentWithType;
+
+/**
+ * {@link SkywalkingSpanActivation} defines five interceptors to enhance the methods and constructor in class
+ * <code>org.skywalking.apm.toolkit.opentracing.SkywalkingSpan</code>.
+ *
+ * 1. The <code>org.skywalking.apm.toolkit.activation.opentracing.span.ConstructorWithSpanBuilderInterceptor</code>
+ * interceptor enhance the constructor with <code>org.skywalking.apm.toolkit.opentracing.SkywalkingSpanBuilder</code>
+ * argument.
+ *
+ * 2. The <code>org.skywalking.apm.toolkit.activation.opentracing.span.ConstructorWithTracerInterceptor</code>
+ * interceptor enhance the constructor with <code>org.skywalking.apm.toolkit.opentracing.SkywalkingTracer</code>
+ * argument.
+ *
+ * 3. The <code>org.skywalking.apm.toolkit.activation.opentracing.span.SpanFinishInterceptor</code>
+ * interceptor enhance the <code>finish</code> method that the first argument type is {@link Long}
+ *
+ * 4. The <code>org.skywalking.apm.toolkit.activation.opentracing.span.SpanLogInterceptor</code>
+ * interceptor enhance the <code>log</code> method that the first argument type is {@link Long} and the second
+ * argument type is {@link Map<String,?>}
+ *
+ * 5. The <code>org.skywalking.apm.toolkit.activation.opentracing.span.SpanSetOperationNameInterceptor</code>
+ * interceptor enhance the <code>setOperationName</code> method
+ **/
+public class SkywalkingSpanActivation extends ClassInstanceMethodsEnhancePluginDefine {
+
+    private static final String ENHANCE_CLASS = "org.skywalking.apm.toolkit.opentracing.SkywalkingSpan";
+
+    private static final String SPAN_BUILDER_CLASS_NAME = "org.skywalking.apm.toolkit.opentracing.SkywalkingSpanBuilder";
+    private static final String CONSTRUCTOR_WITH_SPAN_BUILDER_INTERCEPTOR = "org.skywalking.apm.toolkit.activation.opentracing.span.ConstructorWithSpanBuilderInterceptor";
+
+    private static final String SKYWALKING_TRACER_CLASS_NAME = "org.skywalking.apm.toolkit.opentracing.SkywalkingTracer";
+    private static final String CONSTRUCTOR_WITH_TRACER_INTERCEPTOR = "org.skywalking.apm.toolkit.activation.opentracing.span.ConstructorWithTracerInterceptor";
+
+    private static final String FINISH_METHOD_INTERCEPTOR = "org.skywalking.apm.toolkit.activation.opentracing.span.SpanFinishInterceptor";
+    private static final String LOG_INTERCEPTOR = "org.skywalking.apm.toolkit.activation.opentracing.span.SpanLogInterceptor";
+    private static final String SET_OPERATION_NAME_INTERCEPTOR = "org.skywalking.apm.toolkit.activation.opentracing.span.SpanSetOperationNameInterceptor";
+
+    @Override
+    protected String enhanceClassName() {
+        return ENHANCE_CLASS;
+    }
+
+    @Override
+    protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() {
+        return new ConstructorInterceptPoint[] {
+            new ConstructorInterceptPoint() {
+                @Override
+                public ElementMatcher<MethodDescription> getConstructorMatcher() {
+                    return takesArgumentWithType(0, SPAN_BUILDER_CLASS_NAME);
+                }
+
+                @Override
+                public String getConstructorInterceptor() {
+                    return CONSTRUCTOR_WITH_SPAN_BUILDER_INTERCEPTOR;
+                }
+            },
+            new ConstructorInterceptPoint() {
+                @Override
+                public ElementMatcher<MethodDescription> getConstructorMatcher() {
+                    return takesArgumentWithType(0, SKYWALKING_TRACER_CLASS_NAME);
+                }
+
+                @Override
+                public String getConstructorInterceptor() {
+                    return CONSTRUCTOR_WITH_TRACER_INTERCEPTOR;
+                }
+            }
+        };
+    }
+
+    @Override
+    protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() {
+        return new InstanceMethodsInterceptPoint[] {
+            new InstanceMethodsInterceptPoint() {
+                @Override
+                public ElementMatcher<MethodDescription> getMethodsMatcher() {
+                    return named("finish").and(takesArgument(0, long.class));
+                }
+
+                @Override
+                public String getMethodsInterceptor() {
+                    return FINISH_METHOD_INTERCEPTOR;
+                }
+
+                @Override
+                public boolean isOverrideArgs() {
+                    return false;
+                }
+            },
+            new InstanceMethodsInterceptPoint() {
+                @Override
+                public ElementMatcher<MethodDescription> getMethodsMatcher() {
+                    return named("log").and(takesArgument(0, long.class).and(takesArgument(1, Map.class)));
+                }
+
+                @Override
+                public String getMethodsInterceptor() {
+                    return LOG_INTERCEPTOR;
+                }
+
+                @Override
+                public boolean isOverrideArgs() {
+                    return false;
+                }
+            },
+            new InstanceMethodsInterceptPoint() {
+                @Override
+                public ElementMatcher<MethodDescription> getMethodsMatcher() {
+                    return named("setOperationName");
+                }
+
+                @Override
+                public String getMethodsInterceptor() {
+                    return SET_OPERATION_NAME_INTERCEPTOR;
+                }
+
+                @Override
+                public boolean isOverrideArgs() {
+                    return false;
+                }
+            }
+        };
+    }
+}

apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanFinishInterceptor.java

+package org.skywalking.apm.toolkit.activation.opentracing.span;
+
+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 SpanFinishInterceptor 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 {
+        AbstractSpan abstractSpan = (AbstractSpan)objInst.getSkyWalkingDynamicField();
+        if (abstractSpan != null) {
+            ContextManager.stopSpan(abstractSpan);
+        }
+        return ret;
+    }
+
+    @Override
+    public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments,
+        Class<?>[] argumentsTypes, Throwable t) {
+
+    }
+}

apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanLogInterceptor.java

+package org.skywalking.apm.toolkit.activation.opentracing.span;
+
+import java.util.Map;
+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;
+
+/**
+ * Created by xin on 2017/7/10.
+ */
+public class SpanLogInterceptor 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 {
+        AbstractSpan abstractSpan = (AbstractSpan)objInst.getSkyWalkingDynamicField();
+        if (abstractSpan != null) {
+            abstractSpan.log(Long.parseLong(allArguments[0].toString()), (Map<String, ?>)allArguments[1]);
+        }
+        return ret;
+    }
+
+    @Override
+    public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments,
+        Class<?>[] argumentsTypes, Throwable t) {
+
+    }
+}

apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/span/SpanSetOperationNameInterceptor.java

+package org.skywalking.apm.toolkit.activation.opentracing.span;
+
+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 SpanSetOperationNameInterceptor 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 {
+        AbstractSpan tracingSpan = (AbstractSpan)objInst.getSkyWalkingDynamicField();
+        if (tracingSpan != null) {
+            tracingSpan.setOperationName(allArguments[0].toString());
+        }
+        return ret;
+    }
+
+    @Override
+    public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments,
+        Class<?>[] argumentsTypes, Throwable t) {
+
+    }
+}

apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/tracer/SkywalkingTracerActivation.java

+package org.skywalking.apm.toolkit.activation.opentracing.tracer;
+
+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 static net.bytebuddy.matcher.ElementMatchers.named;
+
+/**
+ * {@link SkywalkingTracerActivation} defines two interceptors to enhance the methods in
+ * class <code>org.skywalking.apm.toolkit.opentracing.SkywalkingTracer</code>.
+ *
+ * 1. The <code>org.skywalking.apm.toolkit.activation.opentracing.tracer.SkywalkingTracerInjectInterceptor</code>
+ * interceptor enhance the <code>extract</code> method
+ *
+ * 2. The <code>org.skywalking.apm.toolkit.activation.opentracing.tracer.SkywalkingTracerExtractInterceptor</code>
+ * interceptor enhance the <code>inject</code> method
+ **/
+public class SkywalkingTracerActivation extends ClassInstanceMethodsEnhancePluginDefine {
+
+    private static final String ENHANCE_CLASS = "org.skywalking.apm.toolkit.opentracing.SkywalkingTracer";
+    private static final String INJECT_INTERCEPTOR = "org.skywalking.apm.toolkit.activation.opentracing.tracer.SkywalkingTracerInjectInterceptor";
+    private static final String EXTRACT_INTERCEPTOR = "org.skywalking.apm.toolkit.activation.opentracing.tracer.SkywalkingTracerExtractInterceptor";
+
+    @Override protected String enhanceClassName() {
+        return ENHANCE_CLASS;
+    }
+
+    @Override protected ConstructorInterceptPoint[] getConstructorsInterceptPoints() {
+        return new ConstructorInterceptPoint[0];
+    }
+
+    @Override protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() {
+        return new InstanceMethodsInterceptPoint[] {
+            new InstanceMethodsInterceptPoint() {
+                @Override public ElementMatcher<MethodDescription> getMethodsMatcher() {
+                    return named("inject");
+                }
+
+                @Override public String getMethodsInterceptor() {
+                    return INJECT_INTERCEPTOR;
+                }
+
+                @Override public boolean isOverrideArgs() {
+                    return false;
+                }
+            },
+            new InstanceMethodsInterceptPoint() {
+                @Override public ElementMatcher<MethodDescription> getMethodsMatcher() {
+                    return named("extract");
+                }
+
+                @Override public String getMethodsInterceptor() {
+                    return EXTRACT_INTERCEPTOR;
+                }
+
+                @Override public boolean isOverrideArgs() {
+                    return false;
+                }
+            }
+        };
+    }
+}

apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/tracer/SkywalkingTracerExtractInterceptor.java

+package org.skywalking.apm.toolkit.activation.opentracing.tracer;
+
+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;
+import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor;
+import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult;
+
+public class SkywalkingTracerExtractInterceptor 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 {
+        String carrier = (String)allArguments[0];
+        ContextCarrier contextCarrier = new ContextCarrier().deserialize(carrier);
+        ContextManager.extract(contextCarrier);
+        return ret;
+    }
+
+    @Override
+    public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments,
+        Class<?>[] argumentsTypes, Throwable t) {
+
+    }
+}

apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/java/org/skywalking/apm/toolkit/activation/opentracing/tracer/SkywalkingTracerInjectInterceptor.java

+package org.skywalking.apm.toolkit.activation.opentracing.tracer;
+
+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;
+import org.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor;
+import org.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult;
+
+public class SkywalkingTracerInjectInterceptor 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 {
+        ContextCarrier contextCarrier = new ContextCarrier();
+        ContextManager.inject(contextCarrier);
+        return contextCarrier.serialize();
+    }
+
+    @Override
+    public void handleMethodException(EnhancedInstance objInst, String methodName, Object[] allArguments,
+        Class<?>[] argumentsTypes, Throwable t) {
+
+    }
+}

apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/main/resources/skywalking-plugin.def

-opentracing=org.skywalking.apm.toolkit.activation.opentracing.span.SkyWalkingSpanActivation
-opentracing=org.skywalking.apm.toolkit.activation.opentracing.tracer.SkyWalkingTracerActivation
\ No newline at end of file
+opentracing=org.skywalking.apm.toolkit.activation.opentracing.tracer.SkywalkingTracerActivation
+opentracing=org.skywalking.apm.toolkit.activation.opentracing.span.SkywalkingSpanActivation
+opentracing=org.skywalking.apm.toolkit.activation.opentracing.continuation.SkywalkingContinuationActivation

apm-sniffer/apm-toolkit-activation/apm-toolkit-opentracing-activation/src/test/java/org/skywalking/apm/toolkit/activation/opentracing/SkywalkingSpanActivationTest.java

+package org.skywalking.apm.toolkit.activation.opentracing;
+
+import io.opentracing.Tracer;
+import io.opentracing.tag.Tags;
+import java.util.HashMap;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.powermock.modules.junit4.PowerMockRunner;
+import org.powermock.modules.junit4.PowerMockRunnerDelegate;
+import org.skywalking.apm.agent.core.context.ContextCarrier;
+import org.skywalking.apm.agent.core.context.ContextSnapshot;
+import org.skywalking.apm.agent.core.context.trace.AbstractTracingSpan;
+import org.skywalking.apm.agent.core.context.trace.TraceSegment;
+import org.skywalking.apm.agent.core.context.trace.TraceSegmentRef;
+import org.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
+import org.skywalking.apm.agent.test.helper.SegmentHelper;
+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 org.skywalking.apm.toolkit.activation.opentracing.continuation.ActivateInterceptor;
+import org.skywalking.apm.toolkit.activation.opentracing.continuation.ConstructorInterceptor;
+import org.skywalking.apm.toolkit.activation.opentracing.span.ConstructorWithSpanBuilderInterceptor;
+import org.skywalking.apm.toolkit.activation.opentracing.span.SpanFinishInterceptor;
+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.SkywalkingSpanBuilder;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.skywalking.apm.agent.test.tools.SegmentRefAssert.assertPeerHost;
+import static org.skywalking.apm.agent.test.tools.SegmentRefAssert.assertSegmentId;
+import static org.skywalking.apm.agent.test.tools.SegmentRefAssert.assertSpanId;
+import static org.skywalking.apm.agent.test.tools.SpanAssert.assertComponent;
+import static org.skywalking.apm.agent.test.tools.SpanAssert.assertLogSize;
+
+@RunWith(PowerMockRunner.class)
+@PowerMockRunnerDelegate(TracingSegmentRunner.class)
+public class SkywalkingSpanActivationTest {
+
+    @SegmentStoragePoint
+    private SegmentStorage storage;
+
+    @Rule
+    public AgentServiceRule serviceRule = new AgentServiceRule();
+    private MockEnhancedInstance enhancedInstance = new MockEnhancedInstance();
+    private ConstructorWithSpanBuilderInterceptor constructorWithSpanBuilderInterceptor;
+    private Tracer.SpanBuilder spanBuilder = new SkywalkingSpanBuilder("test");
+    private SpanLogInterceptor spanLogInterceptor;
+    private Object[] logArgument;
+    private HashMap<String, Object> event = new HashMap<String, Object>() {
+        {
+            put("a", "A");
+        }
+    };
+    private Class[] logArgumentType;
+
+    private SpanSetOperationNameInterceptor setOperationNameInterceptor;
+    private Object[] setOperationNameArgument;
+    private Class[] setOperationNameArgumentType;
+
+    private SpanFinishInterceptor spanFinishInterceptor;
+
+    private SkywalkingTracerInjectInterceptor injectInterceptor;
+
+    private SkywalkingTracerExtractInterceptor extractInterceptor;
+
+    private ConstructorInterceptor constructorInterceptor;
+
+    private ActivateInterceptor activateInterceptor;
+
+    @Before
+    public void setUp() {
+        spanBuilder = new SkywalkingSpanBuilder("test").withTag(Tags.COMPONENT.getKey(), "test");
+        constructorWithSpanBuilderInterceptor = new ConstructorWithSpanBuilderInterceptor();
+        spanLogInterceptor = new SpanLogInterceptor();
+        logArgument = new Object[] {111111111L, event};
+        logArgumentType = new Class[] {long.class, HashMap.class};
+
+        setOperationNameInterceptor = new SpanSetOperationNameInterceptor();
+        setOperationNameArgument = new Object[] {"testOperationName"};
+        setOperationNameArgumentType = new Class[] {String.class};
+
+        spanFinishInterceptor = new SpanFinishInterceptor();
+
+        injectInterceptor = new SkywalkingTracerInjectInterceptor();
+        extractInterceptor = new SkywalkingTracerExtractInterceptor();
+
+        constructorInterceptor = new ConstructorInterceptor();
+        activateInterceptor = new ActivateInterceptor();
+    }
+
+    @Test
+    public void testCreateLocalSpan() throws Throwable {
+        startSpan();
+        stopSpan();
+
+        TraceSegment tracingSegment = assertTraceSemgnets();
+        List<AbstractTracingSpan> spans = SegmentHelper.getSpans(tracingSegment);
+        assertThat(spans.size(), is(1));
+        assertThat(spans.get(0).isEntry(), is(false));
+        assertThat(spans.get(0).isExit(), is(false));
+    }
+
+    @Test
+    public void testCreateEntrySpan() throws Throwable {
+        spanBuilder.withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_SERVER);
+        startSpan();
+        stopSpan();
+
+        TraceSegment tracingSegment = assertTraceSemgnets();
+        List<AbstractTracingSpan> spans = SegmentHelper.getSpans(tracingSegment);
+        assertThat(spans.size(), is(1));
+        assertSpanCommonsAttribute(spans.get(0));
+        assertThat(spans.get(0).isEntry(), is(true));
+    }
+
+    @Test
+    public void testCreateExitSpanWithoutPeer() throws Throwable {
+        spanBuilder.withTag(Tags.SPAN_KIND.getKey(), Tags.SPAN_KIND_CLIENT);
+        startSpan();
+        stopSpan();
+
+        TraceSegment tracingSegment = assertTraceSemgnets();
+        List<AbstractTracingSpan> spans = SegmentHelper.getSpans(tracingSegment);
+        assertThat(spans.size(), is(1));
+        assertSpanCommonsAttribute(spans.get(0));
+        assertThat(spans.get(0).isEntry(), is(false));
+        assertThat(spans.get(0).isExit(), is(false));
+    }
+
+    @Test
+    public void testCreateExitSpanWithPeer() 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();
+        stopSpan();
+
+        TraceSegment tracingSegment = assertTraceSemgnets();
+        List<AbstractTracingSpan> spans = SegmentHelper.getSpans(tracingSegment);
+        assertThat(spans.size(), is(1));
+        assertSpanCommonsAttribute(spans.get(0));
+        assertThat(spans.get(0).isEntry(), is(false));
+        assertThat(spans.get(0).isExit(), is(true));
+    }
+
+    private TraceSegment assertTraceSemgnets() {
+        List<TraceSegment> segments = storage.getTraceSegments();
+        assertThat(segments.size(), is(1));
+
+        return segments.get(0);
+    }
+
+    @Test
+    public void testInject() 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();
+
+        String extractValue = (String)injectInterceptor.afterMethod(enhancedInstance, "extract",
+            null, null, null);
+
+        ContextCarrier contextCarrier = new ContextCarrier().deserialize(extractValue);
+        assertTrue(contextCarrier.isValid());
+        assertThat(contextCarrier.getPeerHost(), is("#127.0.0.1:8080"));
+        assertThat(contextCarrier.getSpanId(), is(0));
+        assertThat(contextCarrier.getEntryOperationName(), is("#testOperationName"));
+        stopSpan();
+    }
+
+    @Test
+    public void testExtractWithValidateContext() 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",
+            new Object[] {"S.1499746282749.1100157028.88023.1.1|0|1|#127.0.0.1:8080|#testOperationName|T.1499746282768.1100157028.88023.1.2"}, new Class[] {String.class}, null);
+        stopSpan();
+
+        TraceSegment tracingSegment = assertTraceSemgnets();
+        List<AbstractTracingSpan> spans = SegmentHelper.getSpans(tracingSegment);
+        assertThat(tracingSegment.getRefs().size(), is(1));
+        TraceSegmentRef ref = tracingSegment.getRefs().get(0);
+        assertSegmentId(ref, "S.1499746282749.1100157028.88023.1.1");
+        assertSpanId(ref, 0);
+        assertPeerHost(ref, "127.0.0.1:8080");
+        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",
+            new Object[] {"S.1499746282749.1100157028.88023.1.1|0|1|#127.0.0.1:8080|#testOperationName"}, new Class[] {String.class}, null);
+        stopSpan();
+
+        TraceSegment tracingSegment = assertTraceSemgnets();
+        List<AbstractTracingSpan> spans = SegmentHelper.getSpans(tracingSegment);
+        assertNull(tracingSegment.getRefs());
+        assertSpanCommonsAttribute(spans.get(0));
+    }
+
+    @Test
+    public void testContinuation() throws Throwable {
+        startSpan();
+        final MockEnhancedInstance continuationHolder = new MockEnhancedInstance();
+        constructorInterceptor.onConstruct(continuationHolder, null);
+        assertTrue(continuationHolder.getSkyWalkingDynamicField() instanceof ContextSnapshot);
+        new Thread() {
+            @Override public void run() {
+                MockEnhancedInstance enhancedInstance = new MockEnhancedInstance();
+                try {
+                    startSpan(enhancedInstance);
+                    activateInterceptor.afterMethod(continuationHolder, "activate", null, null, null);
+                } catch (Throwable throwable) {
+                    throwable.printStackTrace();
+                } finally {
+                    try {
+                        stopSpan(enhancedInstance);
+                    } catch (Throwable throwable) {
+                        throwable.printStackTrace();
+                    }
+                }
+            }
+        }.start();
+        Thread.sleep(1000L);
+        stopSpan();
+
+        List<TraceSegment> segments = storage.getTraceSegments();
+        assertThat(segments.size(), is(2));
+        TraceSegment traceSegment = segments.get(0);
+        assertThat(traceSegment.getRefs().size(), is(1));
+
+        traceSegment = segments.get(1);
+        assertNull(traceSegment.getRefs());
+    }
+
+    private void assertSpanCommonsAttribute(AbstractTracingSpan span) {
+        assertThat(span.getOperationName(), is("testOperationName"));
+        assertComponent(span, "test");
+        assertLogSize(span, 1);
+    }
+
+    private void stopSpan() throws Throwable {
+        stopSpan(enhancedInstance);
+    }
+
+    private void stopSpan(EnhancedInstance enhancedInstance) throws Throwable {
+        spanFinishInterceptor.afterMethod(enhancedInstance, "finish", null, null, null);
+    }
+
+    private void startSpan() throws Throwable {
+        startSpan(enhancedInstance);
+    }
+
+    private void startSpan(MockEnhancedInstance enhancedInstance) throws Throwable {
+        constructorWithSpanBuilderInterceptor.onConstruct(enhancedInstance, new Object[] {spanBuilder});
+        spanLogInterceptor.afterMethod(enhancedInstance, "log", logArgument, logArgumentType, null);
+
+        setOperationNameInterceptor.afterMethod(enhancedInstance, "setOperationName",
+            setOperationNameArgument, setOperationNameArgumentType, null);
+    }
+
+    private class MockEnhancedInstance implements EnhancedInstance {
+        public Object object;
+
+        @Override public Object getSkyWalkingDynamicField() {
+            return object;
+        }
+
+        @Override public void setSkyWalkingDynamicField(Object value) {
+            this.object = value;
+        }
+    }
+
+    private class MockContinuationThread extends Thread {
+        @Override
+        public void run() {
+            super.run();
+        }
+    }
+}

apm-sniffer/apm-toolkit-activation/pom.xml

@@ -25,5 +25,10 @@
             <artifactId>apm-agent-core</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.skywalking</groupId>
+            <artifactId>apm-test-tools</artifactId>
+            <version>${project.version}</version>
+        </dependency>
     </dependencies>
 </project>