Add method to run code with activated span for interop with Java libraries

Author: mwisnicki

modules/core/shared/src/main/scala/Span.scala

@@ -51,6 +51,15 @@ trait Span[F[_]] {
     */
   def traceUri: F[Option[URI]]
 
+  /** Run impure code with the span of underlying tracing backend activated on the current thread
+    *  for the duration of the call.
+    *
+    * This is useful when calling into Java or other non-cats-effect code that is instrumented by the tracing backend.
+    *
+    * This should always be wrapped in `Sync.suspend` or equivalent.
+    */
+  def unsafeRunWithActivatedSpan[T](run: => T): T = run
+
   /** Converts this `Span[F]` to a `Span[G]` using a `F ~> G`. */
   def mapK[G[_]](f: F ~> G)(implicit
       F: MonadCancel[F, _],

modules/datadog/src/main/scala/DDSpan.scala

@@ -112,4 +112,10 @@ final case class DDSpan[F[_]: Sync](
           ) ++ fields.toList.nested.map(_.value).value.toMap).asJava
         )
       }.void
+
+  override def unsafeRunWithActivatedSpan[T](run: => T): T = {
+    val scope = tracer.activateSpan(span)
+    try run
+    finally scope.close()
+  }
 }

modules/jaeger/src/main/scala/JaegerSpan.scala

@@ -100,6 +100,12 @@ private[jaeger] final case class JaegerSpan[F[_]: Sync](
     (Nested(prefix.pure[F]), Nested(traceId)).mapN { (uri, id) =>
       uri.resolve(s"/trace/$id")
     }.value
+
+  override def unsafeRunWithActivatedSpan[T](run: => T): T = {
+    val scope = tracer.activateSpan(span)
+    try run
+    finally scope.close()
+  }
 }
 
 private[jaeger] object JaegerSpan {

modules/lightstep/src/main/scala/LightstepSpan.scala

@@ -96,4 +96,10 @@ private[lightstep] final case class LightstepSpan[F[_]: Sync](
 
   // TODO
   def traceUri: F[Option[URI]] = none.pure[F]
+
+  override def unsafeRunWithActivatedSpan[T](run: => T): T = {
+    val scope = tracer.activateSpan(span)
+    try run
+    finally scope.close()
+  }
 }

modules/opencensus/src/main/scala/OpenCensusSpan.scala

@@ -95,6 +95,12 @@ private[opencensus] final case class OpenCensusSpan[F[_]: Sync](
         ("error.class" -> TraceValue.StringValue(err.getClass.getSimpleName)) ::
         fields.toList: _*
     )
+
+  override def unsafeRunWithActivatedSpan[T](run: => T): T = {
+    val scope = tracer.withSpan(span)
+    try run
+    finally scope.close()
+  }
 }
 
 private[opencensus] object OpenCensusSpan {

modules/opentelemetry/src/main/scala/natchez/opentelemetry/OpenTelemetrySpan.scala

@@ -131,6 +131,12 @@ private[opentelemetry] final case class OpenTelemetrySpan[F[_]: Sync](
     (Nested(prefix.pure[F]), Nested(traceId)).mapN { (uri, id) =>
       uri.resolve(s"/trace/$id")
     }.value
+
+  override def unsafeRunWithActivatedSpan[T](run: => T): T = {
+    val scope = span.makeCurrent()
+    try run
+    finally scope.close()
+  }
 }
 
 private[opentelemetry] object OpenTelemetrySpan {