@effect/opentelemetry 0.61.0 → 4.0.0-beta.1

package/package.json

@@ -1,15 +1,58 @@
 {
   "name": "@effect/opentelemetry",
-  "version": "0.61.0",
-  "description": "OpenTelemetry integration for Effect",
+  "type": "module",
+  "version": "4.0.0-beta.1",
   "license": "MIT",
+  "description": "OpenTelemetry integration for Effect",
+  "homepage": "https://effect.website",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Effect-TS/effect.git",
+    "url": "https://github.com/Effect-TS/effect-smol.git",
     "directory": "packages/opentelemetry"
   },
+  "bugs": {
+    "url": "https://github.com/Effect-TS/effect-smol/issues"
+  },
+  "tags": [
+    "opentelemetry",
+    "observability",
+    "tracing",
+    "metrics",
+    "typescript",
+    "algebraic-data-types",
+    "functional-programming"
+  ],
+  "keywords": [
+    "opentelemetry",
+    "observability",
+    "tracing",
+    "metrics",
+    "typescript",
+    "algebraic-data-types",
+    "functional-programming"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "sideEffects": [],
-  "homepage": "https://effect.website",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./dist/index.js",
+    "./*": "./dist/*.js",
+    "./internal/*": null,
+    "./*/index": null
+  },
+  "files": [
+    "src/**/*.ts",
+    "dist/**/*.js",
+    "dist/**/*.js.map",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "peerDependencies": {
     "@opentelemetry/api": "^1.9",
     "@opentelemetry/resources": "^2.0.0",
@@ -19,129 +62,53 @@
     "@opentelemetry/sdk-trace-node": "^2.0.0",
     "@opentelemetry/sdk-trace-web": "^2.0.0",
     "@opentelemetry/semantic-conventions": "^1.33.0",
-    "@effect/platform": "^0.94.2",
-    "effect": "^3.19.15"
-  },
-  "publishConfig": {
-    "provenance": true
+    "effect": "^4.0.0-beta.1"
   },
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/dts/index.d.ts",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "types": "./dist/dts/index.d.ts",
-      "import": "./dist/esm/index.js",
-      "default": "./dist/cjs/index.js"
-    },
-    "./Logger": {
-      "types": "./dist/dts/Logger.d.ts",
-      "import": "./dist/esm/Logger.js",
-      "default": "./dist/cjs/Logger.js"
-    },
-    "./Metrics": {
-      "types": "./dist/dts/Metrics.d.ts",
-      "import": "./dist/esm/Metrics.js",
-      "default": "./dist/cjs/Metrics.js"
-    },
-    "./NodeSdk": {
-      "types": "./dist/dts/NodeSdk.d.ts",
-      "import": "./dist/esm/NodeSdk.js",
-      "default": "./dist/cjs/NodeSdk.js"
+  "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
     },
