From 6ba7487204e0339437c7279e6330fc03419a2c5c Mon Sep 17 00:00:00 2001 From: Ivan Topolnjak Date: Sat, 23 Nov 2013 21:30:34 -0300 Subject: Put FutureTracing instrumentation in place, simpler and more explicit test --- kamon-trace/src/main/resources/META-INF/aop.xml | 13 ++++ kamon-trace/src/main/scala/kamon/trace/Trace.scala | 2 + .../trace/instrumentation/FutureTracing.scala | 40 ++++++++++ .../trace/instrumentation/RunnableTracing.scala | 46 ------------ .../src/test/scala/kamon/FutureTracingSpec.scala | 56 ++++++++++++++ .../scala/kamon/RunnableInstrumentationSpec.scala | 85 ---------------------- 6 files changed, 111 insertions(+), 131 deletions(-) create mode 100644 kamon-trace/src/main/resources/META-INF/aop.xml create mode 100644 kamon-trace/src/main/scala/kamon/trace/instrumentation/FutureTracing.scala delete mode 100644 kamon-trace/src/main/scala/kamon/trace/instrumentation/RunnableTracing.scala create mode 100644 kamon-trace/src/test/scala/kamon/FutureTracingSpec.scala delete mode 100644 kamon-trace/src/test/scala/kamon/RunnableInstrumentationSpec.scala (limited to 'kamon-trace') diff --git a/kamon-trace/src/main/resources/META-INF/aop.xml b/kamon-trace/src/main/resources/META-INF/aop.xml new file mode 100644 index 00000000..fdc1c496 --- /dev/null +++ b/kamon-trace/src/main/resources/META-INF/aop.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/kamon-trace/src/main/scala/kamon/trace/Trace.scala b/kamon-trace/src/main/scala/kamon/trace/Trace.scala index 0ef438d4..fbd4ea8b 100644 --- a/kamon-trace/src/main/scala/kamon/trace/Trace.scala +++ b/kamon-trace/src/main/scala/kamon/trace/Trace.scala @@ -35,6 +35,8 @@ object Trace extends ExtensionId[TraceExtension] with ExtensionIdProvider { ctx } + def withValue[T](ctx: Option[TraceContext])(thunk: => T): T = traceContext.withValue(ctx)(thunk) + def transformContext(f: TraceContext => TraceContext): Unit = { context.map(f).foreach(set(_)) } diff --git a/kamon-trace/src/main/scala/kamon/trace/instrumentation/FutureTracing.scala b/kamon-trace/src/main/scala/kamon/trace/instrumentation/FutureTracing.scala new file mode 100644 index 00000000..10daa2da --- /dev/null +++ b/kamon-trace/src/main/scala/kamon/trace/instrumentation/FutureTracing.scala @@ -0,0 +1,40 @@ +package kamon.trace.instrumentation + +import org.aspectj.lang.annotation._ +import org.aspectj.lang.ProceedingJoinPoint +import kamon.trace.{ContextAware, TraceContext, Trace} + +@Aspect +class FutureTracing { + + /** + * These are the Runnables that need to be instrumented and make the TraceContext available + * while their run method is executed. + */ + @DeclareMixin("scala.concurrent.impl.CallbackRunnable || scala.concurrent.impl.Future.PromiseCompletingRunnable") + def onCompleteCallbacksRunnable: ContextAware = ContextAware.default + + + @Pointcut("execution(kamon.trace.ContextAware+.new(..)) && this(runnable)") + def instrumentedRunnableCreation(runnable: ContextAware): Unit = {} + + @Pointcut("execution(* kamon.trace.ContextAware+.run()) && this(runnable)") + def futureRunnableExecution(runnable: ContextAware) = {} + + + @After("instrumentedRunnableCreation(runnable)") + def beforeCreation(runnable: ContextAware): Unit = { + // Force traceContext initialization. + runnable.traceContext + } + + @Around("futureRunnableExecution(runnable)") + def around(pjp: ProceedingJoinPoint, runnable: ContextAware): Any = { + import pjp._ + + Trace.withValue(runnable.traceContext) { + proceed() + } + } + +} \ No newline at end of file diff --git a/kamon-trace/src/main/scala/kamon/trace/instrumentation/RunnableTracing.scala b/kamon-trace/src/main/scala/kamon/trace/instrumentation/RunnableTracing.scala deleted file mode 100644 index 5c16a648..00000000 --- a/kamon-trace/src/main/scala/kamon/trace/instrumentation/RunnableTracing.scala +++ /dev/null @@ -1,46 +0,0 @@ -package kamon.trace.instrumentation - -import org.aspectj.lang.annotation._ -import org.aspectj.lang.ProceedingJoinPoint -import kamon.trace.{ContextAware, TraceContext, Trace} - -@Aspect -class RunnableTracing { - - /** - * These are the Runnables that need to be instrumented and make the TraceContext available - * while their run method is executed. - */ - @DeclareMixin("scala.concurrent.impl.CallbackRunnable || scala.concurrent.impl.Future.PromiseCompletingRunnable") - def onCompleteCallbacksRunnable: ContextAware = ContextAware.default - - - /** - * Pointcuts - */ - - @Pointcut("execution(kamon.trace.ContextAware+.new(..)) && this(runnable)") - def instrumentedRunnableCreation(runnable: ContextAware): Unit = {} - - @Pointcut("execution(* kamon.trace.ContextAware+.run()) && this(runnable)") - def runnableExecution(runnable: ContextAware) = {} - - - - @After("instrumentedRunnableCreation(runnable)") - def beforeCreation(runnable: ContextAware): Unit = { - // Force traceContext initialization. - runnable.traceContext - } - - - @Around("runnableExecution(runnable)") - def around(pjp: ProceedingJoinPoint, runnable: ContextAware): Any = { - import pjp._ - - Trace.traceContext.withValue(runnable.traceContext) { - proceed() - } - } - -} \ No newline at end of file diff --git a/kamon-trace/src/test/scala/kamon/FutureTracingSpec.scala b/kamon-trace/src/test/scala/kamon/FutureTracingSpec.scala new file mode 100644 index 00000000..7ff1b96d --- /dev/null +++ b/kamon-trace/src/test/scala/kamon/FutureTracingSpec.scala @@ -0,0 +1,56 @@ +package kamon + +import scala.concurrent.{ExecutionContext, Await, Promise, Future} +import org.scalatest.{Matchers, OptionValues, WordSpec} +import org.scalatest.concurrent.{ScalaFutures, PatienceConfiguration} +import java.util.UUID +import scala.util.{Random, Success} +import scala.concurrent.duration._ +import java.util.concurrent.TimeUnit +import akka.actor.{Actor, ActorSystem} +import kamon.trace.{Trace, TraceContext} + + +class FutureTracingSpec extends WordSpec with Matchers with ScalaFutures with PatienceConfiguration with OptionValues { + + implicit val execContext = ExecutionContext.Implicits.global + + "a Future created with FutureTracing" should { + "capture the TraceContext available when created" which { + "must be available when executing the future's body" in new TraceContextFixture { + var future: Future[Option[TraceContext]] = _ + + Trace.withValue(testTraceContext) { + future = Future(Trace.context) + } + + whenReady(future)( ctxInFuture => + ctxInFuture should equal(testTraceContext) + ) + } + + "must be available when executing callbacks on the future" in new TraceContextFixture { + var future: Future[Option[TraceContext]] = _ + + Trace.withValue(testTraceContext) { + future = Future("Hello Kamon!") + // The TraceContext is expected to be available during all intermediate processing. + .map (_.length) + .flatMap(len => Future(len.toString)) + .map (s => Trace.context()) + } + + whenReady(future)( ctxInFuture => + ctxInFuture should equal(testTraceContext) + ) + } + } + } + + trait TraceContextFixture { + val random = new Random(System.nanoTime) + val testTraceContext = Some(TraceContext(Actor.noSender, random.nextInt)) + } +} + + diff --git a/kamon-trace/src/test/scala/kamon/RunnableInstrumentationSpec.scala b/kamon-trace/src/test/scala/kamon/RunnableInstrumentationSpec.scala deleted file mode 100644 index f968fa83..00000000 --- a/kamon-trace/src/test/scala/kamon/RunnableInstrumentationSpec.scala +++ /dev/null @@ -1,85 +0,0 @@ -package kamon - -import scala.concurrent.{Await, Promise, Future} -import org.scalatest.{Matchers, OptionValues, WordSpec} -import org.scalatest.concurrent.{ScalaFutures, PatienceConfiguration} -import java.util.UUID -import scala.util.Success -import scala.concurrent.duration._ -import java.util.concurrent.TimeUnit -import akka.actor.{Actor, ActorSystem} -import kamon.trace.{Trace, TraceContext} - - -class RunnableInstrumentationSpec extends WordSpec with Matchers with ScalaFutures with PatienceConfiguration with OptionValues { - - "a instrumented runnable" when { - "created in a thread that does have a TraceContext" must { - "preserve the TraceContext" which { - "should be available during the run method execution" in new FutureWithContextFixture { - -/* whenReady(futureWithContext) { result => - result.value should equal(testContext) - }*/ - } - - "should be available during the execution of onComplete callbacks" in new FutureWithContextFixture { - - val onCompleteContext = Promise[Option[TraceContext]]() - -/* Tracer.traceContext.withValue(Some(testContext)) { - futureWithContext.onComplete({ - case _ => println("Completing second promise from: "+Thread.currentThread().getName + " With Context: " + Tracer.traceContext.value); onCompleteContext.complete(Success(Tracer.traceContext.value)) - }) - }*/ - - whenReady(onCompleteContext.future) { result => - result should equal(Some(testContext)) - } - } - } - } - - "created in a thread that doest have a TraceContext" must { - "not capture any TraceContext for the body execution" in new FutureWithoutContextFixture{ - whenReady(futureWithoutContext) { result => - result should equal(None) - } - } - - "not make any TraceContext available during the onComplete callback" in new FutureWithoutContextFixture { - val onCompleteContext = Promise[Option[TraceContext]]() - - futureWithoutContext.onComplete { - case _ => onCompleteContext.complete(Success(Trace.context())) - } - - whenReady(onCompleteContext.future) { result => - result should equal(None) - } - } - } - } - - - /** - * We are using Futures for the test since they exercise Runnables in the back and also resemble the real use case we have. - */ - implicit val testActorSystem = ActorSystem("test-actorsystem") - implicit val execContext = testActorSystem.dispatcher - - class FutureWithContextFixture { - val testContext = TraceContext(Actor.noSender, 1) - -/* var futureWithContext: Future[Option[TraceContext]] = _ - Tracer.context.withValue(Some(testContext)) { - futureWithContext = Future { Tracer.traceContext.value } - }*/ - } - - trait FutureWithoutContextFixture { - val futureWithoutContext = Future { Trace.context.value } - } -} - - -- cgit v1.2.3