@effect/opentelemetry 0.20.0 → 0.21.0

package/src/Tracer.ts

@@ -6,7 +6,7 @@ import type { Tag } from "effect/Context"
 import type { Effect } from "effect/Effect"
 import type { Layer } from "effect/Layer"
 import type * as Option from "effect/Option"
-import type { ExternalSpan, Tracer } from "effect/Tracer"
+import type { ExternalSpan, Tracer as EffectTracer } from "effect/Tracer"
 import * as internal from "./internal/tracer"
 import type { Resource } from "./Resource"
 
@@ -14,7 +14,7 @@ import type { Resource } from "./Resource"
  * @since 1.0.0
  * @category constructors
  */
-export const make: Effect<Otel.Tracer, never, Tracer> = internal.make
+export const make: Effect<Otel.Tracer, never, EffectTracer> = internal.make
 
 /**
  * @since 1.0.0
@@ -39,19 +39,37 @@ export const currentOtelSpan: Effect<never, never, Option.Option<Otel.Span>> = i
  * @since 1.0.0
  * @category layers
  */
-export const layer: Layer<Resource, never, never> = internal.layer
+export const layer: Layer<Resource | Otel.TracerProvider, never, never> = internal.layer
 
 /**
  * @since 1.0.0
  * @category layers
  */
-export const layerOtelTracer: Layer<Resource, never, Otel.Tracer> = internal.layerOtelTracer
+export const layerGlobal: Layer<Resource, never, never> = internal.layerGlobal
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerTracer: Layer<Resource | Otel.TracerProvider, never, Otel.Tracer> = internal.layerTracer
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerGlobalTracer: Layer<Resource, never, Otel.Tracer> = internal.layerGlobalTracer
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export const TracerProvider: Tag<Otel.TracerProvider, Otel.TracerProvider> = internal.TracerProvider
 
 /**
  * @since 1.0.0
  * @category tags
  */
