@effect/opentelemetry 0.19.0 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/opentelemetry",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "publishConfig": {
     "access": "public"
   },
@@ -44,12 +44,14 @@
   "dependencies": {
     "@opentelemetry/resources": "^1.17.1",
     "@opentelemetry/sdk-metrics": "^1.17.1",
-    "@opentelemetry/sdk-node": "^0.44.0",
+    "@opentelemetry/sdk-trace-base": "^1.17.1",
+    "@opentelemetry/sdk-trace-node": "^1.17.1",
+    "@opentelemetry/sdk-trace-web": "^1.17.1",
     "@opentelemetry/semantic-conventions": "^1.17.1"
   },
   "peerDependencies": {
     "@opentelemetry/api": "^1.4",
-    "effect": "2.0.0-next.49"
+    "effect": "2.0.0-next.51"
   },
   "devDependencies": {
     "@babel/core": "^7.23.2",
@@ -62,31 +64,33 @@
     "@effect/eslint-plugin": "^0.1.2",
     "@effect/language-service": "^0.0.21",
     "@opentelemetry/api": "^1.6.0",
-    "@opentelemetry/exporter-prometheus": "^0.44.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.44.0",
-    "@opentelemetry/sdk-trace-base": "^1.17.1",
+    "@opentelemetry/context-async-hooks": "^1.17.1",
+    "@opentelemetry/exporter-metrics-otlp-http": "0.43.0",
+    "@opentelemetry/exporter-prometheus": "0.43.0",
+    "@opentelemetry/exporter-trace-otlp-http": "0.43.0",
+    "@opentelemetry/otlp-exporter-base": "0.43.0",
     "@preconstruct/cli": "^2.8.1",
-    "@types/chai": "^4.3.8",
-    "@types/node": "^20.8.6",
-    "@typescript-eslint/eslint-plugin": "^6.8.0",
-    "@typescript-eslint/parser": "^6.8.0",
+    "@types/chai": "^4.3.9",
+    "@types/node": "^20.8.9",
+    "@typescript-eslint/eslint-plugin": "^6.9.0",
+    "@typescript-eslint/parser": "^6.9.0",
     "@vitejs/plugin-react": "^4.1.0",
     "@vitest/coverage-v8": "^0.34.6",
     "@vitest/expect": "^0.34.6",
     "babel-plugin-annotate-pure-calls": "^0.4.0",
-    "concurrently": "^8.2.1",
-    "effect": "2.0.0-next.49",
-    "eslint": "^8.51.0",
+    "concurrently": "^8.2.2",
+    "effect": "2.0.0-next.51",
+    "eslint": "^8.52.0",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-codegen": "0.17.0",
     "eslint-plugin-deprecation": "^2.0.0",
-    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-import": "^2.29.0",
     "eslint-plugin-simple-import-sort": "^10.0.0",
     "eslint-plugin-sort-destructure-keys": "^1.5.0",
     "madge": "^6.1.0",
     "ts-node": "^10.9.1",
     "typescript": "^5.2.2",
-    "vite": "^4.4.11",
+    "vite": "^4.5.0",
     "vitest": "0.34.6"
   },
   "exports": {
@@ -120,6 +124,12 @@
       "module": "./Tracer/dist/effect-opentelemetry-Tracer.esm.js",
       "import": "./Tracer/dist/effect-opentelemetry-Tracer.cjs.mjs",
       "default": "./Tracer/dist/effect-opentelemetry-Tracer.cjs.js"
+    },
+    "./WebSdk": {
+      "types": "./dist/declarations/src/WebSdk.d.ts",
+      "module": "./WebSdk/dist/effect-opentelemetry-WebSdk.esm.js",
+      "import": "./WebSdk/dist/effect-opentelemetry-WebSdk.cjs.mjs",
+      "default": "./WebSdk/dist/effect-opentelemetry-WebSdk.cjs.js"
     }
   },
   "files": [
@@ -129,10 +139,11 @@
     "Metrics",
     "NodeSdk",
     "Resource",
-    "Tracer"
+    "Tracer",
+    "WebSdk"
   ],
   "scripts": {
-    "example": "ts-node --project tsconfig.examples.json",
+    "example": "node -r ts-node/register",
     "version": "changeset version",
     "clean": "node scripts/clean.mjs",
     "build": "pnpm gen && preconstruct fix && preconstruct build && pnpm gen",

package/src/NodeSdk.ts

@@ -1,41 +1,81 @@
 /**
  * @since 1.0.0
  */
-import type { NodeSDKConfiguration } from "@opentelemetry/sdk-node"
-import { NodeSDK } from "@opentelemetry/sdk-node"
+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 { NodeTracerProvider } from "@opentelemetry/sdk-trace-node"
 import * as Effect from "effect/Effect"
 import type { LazyArg } from "effect/Function"
 import * as Layer from "effect/Layer"
-import { Resource } from "./Resource"
+import * as Metrics from "./Metrics"
+import * as Resource from "./Resource"
+import * as Tracer from "./Tracer"
 
 /**
  * @since 1.0.0
  * @category model
  */
-export type Configuration = Partial<Omit<NodeSDKConfiguration, "resource" | "serviceName">>
+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 constructor
+ * @category layers
  */
-export const config: (config: Configuration) => Configuration = (config: Configuration) => config
+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 NodeTracerProvider({
+              ...(config ?? {}),
+              resource
+            })
+            provider.addSpanProcessor(processor)
+            return provider
+          }),
+          (provider) => Effect.promise(() => provider.shutdown())
+        )
+    )
+  )
 
 /**
  * @since 1.0.0
  * @category layer
  */
 export const layer = (
-  config: LazyArg<Configuration>
-): Layer.Layer<Resource, never, never> =>
-  Layer.scopedDiscard(Effect.acquireRelease(
-    Effect.flatMap(
-      Resource,
-      (resource) =>
-        Effect.sync(() => {
-          const sdk = new NodeSDK({ ...config(), resource })
-          sdk.start()
-          return sdk
-        })
-    ),
-    (sdk) => Effect.promise(() => sdk.shutdown())
-  ))
+  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/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

