@effect/opentelemetry 0.60.0 → 4.0.0-beta.0

package/src/NodeSdk.ts

@@ -1,7 +1,7 @@
 /**
  * @since 1.0.0
  */
-import type * as OtelApi from "@opentelemetry/api"
+import type * as Otel from "@opentelemetry/api"
 import type { LoggerProviderConfig, LogRecordProcessor } from "@opentelemetry/sdk-logs"
 import type { MetricReader } from "@opentelemetry/sdk-metrics"
 import type { SpanProcessor, TracerConfig } from "@opentelemetry/sdk-trace-base"
@@ -11,33 +11,35 @@ import type { DurationInput } from "effect/Duration"
 import * as Effect from "effect/Effect"
 import { constant, type LazyArg } from "effect/Function"
 import * as Layer from "effect/Layer"
-import { isNonEmpty } from "./internal/utils.js"
-import * as Logger from "./Logger.js"
-import * as Metrics from "./Metrics.js"
-import * as Resource from "./Resource.js"
-import * as Tracer from "./Tracer.js"
+import { isNonEmpty } from "./internal/utilities.ts"
+import * as Logger from "./Logger.ts"
+import * as Metrics from "./Metrics.ts"
+import * as Resource from "./Resource.ts"
+import * as Tracer from "./Tracer.ts"
 
 /**
  * @since 1.0.0
- * @category model
+ * @category Models
  */
 export interface Configuration {
   readonly spanProcessor?: SpanProcessor | ReadonlyArray<SpanProcessor> | undefined
   readonly tracerConfig?: Omit<TracerConfig, "resource"> | undefined
   readonly metricReader?: MetricReader | ReadonlyArray<MetricReader> | undefined
+  readonly metricTemporality?: Metrics.TemporalityPreference | undefined
   readonly logRecordProcessor?: LogRecordProcessor | ReadonlyArray<LogRecordProcessor> | undefined
   readonly loggerProviderConfig?: Omit<LoggerProviderConfig, "resource"> | undefined
+  readonly loggerMergeWithExisting?: boolean | undefined
   readonly resource?: {
     readonly serviceName: string
     readonly serviceVersion?: string
-    readonly attributes?: OtelApi.Attributes
+    readonly attributes?: Otel.Attributes
   } | undefined
   readonly shutdownTimeout?: DurationInput | undefined
 }
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
 export const layerTracerProvider = (
   processor: SpanProcessor | NonEmptyReadonlyArray<SpanProcessor>,
@@ -45,85 +47,86 @@ export const layerTracerProvider = (
     readonly shutdownTimeout?: DurationInput | undefined
   }
 ): Layer.Layer<Tracer.OtelTracerProvider, never, Resource.Resource> =>
