wsargent/opentelemetry-with-scala-futures

sbt runProd

sbt test

val span = tracer.spanBuilder("operationInvolvingSpan").startSpan()
try {
  operationInvolvingSpan(span)
} finally {
  span.end()
}

implicit val span: Span = tracer.spanBuilder(spanName).startSpan()
val f: Future[Foo] = operationInvolvingFuture(span)
f.onComplete {
    case Success(_) =>
      span.end()
    case Failure(e) =>
      span.recordException(e)
      span.setStatus(StatusCode.ERROR)
      span.end()
}(ExecutionContext.global)
f

val scope: Scope = span.makeCurrent

val scope = span.makeCurrent
try {
  // activeSpan should equal span!
  val activeSpan = Span.current
  operationInvolvingSpan(span)
} finally {
  scope.close
  // after this point Span.current does not equal span 
}

val scope = parentSpan.makeCurrent
try {
  // parentSpan is parent of childSpan because it is accessible via thread-local
  val childSpan: Span = tracer.spanBuilder("getCurrentTime").startSpan()
  try {
    operationInvolvingSpan(childSpan)
  } finally {
    childSpan.end
  }
} finally {
  scope.close
}

-Dio.opentelemetry.javaagent.shaded.io.opentelemetry.context.enableStrictContext=true

@Singleton
class MyService {

  def getCurrentTime: Long = {
    val span = Span.current()
    if (span.getSpanContext == SpanContext.getInvalid) {
      throw new IllegalStateException("getCurrentTime: no active span!")
    }

    // On shutdown, threads will still be active but will get non-writable spans :-(
    val result = System.currentTimeMillis()
    if (span.isRecording) {
      val attributes = Attributes.of[java.lang.Long](resultKey, result)
      span.addEvent("getCurrentTime", attributes)
    } else {
      logger.warn("getCurrentTime: span is read only! {}", span)
    }
    logger.debug("getCurrentTime: {}", "result" -> result)
    result
  }
}

class MyServiceSpec extends PlaySpec with Matchers with GuiceOneServerPerSuite with Injecting with ScalaFutures with TryValues {
  private val tracer = GlobalOpenTelemetry.getTracer("application")

  "MyService" must {
    "fail with getCurrentTime without an active span" in {
      val myService = inject[MyService]
      Try(myService.getCurrentTime).failure.exception mustBe an[IllegalStateException]
    }

    "work with getCurrentTime with an active span" in {
      val myService = inject[MyService]
      val span = tracer.spanBuilder("getCurrentTime").startSpan()
      val scope = span.makeCurrent()
      try {
        myService.getCurrentTime
      } finally {
        span.end()
        scope.close()
      }
    }
  }
}

@Singleton
class MyService @Inject()(implicit ec: ExecutionContext) {
  // ...
  
  def futureCurrentTime: Future[Long] = {
    Future {
      getCurrentTime
    }(ec)
  }
}

class MyServiceSpec {
  // ...
  "fail with futureCurrentTime if a span is not active" in {
    val myService = inject[MyService]
    myService.futureCurrentTime.failed.futureValue mustBe an[IllegalStateException]
  }

  "work with futureCurrentTime with an active span" in {
    val myService = inject[MyService]
    val span = tracer.spanBuilder("futureCurrentTime").startSpan()
    val scope = span.makeCurrent()
    whenReady(myService.futureCurrentTime) {
      scope.close()
      span.end()
      _ > 0 mustBe true
    }
  }
}

class RequestScopeFilter @Inject()(tracer: Tracer, requestScope: RequestScope, injector: Injector) extends EssentialFilter with Logging {

  override def apply(next: EssentialAction): EssentialAction = { rh =>
    val requestId = requireNonNull(rh.id.toString)
    val baggage = Baggage.builder().put("request_id", requestId).build()
    val baggageScope = baggage.storeInContext(Context.current()).makeCurrent

    // Seed the scope with the current request
    requestScope.seed(Key.get(classOf[RequestHeader]), rh)

    implicit val ec: ExecutionContext = ExecutionContext.parasitic
    next(rh).map { result =>
      requestScope.cleanupRequest(requestId)
      baggageScope.close()
      result
    }.recover {
      case e: Exception =>
        requestScope.cleanupRequest(requestId)
        baggageScope.close()
        throw e
    }
  }
}

class RequestLookup @Inject()(requestScope: RequestScope) {
  // Retrieve the current request from the RequestScope
  def request: RequestHeader = {
    requestScope.get(Key.get(classOf[RequestHeader]))
  }
}