@@ -4,31 +4,29 @@ import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import type { Exit } from "effect/Exit"
 import * as FiberRef from "effect/FiberRef"
-import * as FiberRefs from "effect/FiberRefs"
 import * as Layer from "effect/Layer"
-import * as List from "effect/List"
 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
   readonly spanId: string
   readonly traceId: string
   readonly attributes = new Map<string, unknown>()
-  status: Tracer.SpanStatus
+  readonly sampled: boolean
+  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 sampled: boolean,
+    readonly links: ReadonlyArray<EffectTracer.SpanLink>,
     startTime: bigint
   ) {
     const active = contextApi.active()
@@ -54,6 +52,7 @@ export class OtelSpan implements Tracer.Span {
       _tag: "Started",
       startTime
     }
+    this.sampled = (spanContext.traceFlags & OtelApi.TraceFlags.SAMPLED) === OtelApi.TraceFlags.SAMPLED
   }
 
   attribute(key: string, value: unknown) {
@@ -101,12 +100,15 @@ 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({
-    span(name, parent, context, links, sampled, startTime) {
+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,
         tracer,
@@ -114,32 +116,25 @@ export const make = Effect.map(OtelTracer, (tracer) =>
         parent,
         context,
         links,
-        sampled,
         startTime
       )
     },
     context(execution, fiber) {
-      const currentSpan = Option.flatMap(
-        FiberRefs.get(
-          fiber.getFiberRefs(),
-          FiberRef.currentTracerSpan
-        ),
-        List.head
-      )
+      const currentSpan = fiber.getFiberRef(FiberRef.currentContext).unsafeMap.get(EffectTracer.ParentSpan) as
+        | EffectTracer.ParentSpan
+        | undefined
 
-      if (currentSpan._tag === "None") {
+      if (currentSpan === undefined) {
         return execution()
       }
 
       return OtelApi.context.with(
-        populateContext(OtelApi.context.active(), currentSpan.value),
+        populateContext(OtelApi.context.active(), currentSpan),
         execution
       )
     }
   }))
 
-/** @internal */
-
 /** @internal */
 export const traceFlagsTag = Context.Tag<OtelApi.TraceFlags>("@effect/opentelemetry/traceFlags")
 
@@ -152,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) {
@@ -173,7 +168,7 @@ export const makeExternalSpan = (options: {
     traceId: options.traceId,
     spanId: options.spanId,
     sampled: options.traceFlags
-      ? options.traceFlags === OtelApi.TraceFlags.SAMPLED
+      ? (options.traceFlags & OtelApi.TraceFlags.SAMPLED) === OtelApi.TraceFlags.SAMPLED
       : true,
     context
   }
@@ -190,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
         )
@@ -205,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)
 )
 
 // -------------------------------------------------------------------------------------
@@ -223,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",
@@ -248,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>
 ) =>