-    "./Otlp": {
-      "types": "./dist/dts/Otlp.d.ts",
-      "import": "./dist/esm/Otlp.js",
-      "default": "./dist/cjs/Otlp.js"
+    "@opentelemetry/resources": {
+      "optional": true
     },
-    "./OtlpLogger": {
-      "types": "./dist/dts/OtlpLogger.d.ts",
-      "import": "./dist/esm/OtlpLogger.js",
-      "default": "./dist/cjs/OtlpLogger.js"
+    "@opentelemetry/sdk-metrics": {
+      "optional": true
     },
-    "./OtlpMetrics": {
-      "types": "./dist/dts/OtlpMetrics.d.ts",
-      "import": "./dist/esm/OtlpMetrics.js",
-      "default": "./dist/cjs/OtlpMetrics.js"
+    "@opentelemetry/sdk-trace-base": {
+      "optional": true
     },
-    "./OtlpResource": {
-      "types": "./dist/dts/OtlpResource.d.ts",
-      "import": "./dist/esm/OtlpResource.js",
-      "default": "./dist/cjs/OtlpResource.js"
+    "@opentelemetry/sdk-trace-node": {
+      "optional": true
     },
-    "./OtlpSerialization": {
-      "types": "./dist/dts/OtlpSerialization.d.ts",
-      "import": "./dist/esm/OtlpSerialization.js",
-      "default": "./dist/cjs/OtlpSerialization.js"
+    "@opentelemetry/sdk-trace-web": {
+      "optional": true
     },
-    "./OtlpTracer": {
-      "types": "./dist/dts/OtlpTracer.d.ts",
-      "import": "./dist/esm/OtlpTracer.js",
-      "default": "./dist/cjs/OtlpTracer.js"
-    },
-    "./Resource": {
-      "types": "./dist/dts/Resource.d.ts",
-      "import": "./dist/esm/Resource.js",
-      "default": "./dist/cjs/Resource.js"
-    },
-    "./Tracer": {
-      "types": "./dist/dts/Tracer.d.ts",
-      "import": "./dist/esm/Tracer.js",
-      "default": "./dist/cjs/Tracer.js"
-    },
-    "./WebSdk": {
-      "types": "./dist/dts/WebSdk.d.ts",
-      "import": "./dist/esm/WebSdk.js",
-      "default": "./dist/cjs/WebSdk.js"
-    },
-    "./index": {
-      "types": "./dist/dts/index.d.ts",
-      "import": "./dist/esm/index.js",
-      "default": "./dist/cjs/index.js"
+    "@opentelemetry/sdk-logs": {
+      "optional": true
     }
   },
-  "typesVersions": {
-    "*": {
-      "Logger": [
-        "./dist/dts/Logger.d.ts"
-      ],
-      "Metrics": [
-        "./dist/dts/Metrics.d.ts"
-      ],
-      "NodeSdk": [
-        "./dist/dts/NodeSdk.d.ts"
-      ],
-      "Otlp": [
-        "./dist/dts/Otlp.d.ts"
-      ],
-      "OtlpLogger": [
-        "./dist/dts/OtlpLogger.d.ts"
-      ],
-      "OtlpMetrics": [
-        "./dist/dts/OtlpMetrics.d.ts"
-      ],
-      "OtlpResource": [
-        "./dist/dts/OtlpResource.d.ts"
-      ],
-      "OtlpSerialization": [
-        "./dist/dts/OtlpSerialization.d.ts"
-      ],
-      "OtlpTracer": [
-        "./dist/dts/OtlpTracer.d.ts"
-      ],
-      "Resource": [
-        "./dist/dts/Resource.d.ts"
-      ],
-      "Tracer": [
-        "./dist/dts/Tracer.d.ts"
-      ],
-      "WebSdk": [
-        "./dist/dts/WebSdk.d.ts"
-      ],
-      "index": [
-        "./dist/dts/index.d.ts"
-      ]
-    }
+  "devDependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/context-async-hooks": "^2.5.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "0.211.0",
+    "@opentelemetry/exporter-prometheus": "^0.211.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.211.0",
+    "@opentelemetry/otlp-exporter-base": "^0.211.0",
+    "@opentelemetry/resources": "^2.5.0",
+    "@opentelemetry/sdk-logs": "^0.211.0",
+    "@opentelemetry/sdk-metrics": "^2.5.0",
+    "@opentelemetry/sdk-trace-base": "^2.5.0",
+    "@opentelemetry/sdk-trace-node": "^2.5.0",
+    "@opentelemetry/sdk-trace-web": "^2.5.0",
+    "@opentelemetry/semantic-conventions": "^1.39.0"
+  },
+  "scripts": {
+    "codegen": "effect-utils codegen",
+    "build": "tsc -b tsconfig.json && pnpm babel",
+    "build:tsgo": "tsgo -b tsconfig.json && pnpm babel",
+    "babel": "babel dist --plugins annotate-pure-calls --out-dir dist --source-maps",
+    "check": "tsc -b tsconfig.json",
+    "test": "vitest",
+    "coverage": "vitest --coverage"
   }
 }

package/src/Logger.ts

@@ -4,30 +4,30 @@
 import * as Otel from "@opentelemetry/sdk-logs"
 import type { NonEmptyReadonlyArray } from "effect/Array"
 import * as Arr from "effect/Array"
-import * as Context from "effect/Context"
+import * as Clock from "effect/Clock"
 import type { DurationInput } from "effect/Duration"
 import * as Effect from "effect/Effect"
-import * as FiberId from "effect/FiberId"
-import * as FiberRef from "effect/FiberRef"
-import * as FiberRefs from "effect/FiberRefs"
 import * as Layer from "effect/Layer"
 import * as Logger from "effect/Logger"
+import * as LogLevel from "effect/LogLevel"
+import * as Predicate from "effect/Predicate"
+import * as ServiceMap from "effect/ServiceMap"
 import * as Tracer from "effect/Tracer"
-import { unknownToAttributeValue } from "./internal/utils.js"
-import { Resource } from "./Resource.js"
+import { unknownToAttributeValue } from "./internal/attributes.ts"
+import { Resource } from "./Resource.ts"
 
 /**
  * @since 1.0.0
- * @category tags
+ * @category Services
  */
-export class OtelLoggerProvider extends Context.Tag("@effect/opentelemetry/Logger/OtelLoggerProvider")<
+export class OtelLoggerProvider extends ServiceMap.Service<
   OtelLoggerProvider,
   Otel.LoggerProvider
->() {}
+>()("@effect/opentelemetry/Logger/OtelLoggerProvider") {}
 
 /**
  * @since 1.0.0
- * @category constructors
+ * @category Constructors
  */
 export const make: Effect.Effect<
   Logger.Logger<unknown, void>,
@@ -35,40 +35,37 @@ export const make: Effect.Effect<
   OtelLoggerProvider
 > = Effect.gen(function*() {
   const loggerProvider = yield* OtelLoggerProvider
-  const clock = yield* Effect.clock
+  const clock = yield* Clock.Clock
   const otelLogger = loggerProvider.getLogger("@effect/opentelemetry")
 
   return Logger.make((options) => {
-    const now = options.date.getTime()
-
     const attributes: Record<string, any> = {
-      fiberId: FiberId.threadName(options.fiberId)
+      fiberId: options.fiber.id
     }
 
-    const maybeSpan = Context.getOption(
-      FiberRefs.getOrDefault(options.context, FiberRef.currentContext),
-      Tracer.ParentSpan
-    )
+    const span = ServiceMap.getOrUndefined(options.fiber.services, Tracer.ParentSpan)
 
-    if (maybeSpan._tag === "Some") {
-      attributes.spanId = maybeSpan.value.spanId
-      attributes.traceId = maybeSpan.value.traceId
+    if (Predicate.isNotUndefined(span)) {
+      attributes.spanId = span.spanId
+      attributes.traceId = span.traceId
     }
 
-    for (const [key, value] of options.annotations) {
-      attributes[key] = unknownToAttributeValue(value)
-    }
-    for (const span of options.spans) {
-      attributes[`logSpan.${span.label}`] = `${now - span.startTime}ms`
-    }
+    // TODO: add back after log spans / annotations
+    // for (const [key, value] of options.annotations) {
+    //   attributes[key] = unknownToAttributeValue(value)
+    // }
+    // const now = options.date.getTime()
+    // for (const span of options.spans) {
+    //   attributes[`logSpan.${span.label}`] = `${now - span.startTime}ms`
+    // }
 
     const message = Arr.ensure(options.message).map(unknownToAttributeValue)
     otelLogger.emit({
       body: message.length === 1 ? message[0] : message,
-      severityText: options.logLevel.label,
-      severityNumber: options.logLevel.ordinal,
+      severityText: options.logLevel,
+      severityNumber: LogLevel.getOrdinal(options.logLevel),
       timestamp: options.date,
-      observedTimestamp: clock.unsafeCurrentTimeMillis(),
+      observedTimestamp: clock.currentTimeMillisUnsafe(),
       attributes
     })
   })
@@ -76,27 +73,27 @@ export const make: Effect.Effect<
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
-export const layerLoggerAdd: Layer.Layer<
-  never,
-  never,
-  OtelLoggerProvider
-> = Logger.addEffect(make)
-
-/**
- * @since 1.0.0
- * @category layers
- */
-export const layerLoggerReplace: Layer.Layer<
-  never,
-  never,
-  OtelLoggerProvider
-> = Logger.replaceEffect(Logger.defaultLogger, make)
+export const layer = (options: {
+  /**
+   * If set to `true`, the OpenTelemetry logger will be merged with existing
+   * loggers in the application.
+   *
+   * If set to `false`, the OpenTelemetry logger will replace all existing
+   * loggers in the application.
+   *
+   * Defaults to `true`.
+   */
+  readonly mergeWithExisting?: boolean | undefined
+}): Layer.Layer<never, never, OtelLoggerProvider> =>
+  Logger.layer([make], {
+    mergeWithExisting: options.mergeWithExisting ?? true
+  })
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
 export const layerLoggerProvider = (
   processor: Otel.LogRecordProcessor | NonEmptyReadonlyArray<Otel.LogRecordProcessor>,
@@ -104,10 +101,11 @@ export const layerLoggerProvider = (
     readonly shutdownTimeout?: DurationInput | undefined
   }
 ): Layer.Layer<OtelLoggerProvider, never, Resource> =>
-  Layer.scoped(
+  Layer.effect(
     OtelLoggerProvider,
-    Effect.flatMap(Resource, (resource) =>
-      Effect.acquireRelease(
+    Effect.gen(function*() {
+      const resource = yield* Resource
+      return yield* Effect.acquireRelease(
         Effect.sync(() =>
           new Otel.LoggerProvider({
             ...(config ?? undefined),
@@ -116,12 +114,11 @@ export const layerLoggerProvider = (
           })
         ),
         (provider) =>
-          Effect.promise(
-            () => provider.forceFlush().then(() => provider.shutdown())
-          ).pipe(
-            Effect.ignoreLogged,
+          Effect.promise(() => provider.forceFlush().then(() => provider.shutdown())).pipe(
+            Effect.ignore,
             Effect.interruptible,
             Effect.timeoutOption(config?.shutdownTimeout ?? 3000)
           )
-      ))
+      )
+    })
   )

package/src/Metrics.ts

@@ -2,39 +2,113 @@
  * @since 1.0.0
  */
 import type { MetricProducer, MetricReader } from "@opentelemetry/sdk-metrics"
-import type { NonEmptyReadonlyArray } from "effect/Array"
+import type * as Arr from "effect/Array"
 import type { DurationInput } from "effect/Duration"
-import type * as Effect from "effect/Effect"
+import * as Effect from "effect/Effect"
 import type { LazyArg } from "effect/Function"
-import type { Layer } from "effect/Layer"
+import * as Layer from "effect/Layer"
 import type * as Scope from "effect/Scope"
-import * as internal from "./internal/metrics.js"
-import type { Resource } from "./Resource.js"
+import { MetricProducerImpl } from "./internal/metrics.ts"
+import { Resource } from "./Resource.ts"
 
 /**
+ * Determines how metric values relate to the time interval over which they
+ * are aggregated.
+ *
+ * - `cumulative`: Reports total since a fixed start time. Each data point
+ *   depends on all previous measurements. This is the default behavior.
+ *
+ * - `delta`: Reports changes since the last export. Each interval is
+ *   independent with no dependency on previous measurements.
+ *
  * @since 1.0.0
- * @category producer
+ * @category Models
  */
-export const makeProducer: Effect.Effect<MetricProducer, never, Resource> = internal.makeProducer
+export type TemporalityPreference = "cumulative" | "delta"
 
 /**
+ * Creates an OpenTelemetry metric producer from Effect metrics.
+ *
  * @since 1.0.0
- * @category producer
+ * @category Constructors
  */
-export const registerProducer: (
+export const makeProducer = (temporality?: TemporalityPreference): Effect.Effect<MetricProducer, never, Resource> =>
+  Effect.gen(function*() {
+    const resource = yield* Resource
+    const services = yield* Effect.services<never>()
+    return new MetricProducerImpl(resource, services, temporality)
+  })
+
+/**
+ * Registers a metric producer with one or more metric readers.
+ *
+ * @since 1.0.0
+ * @category Constructors
+ */
+export const registerProducer = (
   self: MetricProducer,
-  metricReader: LazyArg<MetricReader | NonEmptyReadonlyArray<MetricReader>>
-) => Effect.Effect<Array<any>, never, Scope.Scope> = internal.registerProducer
+  metricReader: LazyArg<MetricReader | Arr.NonEmptyReadonlyArray<MetricReader>>,
+  options?: {
+    readonly shutdownTimeout?: DurationInput | undefined
+  }
+): Effect.Effect<Array<any>, never, Scope.Scope> =>
+  Effect.acquireRelease(
+    Effect.sync(() => {
+      const reader = metricReader()
+      const readers: Array<MetricReader> = Array.isArray(reader) ? reader : [reader] as any
+      readers.forEach((reader) => reader.setMetricProducer(self))
+      return readers
+    }),
+    (readers) =>
+      Effect.promise(() =>
+        Promise.all(
+          readers.map((reader) => reader.shutdown())
+        )
+      ).pipe(
+        Effect.ignore,
+        Effect.interruptible,
+        Effect.timeoutOption(options?.shutdownTimeout ?? 3000)
+      )
+  )
 
 /**
+ * Creates a Layer that registers a metric producer with metric readers.
+ *
+ * @example
+ * ```ts
+ * import { Metrics } from "@effect/opentelemetry"
+ * import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics"
+ * import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http"
+ *
+ * const metricExporter = new OTLPMetricExporter({ url: "<your-otel-url>" })
+ *
+ * // Use delta temporality for backends like Datadog or Dynatrace
+ * const metricsLayer = Metrics.layer(
+ *   () => new PeriodicExportingMetricReader({
+ *     exporter: metricExporter,
+ *     exportIntervalMillis: 10000
+ *   }),
+ *   { temporality: "delta" }
+ * )
+ *
+ * // Use cumulative temporality for backends like Prometheus (default)
+ * const cumulativeLayer = Metrics.layer(
+ *   () => new PeriodicExportingMetricReader({ exporter: metricExporter }),
+ *   { temporality: "cumulative" }
+ * )
+ * ```
+ *
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
-export const layer: (
-  evaluate: LazyArg<MetricReader | NonEmptyReadonlyArray<MetricReader>>,
+export const layer = (
+  evaluate: LazyArg<MetricReader | Arr.NonEmptyReadonlyArray<MetricReader>>,
   options?: {
-    readonly shutdownTimeout?:
-      | DurationInput
-      | undefined
+    readonly shutdownTimeout?: DurationInput | undefined
+    readonly temporality?: TemporalityPreference | undefined
   }
-) => Layer<never, never, Resource> = internal.layer
+): Layer.Layer<never, never, Resource> =>
+  Layer.effectDiscard(Effect.flatMap(
+    makeProducer(options?.temporality),
+    (producer) => registerProducer(producer, evaluate, options)
+  ))