-  Layer.scoped(
+  Layer.effect(
     Tracer.OtelTracerProvider,
-    Effect.flatMap(
-      Resource.Resource,
-      (resource) =>
-        Effect.acquireRelease(
-          Effect.sync(() => {
-            const provider = new NodeTracerProvider({
-              ...(config ?? undefined),
-              resource,
-              spanProcessors: Array.isArray(processor) ? (processor as any) : [processor]
-            })
-            return provider
-          }),
-          (provider) =>
-            Effect.promise(() => provider.forceFlush().then(() => provider.shutdown())).pipe(
-              Effect.ignoreLogged,
-              Effect.interruptible,
-              Effect.timeoutOption(config?.shutdownTimeout ?? 3000)
-            )
-        )
-    )
+    Effect.gen(function*() {
+      const resource = yield* Resource.Resource
+      return yield* Effect.acquireRelease(
+        Effect.sync(() => {
+          const provider = new NodeTracerProvider({
+            ...(config ?? undefined),
+            resource,
+            spanProcessors: Array.isArray(processor) ? (processor as any) : [processor]
+          })
+          return provider
+        }),
+        (provider) =>
+          Effect.promise(() => provider.forceFlush().then(() => provider.shutdown())).pipe(
+            Effect.ignore,
+            Effect.interruptible,
+            Effect.timeoutOption(config?.shutdownTimeout ?? 3000)
+          )
+      )
+    })
   )
 
 /**
  * @since 1.0.0
- * @category layer
+ * @category Layers
  */
 export const layer: {
   /**
    * @since 1.0.0
-   * @category layer
+   * @category Layers
    */
   (evaluate: LazyArg<Configuration>): Layer.Layer<Resource.Resource>
   /**
    * @since 1.0.0
-   * @category layer
+   * @category Layers
    */
   <R, E>(evaluate: Effect.Effect<Configuration, E, R>): Layer.Layer<Resource.Resource, E, R>
 } = (
   evaluate: LazyArg<Configuration> | Effect.Effect<Configuration, any, any>
 ): Layer.Layer<Resource.Resource> =>
-  Layer.unwrapEffect(
-    Effect.map(
-      Effect.isEffect(evaluate)
+  Layer.unwrap(
+    Effect.gen(function*() {
+      const config = yield* Effect.isEffect(evaluate)
         ? evaluate as Effect.Effect<Configuration>
-        : Effect.sync(evaluate),
-      (config) => {
-        const ResourceLive = Resource.layerFromEnv(config.resource && Resource.configToAttributes(config.resource))
+        : Effect.sync(evaluate)
 
-        const TracerLive = isNonEmpty(config.spanProcessor)
-          ? Layer.provide(
-            Tracer.layer,
-            layerTracerProvider(config.spanProcessor, {
-              ...config.tracerConfig,
-              shutdownTimeout: config.shutdownTimeout
-            })
-          )
-          : Layer.empty
+      const ResourceLive = Resource.layerFromEnv(config.resource && Resource.configToAttributes(config.resource))
 
-        const MetricsLive = isNonEmpty(config.metricReader)
-          ? Metrics.layer(constant(config.metricReader), config)
-          : Layer.empty
+      const TracerLive = isNonEmpty(config.spanProcessor)
+        ? Layer.provide(
+          Tracer.layer,
+          layerTracerProvider(config.spanProcessor, {
+            ...config.tracerConfig,
+            shutdownTimeout: config.shutdownTimeout
+          })
+        )
+        : Layer.empty
 
-        const LoggerLive = isNonEmpty(config.logRecordProcessor)
-          ? Layer.provide(
-            Logger.layerLoggerAdd,
-            Logger.layerLoggerProvider(config.logRecordProcessor, {
-              ...config.loggerProviderConfig,
-              shutdownTimeout: config.shutdownTimeout
-            })
-          )
-          : Layer.empty
+      const MetricsLive = isNonEmpty(config.metricReader)
+        ? Metrics.layer(constant(config.metricReader), {
+          shutdownTimeout: config.shutdownTimeout,
+          temporality: config.metricTemporality
+        })
+        : Layer.empty
 
-        return Layer.mergeAll(TracerLive, MetricsLive, LoggerLive).pipe(
-          Layer.provideMerge(ResourceLive)
+      const LoggerLive = isNonEmpty(config.logRecordProcessor)
+        ? Layer.provide(
+          Logger.layer({ mergeWithExisting: config.loggerMergeWithExisting }),
+          Logger.layerLoggerProvider(config.logRecordProcessor, {
+            ...config.loggerProviderConfig,
+            shutdownTimeout: config.shutdownTimeout
+          })
         )
-      }
-    )
+        : Layer.empty
+
+      return Layer.mergeAll(TracerLive, MetricsLive, LoggerLive).pipe(
+        Layer.provideMerge(ResourceLive)
+      )
+    })
   )
 
 /**

package/src/Resource.ts

@@ -6,28 +6,22 @@ import * as Resources from "@opentelemetry/resources"
 import * as OtelSemConv from "@opentelemetry/semantic-conventions"
 import * as Arr from "effect/Array"
 import * as Config from "effect/Config"
-import { GenericTag } from "effect/Context"
 import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
+import * as ServiceMap from "effect/ServiceMap"
 
 /**
  * @since 1.0.0
- * @category identifier
+ * @category Services
  */
-export interface Resource {
-  readonly _: unique symbol
-}
-
-/**
- * @since 1.0.0
- * @category tag
- */
-export const Resource = GenericTag<Resource, Resources.Resource>("@effect/opentelemetry/Resource")
+export class Resource extends ServiceMap.Service<
+  Resource,
+  Resources.Resource
+>()("@effect/opentelemetry/Resource") {}
 
 /**
  * @since 1.0.0
- * @category layer
+ * @category Layers
  */
 export const layer = (config: {
   readonly serviceName: string
@@ -41,7 +35,7 @@ export const layer = (config: {
 
 /**
  * @since 1.0.0
- * @category config
+ * @category Configuration
  */
 export const configToAttributes = (options: {
   readonly serviceName: string
@@ -64,7 +58,7 @@ export const configToAttributes = (options: {
 
 /**
  * @since 1.0.0
- * @category layer
+ * @category Layers
  */
 export const layerFromEnv = (
   additionalAttributes?:
@@ -74,10 +68,9 @@ export const layerFromEnv = (
   Layer.effect(
     Resource,
     Effect.gen(function*() {
-      const serviceName = yield* pipe(Config.string("OTEL_SERVICE_NAME"), Config.option, Effect.orDie)
-      const attributes = yield* pipe(
-        Config.string("OTEL_RESOURCE_ATTRIBUTES"),
-        Config.withDefault(""),
+      const serviceName = yield* Config.option(Config.string("OTEL_SERVICE_NAME"))
+      const attributes = yield* Config.string("OTEL_RESOURCE_ATTRIBUTES").pipe(
+        Config.withDefault(() => ""),
         Config.map((s) => {
           const attrs = s.split(",")
           return Arr.reduce(attrs, {} as OtelApi.Attributes, (acc, attr) => {
@@ -88,8 +81,7 @@ export const layerFromEnv = (
             acc[parts[0].trim()] = parts[1].trim()
             return acc
           })
-        }),
-        Effect.orDie
+        })
       )
       if (serviceName._tag === "Some") {
         attributes[OtelSemConv.ATTR_SERVICE_NAME] = serviceName.value
@@ -98,12 +90,12 @@ export const layerFromEnv = (
         Object.assign(attributes, additionalAttributes)
       }
       return Resources.resourceFromAttributes(attributes)
-    })
+    }).pipe(Effect.orDie)
   )
 
 /**
- * @since 2.0.0
- * @category layer
+ * @since 1.0.0
+ * @category Layers
  */
 export const layerEmpty = Layer.succeed(
   Resource,