diff --git a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/CompletableInstrumentation.java b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/CompletableInstrumentation.java index 814d887a3ac..9c0610faed6 100644 --- a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/CompletableInstrumentation.java +++ b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/CompletableInstrumentation.java @@ -1,49 +1,28 @@ package datadog.trace.instrumentation.rxjava2; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.isConstructor; import static net.bytebuddy.matcher.ElementMatchers.isMethod; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; import static net.bytebuddy.matcher.ElementMatchers.takesArguments; -import com.google.auto.service.AutoService; +import datadog.context.Context; +import datadog.context.ContextScope; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.InstrumentationContext; -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.bootstrap.instrumentation.api.Java8BytecodeBridge; import io.reactivex.Completable; import io.reactivex.CompletableObserver; -import java.util.Map; import net.bytebuddy.asm.Advice; -@AutoService(InstrumenterModule.class) -public final class CompletableInstrumentation extends InstrumenterModule.Tracing +public final class CompletableInstrumentation implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public CompletableInstrumentation() { - super("rxjava"); - } @Override public String instrumentedType() { return "io.reactivex.Completable"; } - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".TracingCompletableObserver", - }; - } - - @Override - public Map contextStore() { - return singletonMap("io.reactivex.Completable", AgentSpan.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice(isConstructor(), getClass().getName() + "$CaptureParentSpanAdvice"); @@ -58,33 +37,34 @@ public void methodAdvice(MethodTransformer transformer) { public static class CaptureParentSpanAdvice { @Advice.OnMethodExit(suppress = Throwable.class) public static void onConstruct(@Advice.This final Completable completable) { - AgentSpan parentSpan = activeSpan(); - if (parentSpan != null) { - InstrumentationContext.get(Completable.class, AgentSpan.class).put(completable, parentSpan); + Context parentContext = Java8BytecodeBridge.getCurrentContext(); + if (parentContext != null && parentContext != Java8BytecodeBridge.getRootContext()) { + InstrumentationContext.get(Completable.class, Context.class) + .put(completable, parentContext); } } } public static class PropagateParentSpanAdvice { @Advice.OnMethodEnter(suppress = Throwable.class) - public static AgentScope onSubscribe( + public static ContextScope onSubscribe( @Advice.This final Completable completable, @Advice.Argument(value = 0, readOnly = false) CompletableObserver observer) { if (observer != null) { - AgentSpan parentSpan = - InstrumentationContext.get(Completable.class, AgentSpan.class).get(completable); - if (parentSpan != null) { + Context parentContext = + InstrumentationContext.get(Completable.class, Context.class).get(completable); + if (parentContext != null) { // wrap the observer so spans from its events treat the captured span as their parent - observer = new TracingCompletableObserver(observer, parentSpan); - // activate the span here in case additional observers are created during subscribe - return activateSpan(parentSpan); + observer = new TracingCompletableObserver(observer, parentContext); + // attach the context here in case additional observers are created during subscribe + return parentContext.attach(); } } return null; } @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) - public static void closeScope(@Advice.Enter final AgentScope scope) { + public static void closeScope(@Advice.Enter final ContextScope scope) { if (scope != null) { scope.close(); } diff --git a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/FlowableInstrumentation.java b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/FlowableInstrumentation.java index 3c74972a00d..97276c5b5af 100644 --- a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/FlowableInstrumentation.java +++ b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/FlowableInstrumentation.java @@ -1,49 +1,28 @@ package datadog.trace.instrumentation.rxjava2; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.isConstructor; import static net.bytebuddy.matcher.ElementMatchers.isMethod; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; import static net.bytebuddy.matcher.ElementMatchers.takesArguments; -import com.google.auto.service.AutoService; +import datadog.context.Context; +import datadog.context.ContextScope; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.InstrumentationContext; -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.bootstrap.instrumentation.api.Java8BytecodeBridge; import io.reactivex.Flowable; -import java.util.Map; import net.bytebuddy.asm.Advice; import org.reactivestreams.Subscriber; -@AutoService(InstrumenterModule.class) -public final class FlowableInstrumentation extends InstrumenterModule.Tracing +public final class FlowableInstrumentation implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public FlowableInstrumentation() { - super("rxjava"); - } @Override public String instrumentedType() { return "io.reactivex.Flowable"; } - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".TracingSubscriber", - }; - } - - @Override - public Map contextStore() { - return singletonMap("io.reactivex.Flowable", AgentSpan.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice(isConstructor(), getClass().getName() + "$CaptureParentSpanAdvice"); @@ -58,33 +37,33 @@ public void methodAdvice(MethodTransformer transformer) { public static class CaptureParentSpanAdvice { @Advice.OnMethodExit(suppress = Throwable.class) public static void onConstruct(@Advice.This final Flowable flowable) { - AgentSpan parentSpan = activeSpan(); - if (parentSpan != null) { - InstrumentationContext.get(Flowable.class, AgentSpan.class).put(flowable, parentSpan); + Context parentContext = Java8BytecodeBridge.getCurrentContext(); + if (parentContext != null && parentContext != Java8BytecodeBridge.getRootContext()) { + InstrumentationContext.get(Flowable.class, Context.class).put(flowable, parentContext); } } } public static class PropagateParentSpanAdvice { @Advice.OnMethodEnter(suppress = Throwable.class) - public static AgentScope onSubscribe( + public static ContextScope onSubscribe( @Advice.This final Flowable flowable, @Advice.Argument(value = 0, readOnly = false) Subscriber subscriber) { if (subscriber != null) { - AgentSpan parentSpan = - InstrumentationContext.get(Flowable.class, AgentSpan.class).get(flowable); - if (parentSpan != null) { + Context parentContext = + InstrumentationContext.get(Flowable.class, Context.class).get(flowable); + if (parentContext != null) { // wrap the subscriber so spans from its events treat the captured span as their parent - subscriber = new TracingSubscriber<>(subscriber, parentSpan); - // activate the span here in case additional subscribers are created during subscribe - return activateSpan(parentSpan); + subscriber = new TracingSubscriber<>(subscriber, parentContext); + // attach the context here in case additional subscribers are created during subscribe + return parentContext.attach(); } } return null; } @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) - public static void closeScope(@Advice.Enter final AgentScope scope) { + public static void closeScope(@Advice.Enter final ContextScope scope) { if (scope != null) { scope.close(); } diff --git a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/MaybeInstrumentation.java b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/MaybeInstrumentation.java index 23e1620736c..89ee0bf813c 100644 --- a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/MaybeInstrumentation.java +++ b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/MaybeInstrumentation.java @@ -1,49 +1,27 @@ package datadog.trace.instrumentation.rxjava2; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.isConstructor; import static net.bytebuddy.matcher.ElementMatchers.isMethod; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; import static net.bytebuddy.matcher.ElementMatchers.takesArguments; -import com.google.auto.service.AutoService; +import datadog.context.Context; +import datadog.context.ContextScope; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.InstrumentationContext; -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.bootstrap.instrumentation.api.Java8BytecodeBridge; import io.reactivex.Maybe; import io.reactivex.MaybeObserver; -import java.util.Map; import net.bytebuddy.asm.Advice; -@AutoService(InstrumenterModule.class) -public final class MaybeInstrumentation extends InstrumenterModule.Tracing +public final class MaybeInstrumentation implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public MaybeInstrumentation() { - super("rxjava"); - } - @Override public String instrumentedType() { return "io.reactivex.Maybe"; } - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".TracingMaybeObserver", - }; - } - - @Override - public Map contextStore() { - return singletonMap("io.reactivex.Maybe", AgentSpan.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice(isConstructor(), getClass().getName() + "$CaptureParentSpanAdvice"); @@ -58,32 +36,32 @@ public void methodAdvice(MethodTransformer transformer) { public static class CaptureParentSpanAdvice { @Advice.OnMethodExit(suppress = Throwable.class) public static void onConstruct(@Advice.This final Maybe maybe) { - AgentSpan parentSpan = activeSpan(); - if (parentSpan != null) { - InstrumentationContext.get(Maybe.class, AgentSpan.class).put(maybe, parentSpan); + Context parentContext = Java8BytecodeBridge.getCurrentContext(); + if (parentContext != null && parentContext != Java8BytecodeBridge.getRootContext()) { + InstrumentationContext.get(Maybe.class, Context.class).put(maybe, parentContext); } } } public static class PropagateParentSpanAdvice { @Advice.OnMethodEnter(suppress = Throwable.class) - public static AgentScope onSubscribe( + public static ContextScope onSubscribe( @Advice.This final Maybe maybe, @Advice.Argument(value = 0, readOnly = false) MaybeObserver observer) { if (observer != null) { - AgentSpan parentSpan = InstrumentationContext.get(Maybe.class, AgentSpan.class).get(maybe); - if (parentSpan != null) { + Context parentContext = InstrumentationContext.get(Maybe.class, Context.class).get(maybe); + if (parentContext != null) { // wrap the observer so spans from its events treat the captured span as their parent - observer = new TracingMaybeObserver<>(observer, parentSpan); - // activate the span here in case additional observers are created during subscribe - return activateSpan(parentSpan); + observer = new TracingMaybeObserver<>(observer, parentContext); + // attach the context here in case additional observers are created during subscribe + return parentContext.attach(); } } return null; } @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) - public static void closeScope(@Advice.Enter final AgentScope scope) { + public static void closeScope(@Advice.Enter final ContextScope scope) { if (scope != null) { scope.close(); } diff --git a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/ObservableInstrumentation.java b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/ObservableInstrumentation.java index 5b030eaba53..cfd51d9bb06 100644 --- a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/ObservableInstrumentation.java +++ b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/ObservableInstrumentation.java @@ -1,49 +1,27 @@ package datadog.trace.instrumentation.rxjava2; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.isConstructor; import static net.bytebuddy.matcher.ElementMatchers.isMethod; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; import static net.bytebuddy.matcher.ElementMatchers.takesArguments; -import com.google.auto.service.AutoService; +import datadog.context.Context; +import datadog.context.ContextScope; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.InstrumentationContext; -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.bootstrap.instrumentation.api.Java8BytecodeBridge; import io.reactivex.Observable; import io.reactivex.Observer; -import java.util.Map; import net.bytebuddy.asm.Advice; -@AutoService(InstrumenterModule.class) -public final class ObservableInstrumentation extends InstrumenterModule.Tracing +public final class ObservableInstrumentation implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public ObservableInstrumentation() { - super("rxjava"); - } - @Override public String instrumentedType() { return "io.reactivex.Observable"; } - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".TracingObserver", - }; - } - - @Override - public Map contextStore() { - return singletonMap("io.reactivex.Observable", AgentSpan.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice(isConstructor(), getClass().getName() + "$CaptureParentSpanAdvice"); @@ -58,33 +36,33 @@ public void methodAdvice(MethodTransformer transformer) { public static class CaptureParentSpanAdvice { @Advice.OnMethodExit(suppress = Throwable.class) public static void onConstruct(@Advice.This final Observable observable) { - AgentSpan parentSpan = activeSpan(); - if (parentSpan != null) { - InstrumentationContext.get(Observable.class, AgentSpan.class).put(observable, parentSpan); + Context parentContext = Java8BytecodeBridge.getCurrentContext(); + if (parentContext != null) { + InstrumentationContext.get(Observable.class, Context.class).put(observable, parentContext); } } } public static class PropagateParentSpanAdvice { @Advice.OnMethodEnter(suppress = Throwable.class) - public static AgentScope onSubscribe( + public static ContextScope onSubscribe( @Advice.This final Observable observable, @Advice.Argument(value = 0, readOnly = false) Observer observer) { if (observer != null) { - AgentSpan parentSpan = - InstrumentationContext.get(Observable.class, AgentSpan.class).get(observable); - if (parentSpan != null) { + Context parentContext = + InstrumentationContext.get(Observable.class, Context.class).get(observable); + if (parentContext != null && parentContext != Java8BytecodeBridge.getRootContext()) { // wrap the observer so spans from its events treat the captured span as their parent - observer = new TracingObserver<>(observer, parentSpan); - // activate the span here in case additional observers are created during subscribe - return activateSpan(parentSpan); + observer = new TracingObserver<>(observer, parentContext); + // attach the context here in case additional observers are created during subscribe + return parentContext.attach(); } } return null; } @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) - public static void closeScope(@Advice.Enter final AgentScope scope) { + public static void closeScope(@Advice.Enter final ContextScope scope) { if (scope != null) { scope.close(); } diff --git a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/RxJavaModule.java b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/RxJavaModule.java new file mode 100644 index 00000000000..67519304f8e --- /dev/null +++ b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/RxJavaModule.java @@ -0,0 +1,51 @@ +package datadog.trace.instrumentation.rxjava2; + +import static java.util.Arrays.asList; + +import com.google.auto.service.AutoService; +import datadog.context.Context; +import datadog.trace.agent.tooling.Instrumenter; +import datadog.trace.agent.tooling.InstrumenterModule; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@AutoService(InstrumenterModule.class) +public final class RxJavaModule extends InstrumenterModule.ContextTracking { + public RxJavaModule() { + super("rxjava"); + } + + @Override + public String[] helperClassNames() { + return new String[] { + packageName + ".TracingCompletableObserver", + packageName + ".TracingSubscriber", + packageName + ".TracingMaybeObserver", + packageName + ".TracingObserver", + packageName + ".RxJavaAsyncResultExtension", + packageName + ".TracingSingleObserver", + }; + } + + @Override + public Map contextStore() { + final Map store = new HashMap<>(); + store.put("io.reactivex.Flowable", Context.class.getName()); + store.put("io.reactivex.Completable", Context.class.getName()); + store.put("io.reactivex.Maybe", Context.class.getName()); + store.put("io.reactivex.Observable", Context.class.getName()); + store.put("io.reactivex.Single", Context.class.getName()); + return store; + } + + @Override + public List typeInstrumentations() { + return asList( + new CompletableInstrumentation(), + new FlowableInstrumentation(), + new MaybeInstrumentation(), + new ObservableInstrumentation(), + new SingleInstrumentation()); + } +} diff --git a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/RxJavaPluginsInstrumentation.java b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/RxJavaPluginsInstrumentation.java deleted file mode 100644 index 0f88b5246f3..00000000000 --- a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/RxJavaPluginsInstrumentation.java +++ /dev/null @@ -1,33 +0,0 @@ -package datadog.trace.instrumentation.rxjava2; - -import com.google.auto.service.AutoService; -import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; -import datadog.trace.api.InstrumenterConfig; - -@AutoService(InstrumenterModule.class) -public class RxJavaPluginsInstrumentation extends InstrumenterModule.Tracing - implements Instrumenter.ForSingleType { - - public RxJavaPluginsInstrumentation() { - super("rxjava"); - } - - @Override - protected boolean defaultEnabled() { - // Only used with OpenTelemetry @WithSpan annotations - return InstrumenterConfig.get().isTraceOtelEnabled(); - } - - @Override - public String instrumentedType() { - return "io.reactivex.plugins.RxJavaPlugins"; - } - - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".RxJavaAsyncResultExtension", - }; - } -} diff --git a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/SingleInstrumentation.java b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/SingleInstrumentation.java index f465a4c9866..98d214606bb 100644 --- a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/SingleInstrumentation.java +++ b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/SingleInstrumentation.java @@ -1,49 +1,28 @@ package datadog.trace.instrumentation.rxjava2; import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan; -import static java.util.Collections.singletonMap; import static net.bytebuddy.matcher.ElementMatchers.isConstructor; import static net.bytebuddy.matcher.ElementMatchers.isMethod; import static net.bytebuddy.matcher.ElementMatchers.takesArgument; import static net.bytebuddy.matcher.ElementMatchers.takesArguments; -import com.google.auto.service.AutoService; +import datadog.context.Context; +import datadog.context.ContextScope; import datadog.trace.agent.tooling.Instrumenter; -import datadog.trace.agent.tooling.InstrumenterModule; import datadog.trace.bootstrap.InstrumentationContext; -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.trace.bootstrap.instrumentation.api.Java8BytecodeBridge; import io.reactivex.Single; import io.reactivex.SingleObserver; -import java.util.Map; import net.bytebuddy.asm.Advice; -@AutoService(InstrumenterModule.class) -public final class SingleInstrumentation extends InstrumenterModule.Tracing +public final class SingleInstrumentation implements Instrumenter.ForSingleType, Instrumenter.HasMethodAdvice { - public SingleInstrumentation() { - super("rxjava"); - } @Override public String instrumentedType() { return "io.reactivex.Single"; } - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".TracingSingleObserver", - }; - } - - @Override - public Map contextStore() { - return singletonMap("io.reactivex.Single", AgentSpan.class.getName()); - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice(isConstructor(), getClass().getName() + "$CaptureParentSpanAdvice"); @@ -58,33 +37,32 @@ public void methodAdvice(MethodTransformer transformer) { public static class CaptureParentSpanAdvice { @Advice.OnMethodExit(suppress = Throwable.class) public static void onConstruct(@Advice.This final Single single) { - AgentSpan parentSpan = activeSpan(); - if (parentSpan != null) { - InstrumentationContext.get(Single.class, AgentSpan.class).put(single, parentSpan); + Context parentContext = Java8BytecodeBridge.getCurrentContext(); + if (parentContext != null) { + InstrumentationContext.get(Single.class, Context.class).put(single, parentContext); } } } public static class PropagateParentSpanAdvice { @Advice.OnMethodEnter(suppress = Throwable.class) - public static AgentScope onSubscribe( + public static ContextScope onSubscribe( @Advice.This final Single single, @Advice.Argument(value = 0, readOnly = false) SingleObserver observer) { if (observer != null) { - AgentSpan parentSpan = - InstrumentationContext.get(Single.class, AgentSpan.class).get(single); - if (parentSpan != null) { + Context parentContext = InstrumentationContext.get(Single.class, Context.class).get(single); + if (parentContext != null && parentContext != Java8BytecodeBridge.getRootContext()) { // wrap the observer so spans from its events treat the captured span as their parent - observer = new TracingSingleObserver<>(observer, parentSpan); - // activate the span here in case additional observers are created during subscribe - return activateSpan(parentSpan); + observer = new TracingSingleObserver<>(observer, parentContext); + // attach the context here in case additional observers are created during subscribe + return parentContext.attach(); } } return null; } @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) - public static void closeScope(@Advice.Enter final AgentScope scope) { + public static void closeScope(@Advice.Enter final ContextScope scope) { if (scope != null) { scope.close(); } diff --git a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingCompletableObserver.java b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingCompletableObserver.java index c6ed06f5d5a..955994ed4cc 100644 --- a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingCompletableObserver.java +++ b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingCompletableObserver.java @@ -1,21 +1,20 @@ package datadog.trace.instrumentation.rxjava2; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; - -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.context.Context; +import datadog.context.ContextScope; import io.reactivex.CompletableObserver; import io.reactivex.disposables.Disposable; +import javax.annotation.Nonnull; /** Wrapper that makes sure spans from observer events treat the captured span as their parent. */ public final class TracingCompletableObserver implements CompletableObserver { private final CompletableObserver observer; - private final AgentSpan parentSpan; + private final Context parentContext; public TracingCompletableObserver( - final CompletableObserver observer, final AgentSpan parentSpan) { + @Nonnull final CompletableObserver observer, @Nonnull final Context parentContext) { this.observer = observer; - this.parentSpan = parentSpan; + this.parentContext = parentContext; } @Override @@ -25,14 +24,14 @@ public void onSubscribe(final Disposable d) { @Override public void onError(final Throwable e) { - try (final AgentScope scope = activateSpan(parentSpan)) { + try (final ContextScope scope = parentContext.attach()) { observer.onError(e); } } @Override public void onComplete() { - try (final AgentScope scope = activateSpan(parentSpan)) { + try (final ContextScope scope = parentContext.attach()) { observer.onComplete(); } } diff --git a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingMaybeObserver.java b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingMaybeObserver.java index fe643296f71..c82d8690189 100644 --- a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingMaybeObserver.java +++ b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingMaybeObserver.java @@ -1,20 +1,20 @@ package datadog.trace.instrumentation.rxjava2; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; - -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.context.Context; +import datadog.context.ContextScope; import io.reactivex.MaybeObserver; import io.reactivex.disposables.Disposable; +import javax.annotation.Nonnull; /** Wrapper that makes sure spans from observer events treat the captured span as their parent. */ public final class TracingMaybeObserver implements MaybeObserver { private final MaybeObserver observer; - private final AgentSpan parentSpan; + private final Context parentContext; - public TracingMaybeObserver(final MaybeObserver observer, final AgentSpan parentSpan) { + public TracingMaybeObserver( + @Nonnull final MaybeObserver observer, @Nonnull final Context parentContext) { this.observer = observer; - this.parentSpan = parentSpan; + this.parentContext = parentContext; } @Override @@ -24,21 +24,21 @@ public void onSubscribe(final Disposable d) { @Override public void onSuccess(final T value) { - try (final AgentScope scope = activateSpan(parentSpan)) { + try (final ContextScope scope = parentContext.attach()) { observer.onSuccess(value); } } @Override public void onError(final Throwable e) { - try (final AgentScope scope = activateSpan(parentSpan)) { + try (final ContextScope scope = parentContext.attach()) { observer.onError(e); } } @Override public void onComplete() { - try (final AgentScope scope = activateSpan(parentSpan)) { + try (final ContextScope scope = parentContext.attach()) { observer.onComplete(); } } diff --git a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingObserver.java b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingObserver.java index ec684c10574..864191ac2d9 100644 --- a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingObserver.java +++ b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingObserver.java @@ -1,20 +1,18 @@ package datadog.trace.instrumentation.rxjava2; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; - -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.context.Context; +import datadog.context.ContextScope; import io.reactivex.Observer; import io.reactivex.disposables.Disposable; /** Wrapper that makes sure spans from observer events treat the captured span as their parent. */ public final class TracingObserver implements Observer { private final Observer observer; - private final AgentSpan parentSpan; + private final Context parentContext; - public TracingObserver(final Observer observer, final AgentSpan parentSpan) { + public TracingObserver(final Observer observer, final Context parentContext) { this.observer = observer; - this.parentSpan = parentSpan; + this.parentContext = parentContext; } @Override @@ -24,21 +22,21 @@ public void onSubscribe(final Disposable d) { @Override public void onNext(final T value) { - try (final AgentScope scope = activateSpan(parentSpan)) { + try (final ContextScope scope = parentContext.attach()) { observer.onNext(value); } } @Override public void onError(final Throwable e) { - try (final AgentScope scope = activateSpan(parentSpan)) { + try (final ContextScope scope = parentContext.attach()) { observer.onError(e); } } @Override public void onComplete() { - try (final AgentScope scope = activateSpan(parentSpan)) { + try (final ContextScope scope = parentContext.attach()) { observer.onComplete(); } } diff --git a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingSingleObserver.java b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingSingleObserver.java index b70b8f628d0..386e1d6fd0b 100644 --- a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingSingleObserver.java +++ b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingSingleObserver.java @@ -1,20 +1,20 @@ package datadog.trace.instrumentation.rxjava2; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; - -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.context.Context; +import datadog.context.ContextScope; import io.reactivex.SingleObserver; import io.reactivex.disposables.Disposable; +import javax.annotation.Nonnull; /** Wrapper that makes sure spans from observer events treat the captured span as their parent. */ public final class TracingSingleObserver implements SingleObserver { private final SingleObserver observer; - private final AgentSpan parentSpan; + private final Context parentContext; - public TracingSingleObserver(final SingleObserver observer, final AgentSpan parentSpan) { + public TracingSingleObserver( + @Nonnull final SingleObserver observer, @Nonnull final Context parentContext) { this.observer = observer; - this.parentSpan = parentSpan; + this.parentContext = parentContext; } @Override @@ -24,14 +24,14 @@ public void onSubscribe(final Disposable d) { @Override public void onSuccess(final T value) { - try (final AgentScope scope = activateSpan(parentSpan)) { + try (final ContextScope scope = parentContext.attach()) { observer.onSuccess(value); } } @Override public void onError(final Throwable e) { - try (final AgentScope scope = activateSpan(parentSpan)) { + try (final ContextScope scope = parentContext.attach()) { observer.onError(e); } } diff --git a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingSubscriber.java b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingSubscriber.java index 325c1059ff2..b38addfcdcb 100644 --- a/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingSubscriber.java +++ b/dd-java-agent/instrumentation/rxjava/rxjava-2.0/src/main/java/datadog/trace/instrumentation/rxjava2/TracingSubscriber.java @@ -1,20 +1,20 @@ package datadog.trace.instrumentation.rxjava2; -import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activateSpan; - -import datadog.trace.bootstrap.instrumentation.api.AgentScope; -import datadog.trace.bootstrap.instrumentation.api.AgentSpan; +import datadog.context.Context; +import datadog.context.ContextScope; +import javax.annotation.Nonnull; import org.reactivestreams.Subscriber; import org.reactivestreams.Subscription; /** Wrapper that makes sure spans from subscriber events treat the captured span as their parent. */ public final class TracingSubscriber implements Subscriber { private final Subscriber subscriber; - private final AgentSpan parentSpan; + private final Context parentContext; - public TracingSubscriber(final Subscriber subscriber, final AgentSpan parentSpan) { + public TracingSubscriber( + @Nonnull final Subscriber subscriber, @Nonnull final Context parentContext) { this.subscriber = subscriber; - this.parentSpan = parentSpan; + this.parentContext = parentContext; } @Override @@ -24,21 +24,21 @@ public void onSubscribe(final Subscription subscription) { @Override public void onNext(final T value) { - try (final AgentScope scope = activateSpan(parentSpan)) { + try (final ContextScope scope = parentContext.attach()) { subscriber.onNext(value); } } @Override public void onError(final Throwable e) { - try (final AgentScope scope = activateSpan(parentSpan)) { + try (final ContextScope scope = parentContext.attach()) { subscriber.onError(e); } } @Override public void onComplete() { - try (final AgentScope scope = activateSpan(parentSpan)) { + try (final ContextScope scope = parentContext.attach()) { subscriber.onComplete(); } }