@effect/opentelemetry 0.60.0 → 4.0.0-beta.0

package/src/WebSdk.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"
@@ -10,100 +10,108 @@ import type { NonEmptyReadonlyArray } from "effect/Array"
 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">
   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
   }
 }
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Layers
  */
 export const layerTracerProvider = (
   processor: SpanProcessor | NonEmptyReadonlyArray<SpanProcessor>,
   config?: Omit<TracerConfig, "resource">
 ): 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 WebTracerProvider({
-              ...(config ?? undefined),
-              resource,
-              spanProcessors: Array.isArray(processor) ? (processor as any) : [processor]
-            })
-            return provider
-          }),
-          (provider) => Effect.ignoreLogged(Effect.promise(() => provider.forceFlush().then(() => provider.shutdown())))
-        )
-    )
+    Effect.gen(function*() {
+      const resource = yield* Resource.Resource
+      return yield* Effect.acquireRelease(
+        Effect.sync(() => {
+          const provider = new WebTracerProvider({
+            ...(config ?? undefined),
+            resource,
+            spanProcessors: Array.isArray(processor) ? (processor as any) : [processor]
+          })
+          return provider
+        }),
+        (provider) =>
+          Effect.ignore(
+            Effect.promise(() => provider.forceFlush().then(() => provider.shutdown()))
+          )
+      )
+    })
   )
 
 /**
  * @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
    */
   <E, R>(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.layer(config.resource)
+        : Effect.sync(evaluate)
 
-        const TracerLive = isNonEmpty(config.spanProcessor)
-          ? Layer.provide(Tracer.layer, layerTracerProvider(config.spanProcessor, config.tracerConfig))
-          : Layer.empty
-
-        const LoggerLive = isNonEmpty(config.logRecordProcessor)
-          ? Layer.provide(
-            Logger.layerLoggerAdd,
-            Logger.layerLoggerProvider(config.logRecordProcessor, config.loggerProviderConfig)
-          )
-          : Layer.empty
+      const ResourceLive = Resource.layer(config.resource)
 
-        const MetricsLive = isNonEmpty(config.metricReader)
-          ? Metrics.layer(constant(config.metricReader))
-          : Layer.empty
+      const TracerLive = isNonEmpty(config.spanProcessor)
+        ? Layer.provide(
+          Tracer.layer,
+          layerTracerProvider(config.spanProcessor, config.tracerConfig)
+        )
+        : 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)
         )
-      }
-    )
+        : Layer.empty
+
+      const MetricsLive = isNonEmpty(config.metricReader)
+        ? Metrics.layer(constant(config.metricReader), {
+          temporality: config.metricTemporality
+        })
+        : Layer.empty
+
+      return Layer.mergeAll(TracerLive, MetricsLive, LoggerLive).pipe(
+        Layer.provideMerge(ResourceLive)
+      )
+    })
   )

package/src/index.ts

@@ -1,54 +1,35 @@
 /**
  * @since 1.0.0
  */
-export * as Logger from "./Logger.js"
 
-/**
- * @since 1.0.0
- */
-export * as Metrics from "./Metrics.js"
-
-/**
- * @since 1.0.0
- */
-export * as NodeSdk from "./NodeSdk.js"
-
-/**
- * @since 1.0.0
- */
-export * as Otlp from "./Otlp.js"
-
-/**
- * @since 1.0.0
- */
-export * as OtlpLogger from "./OtlpLogger.js"
+// @barrel: Auto-generated exports. Do not edit manually.
 
 /**
  * @since 1.0.0
  */
-export * as OtlpMetrics from "./OtlpMetrics.js"
+export * as Logger from "./Logger.ts"
 
 /**
  * @since 1.0.0
  */
-export * as OtlpResource from "./OtlpResource.js"
+export * as Metrics from "./Metrics.ts"
 
 /**
  * @since 1.0.0
  */
-export * as OtlpTracer from "./OtlpTracer.js"
+export * as NodeSdk from "./NodeSdk.ts"
 
 /**
  * @since 1.0.0
  */
-export * as Resource from "./Resource.js"
+export * as Resource from "./Resource.ts"
 
 /**
  * @since 1.0.0
  */
-export * as Tracer from "./Tracer.js"
+export * as Tracer from "./Tracer.ts"
 
 /**
  * @since 1.0.0
  */
-export * as WebSdk from "./WebSdk.js"
+export * as WebSdk from "./WebSdk.ts"

package/src/internal/attributes.ts

@@ -0,0 +1,21 @@
+import type * as Otel from "@opentelemetry/api"
+import * as Inspectable from "effect/Inspectable"
+
+/** @internal */
+export const recordToAttributes = (record: Record<string, unknown>): Otel.Attributes => {
+  const attributes: Otel.Attributes = {}
+  for (const [key, value] of Object.entries(record)) {
+    attributes[key] = unknownToAttributeValue(value)
+  }
+  return attributes
+}
+
+/** @internal */
+export const unknownToAttributeValue = (value: unknown): Otel.AttributeValue => {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value
+  } else if (typeof value === "bigint") {
+    return value.toString()
+  }
+  return Inspectable.toStringUnknown(value)
+}