Draft: Experimental sdk-exporter-trace module

[iRevive]

This PR is built on top of #325. It's mostly for showcase purposes.

The module can be published for the native platform.

The supported exporters:

• http/json
• http/protobuf

Here is the demo:

//> using scala 2.13.11
//> using lib "co.fs2::fs2-io::3.10-4b5f50b"
//> using lib "com.armanbilge::epollcat::0.1.6"
//> using lib "org.typelevel::otel4s-sdk-trace::0.3-f4e1e7f-20231003T171450Z-SNAPSHOT"
//> using lib "org.typelevel::otel4s-sdk-exporter-trace::0.3-f4e1e7f-20231003T171450Z-SNAPSHOT"

import cats.effect._
import cats.effect.std.Console
import cats.effect.std.Random
import cats.syntax.all._
import org.typelevel.otel4s.Attribute
import org.typelevel.otel4s.sdk.{Resource => InstrumentationResource}
import org.typelevel.otel4s.sdk.Attributes
import org.typelevel.otel4s.sdk.context.Context
import org.typelevel.otel4s.sdk.exporter.otlp.OtlpHttpSpanExporter
import org.typelevel.otel4s.sdk.instances._
import org.typelevel.otel4s.sdk.trace.SdkTracerProvider
import org.typelevel.otel4s.sdk.trace.exporter.BatchSpanProcessor
import org.typelevel.otel4s.sdk.trace.exporter.SpanExporter
import org.typelevel.otel4s.trace.Tracer

import scala.concurrent.duration._

trait Work[F[_]] {
  def doWork: F[Unit]
}

object Work {
  def apply[F[_] : Async : Tracer : Console]: Work[F] =
    new Work[F] {
      def doWork: F[Unit] =
        Tracer[F].span("Work.DoWork").use { span =>
          span.addEvent("Starting the work.") *>
            doWorkInternal(steps = 10) *>
            span.addEvent("Finished working.")
        }

      def doWorkInternal(steps: Int): F[Unit] = {
        val step = Tracer[F]
          .span("internal", Attribute("steps", steps.toLong))
          .surround {
            for {
              random <- Random.scalaUtilRandom
              delay <- random.nextIntBounded(1000)
              _ <- Async[F].sleep(delay.millis)
              _ <- Console[F].println("Doin' work")
            } yield ()
          }

        if (steps > 0) step *> doWorkInternal(steps - 1) else step
      }
    }
}

object TracingExample extends IOApp.Simple {

  def tracer: Resource[IO, Tracer[IO]] =
    Resource.eval(IOLocal(Context.root)).flatMap { implicit local =>
      OtlpHttpSpanExporter.builder[IO].build.flatMap { exporter =>
        BatchSpanProcessor.builder[IO](exporter).build.evalMap { processor =>
          Random.scalaUtilRandom[IO].flatMap { implicit random: Random[IO] =>
            val tracerProvider = SdkTracerProvider
              .builder[IO]
              .addResource(InstrumentationResource(Attributes(Attribute("service.name", "sdk-exporter-native.scala"))))
              .addSpanProcessor(processor)
              .build

            tracerProvider.get("my-tracer")
          }
        }
      }
    }

  def run: IO[Unit] =
    tracer.use { implicit tracer: Tracer[IO] =>
      Work[IO].doWork
    }
}

Run (you should have s2n-tls installed):

$  scala-cli run --platform native --native-version 0.4.15 sdk-exporter-native.scala 

Spans exported to Jaeger:

[iRevive]

Closing in favor of #421.