Allow direct access to trace and span id for zio-logging's LogFormat

README.md

@@ -32,6 +32,12 @@ In order to use this library, we need to add the following line in our `build.sb
 libraryDependencies += "dev.zio" %% "zio-opentelemetry" % "<version>"
 ```
 
+If you're also using [ZIO Logging](https://github.com/zio/zio-logging) you can combine OpenTelemetry with ZIO Logging using:
+
+```scala
+libraryDependencies += "dev.zio" %% "zio-opentelemetry-zio-logging" % "<version>"
+```
+
 For using [OpenTracing](https://opentracing.io/) client we should add the following line in our `build.sbt` file:
 
 ```scala
@@ -49,6 +55,7 @@ libraryDependencies += "dev.zio" %% "zio-opencensus" % "<version>"
 You can find examples with full source code and instructions of how to run by following the links:
 - [OpenTelemetry Example](docs/opentelemetry-example.md)
 - [OpenTelemetry Instrumentation Example](docs/opentelemetry-instrumentation-example.md)
+- [OpenTelemetry ZIO Logging Example](docs/opentelemetry-zio-logging.md)
 - [OpenTracing Example](docs/opentracing-example.md)
 
 ## Articles

build.sbt

@@ -103,7 +103,7 @@ lazy val root =
   project
     .in(file("."))
     .settings(publish / skip := true)
-    .aggregate(opentracing, opentelemetry, opencensus, docs)
+    .aggregate(opentracing, opentelemetry, opencensus, opentelemetryZioLogging, docs)
 
 lazy val opentracing =
   project
@@ -146,6 +146,20 @@ lazy val opencensus = project
   .settings(mimaSettings(failOnProblem = true))
   .settings(unusedCompileDependenciesFilter -= moduleFilter("io.opencensus", "opencensus-impl"))
 
+lazy val opentelemetryZioLogging = project
+  .in(file("opentelemetry-zio-logging"))
+  .settings(enableZIO())
+  .settings(
+    stdModuleSettings(
+      name = Some("zio-opentelemetry-zio-logging"),
+      packageName = Some("zio.telemetry.opentelemetry.zio.logging")
+    )
+  )
+  .settings(libraryDependencies ++= Dependencies.opentelemetryZioLogging)
+  .settings(mimaSettings(failOnProblem = true))
+  .settings(missinglinkIgnoreDestinationPackages += IgnoredPackage("scala.reflect"))
+  .dependsOn(opentelemetry)
+
 lazy val opentracingExample =
   project
     .in(file("opentracing-example"))
@@ -194,9 +208,14 @@ lazy val docs =
       projectName                                := "ZIO Telemetry",
       mainModuleName                             := (opentracing / moduleName).value,
       projectStage                               := ProjectStage.ProductionReady,
-      ScalaUnidoc / unidoc / unidocProjectFilter := inProjects(opentracing, opentelemetry, opencensus),
+      ScalaUnidoc / unidoc / unidocProjectFilter := inProjects(
+        opentracing,
+        opentelemetry,
+        opencensus
+        //  opentelemetryZioLogging TODO: Causes some weird import issues
+      ),
       scalacOptions --= Seq("-Yno-imports", "-Xfatal-warnings")
     )
     .settings(unusedCompileDependenciesFilter -= moduleFilter("org.scalameta", "mdoc"))
-    .dependsOn(opentracing, opentelemetry, opencensus)
+    .dependsOn(opentracing, opentelemetry, opencensus, opentelemetryZioLogging)
     .enablePlugins(WebsitePlugin)

docs/index.md

@@ -32,6 +32,12 @@ In order to use this library, we need to add the following line in our `build.sb
 libraryDependencies += "dev.zio" %% "zio-opentelemetry" % "<version>"
 ```
 
+If you're using [ZIO Logging](https://github.com/zio/zio-logging) you can combine OpenTelemetry with ZIO Logging using:
+
+```scala
+libraryDependencies += "dev.zio" %% "zio-opentelemetry-zio-logging" % "<version>"
+```
+
 For using [OpenTracing](https://opentracing.io/) client we should add the following line in our `build.sbt` file:
 
 ```scala
@@ -49,6 +55,7 @@ libraryDependencies += "dev.zio" %% "zio-opencensus" % "<version>"
 You can find examples with full source code and instructions of how to run by following the links:
 - [OpenTelemetry Example](opentelemetry-example.md)
 - [OpenTelemetry Instrumentation Example](opentelemetry-instrumentation-example.md)
+- [OpenTelemetry ZIO Logging Example](opentelemetry-zio-logging.md)
 - [OpenTracing Example](opentracing-example.md)
 
 ## Articles

docs/opentelemetry-zio-logging.md

@@ -0,0 +1,144 @@
+---
+id: opentelemetry-zio-logging
+title: "OpenTelemetry ZIO Logging"
+---
+
+`zio-opentelemetry` logging facilities are implemented around OpenTelemetry Logging.
+
+In order to use `zio-opentelemetry` feature with `zio-logging` you should use `zio-opentelemetry-zio-logging` module.
+
+`OpenTelemetry ZIO Logging` contains utilities for combining ZIO Opentelemetry with ZIO Logging
+
+## Installation
+
+```scala
+"dev.zio" %% "zio-opentelemetry-zio-logging" % "<version>"
+```
+
+## Features
+
+### Log formats
+
+This library implements [Log Format](https://zio.dev/zio-logging/formatting-log-records) for span information (`spanId` and `traceId`). 
+To use them you need a `LogFormats` service in the environment. For this, use the `ZioLogging.logFormats` layer which in turn required a suitable `ContextStorage` implementation.
+
+```scala
+//> using scala "2.13.14"
+//> using dep dev.zio::zio:2.1.1
+//> using dep dev.zio::zio-opentelemetry:3.0.0-RC24
+//> using dep dev.zio::zio-opentelemetry-zio-logging:3.0.0-RC24
+//> using dep io.opentelemetry:opentelemetry-sdk:1.38.0
+//> using dep io.opentelemetry:opentelemetry-sdk-trace:1.38.0
+//> using dep io.opentelemetry:opentelemetry-exporter-logging-otlp:1.38.0
+//> using dep io.opentelemetry.semconv:opentelemetry-semconv:1.22.0-alpha
+
+import io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingSpanExporter
+import io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingLogRecordExporter
+import io.opentelemetry.api.common.Attributes
+import io.opentelemetry.sdk.trace.SdkTracerProvider
+import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor
+import io.opentelemetry.sdk.logs.SdkLoggerProvider
+import io.opentelemetry.sdk.logs.`export`.SimpleLogRecordProcessor
+import io.opentelemetry.sdk.resources.Resource
+import io.opentelemetry.semconv.ResourceAttributes
+import io.opentelemetry.sdk.OpenTelemetrySdk
+import io.opentelemetry.api
+import zio._
+import zio.logging.console
+import zio.logging.LogFormat._
+import zio.telemetry.opentelemetry.tracing.Tracing
+import zio.telemetry.opentelemetry.OpenTelemetry
+import zio.telemetry.opentelemetry.context.ContextStorage
+import zio.telemetry.opentelemetry.zio.logging.LogFormats
+import zio.telemetry.opentelemetry.zio.logging.ZioLogging
+
+object ZioLoggingApp extends ZIOAppDefault {
+
+  val instrumentationScopeName = "dev.zio.LoggingApp"
+  val resourceName             = "logging-app"
+
+  // Prints to stdout in OTLP Json format
+  val stdoutLoggerProvider: RIO[Scope, SdkLoggerProvider] =
+    for {
+      logRecordExporter  <- ZIO.fromAutoCloseable(ZIO.succeed(OtlpJsonLoggingLogRecordExporter.create()))
+      logRecordProcessor <- ZIO.fromAutoCloseable(ZIO.succeed(SimpleLogRecordProcessor.create(logRecordExporter)))
+      loggerProvider     <-
+        ZIO.fromAutoCloseable(
+          ZIO.succeed(
+            SdkLoggerProvider
+              .builder()
+              .setResource(Resource.create(Attributes.of(ResourceAttributes.SERVICE_NAME, resourceName)))
+              .addLogRecordProcessor(logRecordProcessor)
+              .build()
+          )
+        )
+    } yield loggerProvider
+
+  // Prints to stdout in OTLP Json format
+  val stdoutTracerProvider: RIO[Scope, SdkTracerProvider] =
+    for {
+      spanExporter   <- ZIO.fromAutoCloseable(ZIO.succeed(OtlpJsonLoggingSpanExporter.create()))
+      spanProcessor  <- ZIO.fromAutoCloseable(ZIO.succeed(SimpleSpanProcessor.create(spanExporter)))
+      tracerProvider <-
+        ZIO.fromAutoCloseable(
+          ZIO.succeed(
+            SdkTracerProvider
+              .builder()
+              .setResource(Resource.create(Attributes.of(ResourceAttributes.SERVICE_NAME, resourceName)))
+              .addSpanProcessor(spanProcessor)
+              .build()
+          )
+        )
+    } yield tracerProvider
+
+  val otelSdkLayer: TaskLayer[api.OpenTelemetry] =
+    OpenTelemetry.custom(
+      for {
+        tracerProvider <- stdoutTracerProvider
+        loggerProvider <- stdoutLoggerProvider
+        sdk            <- ZIO.fromAutoCloseable(
+          ZIO.succeed(
+            OpenTelemetrySdk
+              .builder()
+              .setTracerProvider(tracerProvider)
+              .setLoggerProvider(loggerProvider)
+              .build()
+          )
+        )
+      } yield sdk
+    )
+
+  // Setup zio-logging with spanId and traceId labels
+  val loggingLayer: URLayer[LogFormats, Unit] = ZLayer {
+    for {
+      logFormats <- ZIO.service[LogFormats]
+      format = timestamp.fixed(32) |-| level |-| label("message", quoted(line)) |-| logFormats.spanIdLabel |-| logFormats.traceIdLabel
+      myConsoleLogger = console(format.highlight)
+    } yield Runtime.removeDefaultLoggers >>> myConsoleLogger
+  }.flatten
+
+
+  override def run =
+    ZIO
+      .serviceWithZIO[Tracing] { tracing =>
+        val logic = for {
+          // Read user input
+          message <- Console.readLine
+          // Print span and trace ids along with message
+          _ <- ZIO.logInfo(s"User message: $message")
+        } yield ()
+
+        // All log messages produced by `logic` will be correlated with a "root_span" automatically
+        logic @@ tracing.aspects.root("root_span")
+      }
+      .provide(
+        otelSdkLayer,
+        OpenTelemetry.logging(instrumentationScopeName),
+        OpenTelemetry.tracing(instrumentationScopeName),
+        OpenTelemetry.contextZIO,
+        ZioLogging.logFormats,
+        loggingLayer
+      )
+
+}
+```

docs/sidebars.js

@@ -10,6 +10,7 @@ const sidebars = {
         "opentracing-example",
         "opencensus",
         "opentelemetry",
+        "opentelemetry-zio-logging",
         "opentelemetry-example",
         "opentelemetry-instrumentation-example"
       ]

opentelemetry-zio-logging/src/main/scala/zio/telemetry/opentelemetry/zio/logging/LogFormats.scala

@@ -0,0 +1,27 @@
+package zio.telemetry.opentelemetry.zio.logging
+
+import zio.logging.LogFormat
+import zio.logging.LogFormat.label
+
+trait LogFormats {
+
+  /**
+   * Will print traceId from current span or nothing when not in span
+   */
+  def traceId: LogFormat
+
+  /**
+   * Will print spanId from current span or nothing when not in span
+   */
+  def spanId: LogFormat
+
+  /**
+   * Label with `traceId` key and [[traceId]] value
+   */
+  def traceIdLabel: LogFormat = label("traceId", traceId)
+
+  /**
+   * Label with `spanId` key and [[spanId]] value
+   */
+  def spanIdLabel: LogFormat = label("spanId", spanId)
+}

opentelemetry-zio-logging/src/main/scala/zio/telemetry/opentelemetry/zio/logging/ZioLogging.scala

@@ -0,0 +1,36 @@
+package zio.telemetry.opentelemetry.zio.logging
+
+import io.opentelemetry.api.trace.{Span, SpanContext}
+import io.opentelemetry.context.Context
+import zio._
+import zio.logging.LogFormat
+import zio.telemetry.opentelemetry.context.ContextStorage
+
+object ZioLogging {
+
+  def logFormats: ZLayer[ContextStorage, Nothing, LogFormats] = ZLayer {
+    for {
+      ctxStorage <- ZIO.service[ContextStorage]
+    } yield new LogFormats {
+      override def traceId: LogFormat = LogFormat.make { (builder, _, _, _, _, _, fiberRefs, _, _) =>
+        getSpanContext(ctxStorage, fiberRefs).map(_.getTraceId).fold(())(builder.appendText(_))
+      }
+
+      override def spanId: LogFormat = LogFormat.make { (builder, _, _, _, _, _, fiberRefs, _, _) =>
+        getSpanContext(ctxStorage, fiberRefs).map(_.getSpanId).fold(())(builder.appendText(_))
+      }
+
+      private def getSpanContext(ctxStorage: ContextStorage, fiberRefs: FiberRefs): Option[SpanContext] = {
+        val maybeOtelContext = ctxStorage match {
+          case ref: ContextStorage.ZIOFiberRef => fiberRefs.get(ref.ref)
+          case ContextStorage.Native           => Some(Context.current())
+        }
+
+        maybeOtelContext
+          .map(Span.fromContext)
+          .map(_.getSpanContext)
+      }
+    }
+  }
+
+}

opentelemetry-zio-logging/src/test/scala/zio/telemetry/opentelemetry/zio/logging/TelemetryLogFormatsSpec.scala

@@ -0,0 +1,59 @@
+package zio.telemetry.opentelemetry.zio.logging
+
+import io.opentelemetry.api.trace.Tracer
+import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter
+import io.opentelemetry.sdk.trace.SdkTracerProvider
+import io.opentelemetry.sdk.trace.data.SpanData
+import io.opentelemetry.sdk.trace.`export`.SimpleSpanProcessor
+import zio.Runtime.removeDefaultLoggers
+import zio.telemetry.opentelemetry.context.ContextStorage
+import zio.telemetry.opentelemetry.tracing.Tracing
+import zio.test.{Spec, TestEnvironment, ZIOSpecDefault, assertTrue}
+import zio.{Scope, UIO, ULayer, URLayer, ZEnvironment, ZIO, ZLayer}
+
+import scala.collection.mutable
+import scala.jdk.CollectionConverters._
+
+object TelemetryLogFormatsSpec extends ZIOSpecDefault {
+
+  val inMemoryTracer: UIO[(InMemorySpanExporter, Tracer)] = for {
+    spanExporter   <- ZIO.succeed(InMemorySpanExporter.create())
+    spanProcessor  <- ZIO.succeed(SimpleSpanProcessor.create(spanExporter))
+    tracerProvider <- ZIO.succeed(SdkTracerProvider.builder().addSpanProcessor(spanProcessor).build())
+    tracer          = tracerProvider.get("TracingTest")
+  } yield (spanExporter, tracer)
+
+  val inMemoryTracerLayer: ULayer[InMemorySpanExporter with Tracer] =
+    ZLayer.fromZIOEnvironment(inMemoryTracer.map { case (inMemorySpanExporter, tracer) =>
+      ZEnvironment(inMemorySpanExporter).add(tracer)
+    })
+
+  def tracingMockLayer(
+    logAnnotated: Boolean = false
+  ): URLayer[ContextStorage, Tracing with InMemorySpanExporter with Tracer] =
+    inMemoryTracerLayer >>> (Tracing.live(logAnnotated) ++ inMemoryTracerLayer)
+
+  def getFinishedSpans: ZIO[InMemorySpanExporter, Nothing, List[SpanData]] =
+    ZIO.serviceWith[InMemorySpanExporter](_.getFinishedSpanItems.asScala.toList)
+
+  override def spec: Spec[TestEnvironment with Scope, Any] =
+    suiteAll("opentelemetry-zio-logging LogFormats") {
+      test("SpanId and traceId are extracted") {
+        ZIO.serviceWithZIO[Tracing] { tracing =>
+          import tracing.aspects._
+          val logs = mutable.Buffer[String]()
+
+          for {
+            logFormats <- ZIO.service[LogFormats]
+            format      = logFormats.spanIdLabel |-| logFormats.traceIdLabel
+            zLogger     = format.toLogger.map(logs.append(_))
+            _          <- zio.ZIO.logInfo("TEST").withLogger(zLogger) @@ span("Span") @@ root("Root")
+            spans      <- getFinishedSpans
+            child       = spans.find(_.getName == "Span").get
+            log         = logs.head
+          } yield assertTrue(log == s"spanId=${child.getSpanId} traceId=${child.getTraceId}")
+        }
+      }
+    }.provide(removeDefaultLoggers, tracingMockLayer(), ContextStorage.fiberRef, ZioLogging.logFormats)
+
+}