-export const OtelTracer: Tag<Otel.Tracer, Otel.Tracer> = internal.OtelTracer
+export const Tracer: Tag<Otel.Tracer, Otel.Tracer> = internal.Tracer
 
 /**
  * @since 1.0.0

package/src/WebSdk.ts

@@ -0,0 +1,79 @@
+/**
+ * @since 1.0.0
+ */
+import type { TracerProvider } from "@opentelemetry/api"
+import type * as Resources from "@opentelemetry/resources"
+import type { MetricReader } from "@opentelemetry/sdk-metrics"
+import type { SpanProcessor, TracerConfig } from "@opentelemetry/sdk-trace-base"
+import { WebTracerProvider } from "@opentelemetry/sdk-trace-web"
+import * as Effect from "effect/Effect"
+import type { LazyArg } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Metrics from "./Metrics"
+import * as Resource from "./Resource"
+import * as Tracer from "./Tracer"
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export interface Configuration {
+  readonly spanProcessor?: SpanProcessor
+  readonly tracerConfig?: Omit<TracerConfig, "resource">
+  readonly metricReader?: MetricReader
+  readonly resource: {
+    readonly serviceName: string
+    readonly serviceVersion?: string
+    readonly attributes?: Resources.ResourceAttributes
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerTracerProvider = (
+  processor: SpanProcessor,
+  config?: Omit<TracerConfig, "resource">
+): Layer.Layer<Resource.Resource, never, TracerProvider> =>
+  Layer.scoped(
+    Tracer.TracerProvider,
+    Effect.flatMap(
+      Resource.Resource,
+      (resource) =>
+        Effect.acquireRelease(
+          Effect.sync(() => {
+            const provider = new WebTracerProvider({
+              ...(config ?? {}),
+              resource
+            })
+            provider.addSpanProcessor(processor)
+            return provider
+          }),
+          (provider) => Effect.promise(() => provider.shutdown())
+        )
+    )
+  )
+
+/**
+ * @since 1.0.0
+ * @category layer
+ */
+export const layer = (
+  evaluate: LazyArg<Configuration>
+): Layer.Layer<never, never, Resource.Resource> =>
+  Layer.unwrapEffect(
+    Effect.sync(() => {
+      const config = evaluate()
+      const ResourceLive = Resource.layer(config.resource)
+      const TracerLive = config.spanProcessor ?
+        Tracer.layer.pipe(Layer.use(layerTracerProvider(config.spanProcessor, config.tracerConfig)))
+        : Layer.effectDiscard(Effect.unit)
+      const MetricsLive = config.metricReader
+        ? Metrics.layer(() => config.metricReader!)
+        : Layer.effectDiscard(Effect.unit)
+      return Layer.merge(TracerLive, MetricsLive).pipe(
+        Layer.useMerge(ResourceLive)
+      )
+    })
+  )

package/src/index.ts

@@ -17,3 +17,8 @@ export * as Resource from "@effect/opentelemetry/Resource"
  * @since 1.0.0
  */
 export * as Tracer from "@effect/opentelemetry/Tracer"
+
+/**
+ * @since 1.0.0
+ */
+export * as WebSdk from "@effect/opentelemetry/WebSdk"

package/src/internal/tracer.ts

@@ -6,11 +6,11 @@ import type { Exit } from "effect/Exit"
 import * as FiberRef from "effect/FiberRef"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
-import * as Tracer from "effect/Tracer"
+import * as EffectTracer from "effect/Tracer"
 import { Resource } from "../Resource"
 
 /** @internal */
-export class OtelSpan implements Tracer.Span {
+export class OtelSpan implements EffectTracer.Span {
   readonly _tag = "Span"
 
   readonly span: OtelApi.Span
@@ -18,15 +18,15 @@ export class OtelSpan implements Tracer.Span {
   readonly traceId: string
   readonly attributes = new Map<string, unknown>()
   readonly sampled: boolean
-  status: Tracer.SpanStatus
+  status: EffectTracer.SpanStatus
 
   constructor(
     contextApi: OtelApi.ContextAPI,
     tracer: OtelApi.Tracer,
     readonly name: string,
-    readonly parent: Option.Option<Tracer.ParentSpan>,
+    readonly parent: Option.Option<EffectTracer.ParentSpan>,
     readonly context: Context.Context<never>,
-    readonly links: ReadonlyArray<Tracer.SpanLink>,
+    readonly links: ReadonlyArray<EffectTracer.SpanLink>,
     startTime: bigint
   ) {
     const active = contextApi.active()
@@ -100,11 +100,14 @@ export class OtelSpan implements Tracer.Span {
 }
 
 /** @internal */
-export const OtelTracer = Context.Tag<OtelApi.Tracer>("@effect/opentelemetry/Tracer/OtelTracer")
+export const TracerProvider = Context.Tag<OtelApi.TracerProvider>("@effect/opentelemetry/Tracer/TracerProvider")
 
 /** @internal */
-export const make = Effect.map(OtelTracer, (tracer) =>
-  Tracer.make({
+export const Tracer = Context.Tag<OtelApi.Tracer>("@effect/opentelemetry/Tracer/Tracer")
+
+/** @internal */
+export const make = Effect.map(Tracer, (tracer) =>
+  EffectTracer.make({
     span(name, parent, context, links, startTime) {
       return new OtelSpan(
         OtelApi.context,
@@ -117,8 +120,8 @@ export const make = Effect.map(OtelTracer, (tracer) =>
       )
     },
     context(execution, fiber) {
-      const currentSpan = fiber.getFiberRef(FiberRef.currentContext).unsafeMap.get(Tracer.ParentSpan) as
-        | Tracer.ParentSpan
+      const currentSpan = fiber.getFiberRef(FiberRef.currentContext).unsafeMap.get(EffectTracer.ParentSpan) as
+        | EffectTracer.ParentSpan
         | undefined
 
       if (currentSpan === undefined) {
@@ -144,7 +147,7 @@ export const makeExternalSpan = (options: {
   readonly spanId: string
   readonly traceFlags?: number
   readonly traceState?: string | OtelApi.TraceState
-}): Tracer.ExternalSpan => {
+}): EffectTracer.ExternalSpan => {
   let context = Context.empty()
 
   if (options.traceFlags) {
@@ -182,13 +185,19 @@ export const currentOtelSpan = Effect.map(
 )
 
 /** @internal */
-export const layerOtelTracer = Layer.effect(
-  OtelTracer,
+export const layerGlobalProvider = Layer.sync(
+  TracerProvider,
+  () => OtelApi.trace.getTracerProvider()
+)
+
+/** @internal */
+export const layerTracer = Layer.effect(
+  Tracer,
   Effect.flatMap(
-    Resource,
-    (resource) =>
+    Effect.zip(Resource, TracerProvider),
+    ([resource, provider]) =>
       Effect.sync(() =>
-        OtelApi.trace.getTracer(
+        provider.getTracer(
           resource.attributes["service.name"] as string,
           resource.attributes["service.version"] as string
         )
@@ -197,9 +206,18 @@ export const layerOtelTracer = Layer.effect(
 )
 
 /** @internal */
-export const layer = Layer.provide(
-  layerOtelTracer,
-  Layer.unwrapEffect(Effect.map(make, Layer.setTracer))
+export const layerGlobalTracer = layerTracer.pipe(
+  Layer.use(layerGlobalProvider)
+)
+
+/** @internal */
+export const layerGlobal = Layer.unwrapEffect(Effect.map(make, Layer.setTracer)).pipe(
+  Layer.use(layerGlobalTracer)
+)
+
+/** @internal */
+export const layer = Layer.unwrapEffect(Effect.map(make, Layer.setTracer)).pipe(
+  Layer.use(layerTracer)
 )
 
 // -------------------------------------------------------------------------------------
@@ -215,14 +233,14 @@ const createTraceState = Option.liftThrowable(OtelApi.createTraceState)
 
 const populateContext = (
   otelContext: OtelApi.Context,
-  span: Tracer.ParentSpan,
+  span: EffectTracer.ParentSpan,
   context?: Context.Context<never>
 ): OtelApi.Context =>
   span instanceof OtelSpan ?
     OtelApi.trace.setSpan(otelContext, span.span) :
     OtelApi.trace.setSpanContext(otelContext, makeSpanContext(span, context))
 
-const makeSpanContext = (span: Tracer.ParentSpan, context?: Context.Context<never>): OtelApi.SpanContext => ({
+const makeSpanContext = (span: EffectTracer.ParentSpan, context?: Context.Context<never>): OtelApi.SpanContext => ({
   spanId: span.spanId,
   traceId: span.traceId,
   isRemote: span._tag === "ExternalSpan",
@@ -240,7 +258,7 @@ const makeSpanContext = (span: Tracer.ParentSpan, context?: Context.Context<neve
 })
 
 const extractTraceTag = <I, S>(
-  parent: Tracer.ParentSpan,
+  parent: EffectTracer.ParentSpan,
   context: Context.Context<never>,
   tag: Context.Tag<I, S>
 ) =>