Experimental sdk-trace module

build.sbt

@@ -520,7 +520,7 @@ lazy val benchmarks = project
 lazy val examples = project
   .enablePlugins(NoPublishPlugin, JavaAgent)
   .in(file("examples"))
-  .dependsOn(core.jvm, oteljava)
+  .dependsOn(core.jvm, oteljava, sdk.jvm, `sdk-exporter`.jvm)
   .settings(
     name := "otel4s-examples",
     libraryDependencies ++= Seq(

examples/src/main/scala/TraceSdkExample.scala

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2022 Typelevel
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import cats.effect._
+import org.typelevel.otel4s.Attribute
+import org.typelevel.otel4s.sdk.OpenTelemetrySdk
+import org.typelevel.otel4s.sdk.exporter.otlp.trace.autoconfigure.OtlpSpanExporterAutoConfigure
+
+object TraceSdkExample extends IOApp.Simple {
+
+  def run: IO[Unit] =
+    OpenTelemetrySdk
+      .autoConfigured[IO](
+        _.addExporterConfigurer(OtlpSpanExporterAutoConfigure[IO])
+      )
+      .use { autoConfigured =>
+        val sdk = autoConfigured.sdk
+
+        for {
+          tracer <- sdk.tracerProvider.get("my-tracer")
+          _ <- tracer
+            .span("test", Attribute("test", "test123"))
+            .use(sd => IO.println(sd.context))
+        } yield ()
+      }
+
+}

sdk/all/src/test/scala/org/typelevel/otel4s/sdk/OpenTelemetrySdkSuite.scala

@@ -30,6 +30,7 @@ import org.typelevel.otel4s.sdk.autoconfigure.AutoConfigure
 import org.typelevel.otel4s.sdk.autoconfigure.Config
 import org.typelevel.otel4s.sdk.context.Context
 import org.typelevel.otel4s.sdk.trace.NoopConsole
+import org.typelevel.otel4s.sdk.trace.SpanLimits
 import org.typelevel.otel4s.sdk.trace.context.propagation.W3CBaggagePropagator
 import org.typelevel.otel4s.sdk.trace.context.propagation.W3CTraceContextPropagator
 import org.typelevel.otel4s.sdk.trace.data.LinkData
@@ -272,7 +273,7 @@ class OpenTelemetrySdkSuite extends CatsEffectSuite {
     "OpenTelemetrySdk.AutoConfigured{sdk=" +
       "OpenTelemetrySdk{meterProvider=MeterProvider.Noop, " +
       "tracerProvider=" +
-      s"SdkTracerProvider{resource=$resource, sampler=$sampler, " +
+      s"SdkTracerProvider{resource=$resource, spanLimits=${SpanLimits.Default}, sampler=$sampler, " +
       "spanProcessor=SpanProcessor.Multi(" +
       s"BatchSpanProcessor{exporter=$exporter, scheduleDelay=5 seconds, exporterTimeout=30 seconds, maxQueueSize=2048, maxExportBatchSize=512}, " +
       "SpanStorage)}, " +

sdk/common/src/main/scala/org/typelevel/otel4s/sdk/internal/ComponentRegistry.scala

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2023 Typelevel
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.typelevel.otel4s
+package sdk
+package internal
+
+import org.typelevel.otel4s.sdk.common.InstrumentationScope
+
+// todo: implement caching
+final class ComponentRegistry[F[_], A](
+    factory: InstrumentationScope => F[A]
+) {
+
+  def get(
+      name: String,
+      version: Option[String],
+      schemaUrl: Option[String],
+      attributes: Attributes
+  ): F[A] = {
+    buildComponent(
+      InstrumentationScope(name, version, schemaUrl, attributes)
+    )
+  }
+
+  private def buildComponent(info: InstrumentationScope): F[A] = {
+    val component = factory(info)
+    component
+  }
+
+}

sdk/trace/src/main/scala/org/typelevel/otel4s/sdk/trace/SdkSpanBackend.scala

@@ -68,6 +68,7 @@ import scala.concurrent.duration.FiniteDuration
   *   the higher-kinded type of a polymorphic effect
   */
 private final class SdkSpanBackend[F[_]: Monad: Clock: Console] private (
+    spanLimits: SpanLimits,
     spanProcessor: SpanProcessor[F],
     immutableState: SdkSpanBackend.ImmutableState,
     mutableState: Ref[F, SdkSpanBackend.MutableState]
@@ -146,7 +147,16 @@ private final class SdkSpanBackend[F[_]: Monad: Clock: Console] private (
   }
 
   private def addTimedEvent(event: EventData): F[Unit] =
-    updateState("addEvent")(s => s.copy(events = s.events :+ event)).void
+    updateState("addEvent") { s =>
+      if (s.events.sizeIs <= spanLimits.maxNumberOfEvents) {
+        s.copy(
+          events = s.events :+ event,
+          totalRecordedEvents = s.totalRecordedEvents + 1
+        )
+      } else {
+        s.copy(totalRecordedEvents = s.totalRecordedEvents + 1)
+      }
+    }.void
 
   // applies modifications while the span is still active
   // modifications are ignored when the span is ended
@@ -193,6 +203,10 @@ private final class SdkSpanBackend[F[_]: Monad: Clock: Console] private (
       attributes = state.attributes,
       events = state.events,
       links = immutableState.links,
+      /*totalRecordedEvents = state.totalRecordedEvents,
+      totalRecordedLinks = immutableState.totalRecordedLinks,
+      totalAttributeCount =
+        state.attributes.size, // todo: incorrect when limits are applied,*/
       instrumentationScope = immutableState.scopeInfo,
       resource = immutableState.resource
     )
@@ -255,9 +269,11 @@ private object SdkSpanBackend {
       resource: TelemetryResource,
       kind: SpanKind,
       parentContext: Option[SpanContext],
+      spanLimits: SpanLimits,
       processor: SpanProcessor[F],
       attributes: Attributes,
       links: Vector[LinkData],
+      totalRecordedLinks: Int,
       userStartTimestamp: Option[FiniteDuration]
   ): F[SdkSpanBackend[F]] = {
     def immutableState(startTimestamp: FiniteDuration) =
@@ -268,6 +284,7 @@ private object SdkSpanBackend {
         parentContext = parentContext,
         resource = resource,
         links = links,
+        totalRecordedLinks = totalRecordedLinks,
         startTimestamp = startTimestamp
       )
 
@@ -276,13 +293,19 @@ private object SdkSpanBackend {
       status = StatusData.Unset,
       attributes = attributes,
       events = Vector.empty,
+      totalRecordedEvents = 0,
       endTimestamp = None
     )
 
     for {
       start <- userStartTimestamp.fold(Clock[F].realTime)(_.pure)
       state <- Ref[F].of(mutableState)
-      backend = new SdkSpanBackend[F](processor, immutableState(start), state)
+      backend = new SdkSpanBackend[F](
+        spanLimits,
+        processor,
+        immutableState(start),
+        state
+      )
       _ <- processor.onStart(parentContext, backend)
     } yield backend
   }
@@ -294,6 +317,7 @@ private object SdkSpanBackend {
       parentContext: Option[SpanContext],
       resource: TelemetryResource,
       links: Vector[LinkData],
+      totalRecordedLinks: Int,
       startTimestamp: FiniteDuration
   )
 
@@ -304,6 +328,7 @@ private object SdkSpanBackend {
       status: StatusData,
       attributes: Attributes,
       events: Vector[EventData],
+      totalRecordedEvents: Int,
       endTimestamp: Option[FiniteDuration]
   )
 

sdk/trace/src/main/scala/org/typelevel/otel4s/sdk/trace/SdkSpanBuilder.scala

@@ -193,9 +193,11 @@ private final case class SdkSpanBuilder[F[_]: Temporal: Console](
               resource = tracerSharedState.resource,
               kind = spanKind,
               parentContext = parentSpanContext,
+              spanLimits = tracerSharedState.spanLimits,
               processor = tracerSharedState.spanProcessor,
               attributes = attrs |+| samplingResult.attributes,
               links = links,
+              totalRecordedLinks = links.size,
               userStartTimestamp = startTimestamp
             )
             .widen

sdk/trace/src/main/scala/org/typelevel/otel4s/sdk/trace/SdkTracerBuilder.scala

@@ -14,25 +14,18 @@
  * limitations under the License.
  */
 
-package org.typelevel.otel4s.sdk
+package org.typelevel.otel4s
+package sdk
 package trace
 
-import cats.effect.Temporal
-import cats.effect.std.Console
-import org.typelevel.otel4s.Attributes
-import org.typelevel.otel4s.context.propagation.ContextPropagators
-import org.typelevel.otel4s.sdk.common.InstrumentationScope
-import org.typelevel.otel4s.sdk.context.Context
-import org.typelevel.otel4s.sdk.trace.processor.SpanStorage
-import org.typelevel.otel4s.trace.TraceScope
+import cats.Functor
+import cats.syntax.functor._
+import org.typelevel.otel4s.sdk.internal.ComponentRegistry
 import org.typelevel.otel4s.trace.Tracer
 import org.typelevel.otel4s.trace.TracerBuilder
 
-private final case class SdkTracerBuilder[F[_]: Temporal: Console](
-    propagators: ContextPropagators[Context],
-    traceScope: TraceScope[F, Context],
-    sharedState: TracerSharedState[F],
-    storage: SpanStorage[F],
+private final case class SdkTracerBuilder[F[_]: Functor](
+    registry: ComponentRegistry[F, SdkTracer[F]],
     name: String,
     version: Option[String] = None,
     schemaUrl: Option[String] = None
@@ -45,13 +38,5 @@ private final case class SdkTracerBuilder[F[_]: Temporal: Console](
     copy(schemaUrl = Option(schemaUrl))
 
   def get: F[Tracer[F]] =
-    Temporal[F].pure(
-      new SdkTracer[F](
-        InstrumentationScope(name, version, schemaUrl, Attributes.empty),
-        propagators,
-        sharedState,
-        traceScope,
-        storage
-      )
-    )
+    registry.get(name, version, schemaUrl, Attributes.empty).widen
 }

sdk/trace/src/main/scala/org/typelevel/otel4s/sdk/trace/SdkTracerProvider.scala

@@ -26,6 +26,7 @@ import org.typelevel.otel4s.context.propagation.ContextPropagators
 import org.typelevel.otel4s.context.propagation.TextMapPropagator
 import org.typelevel.otel4s.sdk.context.Context
 import org.typelevel.otel4s.sdk.context.LocalContext
+import org.typelevel.otel4s.sdk.internal.ComponentRegistry
 import org.typelevel.otel4s.sdk.trace.processor.SpanProcessor
 import org.typelevel.otel4s.sdk.trace.processor.SpanStorage
 import org.typelevel.otel4s.sdk.trace.samplers.Sampler
@@ -36,6 +37,7 @@ import org.typelevel.otel4s.trace.TracerProvider
 private class SdkTracerProvider[F[_]: Temporal: Parallel: Console](
     idGenerator: IdGenerator[F],
     resource: TelemetryResource,
+    spanLimits: SpanLimits,
     sampler: Sampler,
     propagators: ContextPropagators[Context],
     spanProcessors: List[SpanProcessor[F]],
@@ -47,16 +49,33 @@ private class SdkTracerProvider[F[_]: Temporal: Parallel: Console](
     TracerSharedState(
       idGenerator,
       resource,
+      spanLimits,
       sampler,
       SpanProcessor.of(spanProcessors: _*)
     )
 
+  private val registry: ComponentRegistry[F, SdkTracer[F]] =
+    new ComponentRegistry[F, SdkTracer[F]](scopeInfo =>
+      Temporal[F].pure(
+        new SdkTracer[F](
+          scopeInfo,
+          propagators,
+          sharedState,
+          traceScope,
+          storage
+        )
+      )
+    )
+
   def tracer(name: String): TracerBuilder[F] =
-    new SdkTracerBuilder[F](propagators, traceScope, sharedState, storage, name)
+    new SdkTracerBuilder[F](registry, name)
 
   override def toString: String =
-    s"SdkTracerProvider{resource=$resource, sampler=$sampler, spanProcessor=${sharedState.spanProcessor}}"
-
+    "SdkTracerProvider{" +
+      s"resource=$resource, " +
+      s"spanLimits=$spanLimits, " +
+      s"sampler=$sampler, " +
+      s"spanProcessor=${sharedState.spanProcessor}}"
 }
 
 object SdkTracerProvider {
@@ -105,6 +124,16 @@ object SdkTracerProvider {
       */
     def addResource(resource: TelemetryResource): Builder[F]
 
+    /** Sets an initial [[SpanLimits]] that should be used with this SDK.
+      *
+      * The limits will be used for every
+      * [[org.typelevel.otel4s.trace.Span Span]].
+      *
+      * @param limits
+      *   the [[SpanLimits]] to use
+      */
+    def withSpanLimits(limits: SpanLimits): Builder[F]
+
     /** Sets a [[org.typelevel.otel4s.sdk.trace.samplers.Sampler Sampler]].
       *
       * The sampler will be called each time a
@@ -161,6 +190,7 @@ object SdkTracerProvider {
     BuilderImpl[F](
       idGenerator = IdGenerator.random,
       resource = TelemetryResource.default,
+      spanLimits = SpanLimits.Default,
       sampler = Sampler.parentBased(Sampler.AlwaysOn),
       propagators = Nil,
       spanProcessors = Nil
@@ -171,6 +201,7 @@ object SdkTracerProvider {
   ](
       idGenerator: IdGenerator[F],
       resource: TelemetryResource,
+      spanLimits: SpanLimits,
       sampler: Sampler,
       propagators: List[TextMapPropagator[Context]],
       spanProcessors: List[SpanProcessor[F]]
@@ -185,6 +216,9 @@ object SdkTracerProvider {
     def addResource(resource: TelemetryResource): Builder[F] =
       copy(resource = this.resource.mergeUnsafe(resource))
 
+    def withSpanLimits(limits: SpanLimits): Builder[F] =
+      copy(spanLimits = limits)
+
     def withSampler(sampler: Sampler): Builder[F] =
       copy(sampler = sampler)
 
@@ -201,6 +235,7 @@ object SdkTracerProvider {
         new SdkTracerProvider[F](
           idGenerator,
           resource,
+          spanLimits,
           sampler,
           ContextPropagators.of(propagators: _*),
           spanProcessors :+ storage,