effect 4.0.0-beta.76 → 4.0.0-beta.77

package/src/unstable/observability/OtlpMetrics.ts

@@ -25,14 +25,17 @@
  */
 import * as Arr from "../../Array.ts"
 import { Clock } from "../../Clock.ts"
+import * as Config from "../../Config.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Metric from "../../Metric.ts"
+import * as Option from "../../Option.ts"
 import type * as Scope from "../../Scope.ts"
 import type * as Headers from "../http/Headers.ts"
 import type { HttpBody } from "../http/HttpBody.ts"
 import type * as HttpClient from "../http/HttpClient.ts"
+import * as OtlpEnv from "./internal/otlpEnv.ts"
 import * as Exporter from "./OtlpExporter.ts"
 import type { Fixed64, KeyValue } from "./OtlpResource.ts"
 import * as OtlpResource from "./OtlpResource.ts"
@@ -475,6 +478,54 @@ export const layer = (options: {
   readonly temporality?: AggregationTemporality | undefined
 }): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization> => Layer.effectDiscard(make(options))
 
+/**
+ * Creates an OTLP metrics layer from OpenTelemetry configuration.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export const layerFromConfig = (options?: {
+  readonly resource?: {
+    readonly serviceName?: string | undefined
+    readonly serviceVersion?: string | undefined
+    readonly attributes?: Record<string, unknown>
+  } | undefined
+  readonly headers?: Headers.Input | undefined
+}): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization> =>
+  Effect.gen(function*() {
+    const { disabled, endpoint, exporters } = yield* Config.all({
+      disabled: Config.boolean("OTEL_SDK_DISABLED").pipe(Config.withDefault(false)),
+      endpoint: OtlpEnv.endpoint("METRICS"),
+      exporters: OtlpEnv.exporters("METRICS")
+    })
+    if (disabled || !endpoint || !exporters.includes("otlp")) {
+      return Layer.empty
+    }
+
+    const { baseTimeout, metricsTimeout, exportTimeout, exportInterval, temporalityPreference } = yield* Config.all({
+      baseTimeout: Config.option(Config.int("OTEL_EXPORTER_OTLP_TIMEOUT")),
+      metricsTimeout: Config.option(Config.int("OTEL_EXPORTER_OTLP_METRICS_TIMEOUT")),
+      exportTimeout: Config.option(Config.int("OTEL_METRIC_EXPORT_TIMEOUT")),
+      exportInterval: Config.option(Config.int("OTEL_METRIC_EXPORT_INTERVAL")),
+      temporalityPreference: Config.option(
+        Config.literals(["delta", "cumulative"], "OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE")
+      )
+    })
+
+    const shutdownTimeout = Option.firstSomeOf([metricsTimeout, baseTimeout, exportTimeout]).pipe(
+      Option.map((_) => Duration.millis(_))
+    )
+
+    return layer({
+      url: endpoint,
+      resource: options?.resource,
+      headers: options?.headers ?? (yield* OtlpEnv.headers("METRICS")),
+      exportInterval: Option.getOrUndefined(Option.map(exportInterval, (_) => Duration.millis(_))),
+      shutdownTimeout: Option.getOrUndefined(shutdownTimeout),
+      temporality: Option.getOrUndefined(temporalityPreference)
+    })
+  }).pipe(Effect.orDie, Layer.unwrap)
+
 /**
  * OTLP metrics payload serialized by `OtlpMetrics`.
  *

package/src/unstable/observability/OtlpResource.ts

@@ -26,10 +26,10 @@
  * **Gotchas**
  *
  * `service.name` is required because the signal exporters also use it as the
- * instrumentation scope name. Explicit options take precedence over
- * environment variables. `service.name` and `service.version` are normalized
- * into canonical OTLP attributes instead of being left in the custom attribute
- * map. Unsupported runtime values are formatted as strings.
+ * instrumentation scope name. OpenTelemetry environment variables take
+ * precedence over explicit options. `service.name` and `service.version` are
+ * normalized into canonical OTLP attributes instead of being left in the custom
+ * attribute map. Unsupported runtime values are formatted as strings.
  *
  * **See also**
  *
@@ -102,9 +102,9 @@ export const make = (options: {
  *
  * **Details**
  *
- * Explicit options override `OTEL_RESOURCE_ATTRIBUTES`, `OTEL_SERVICE_NAME`,
- * and `OTEL_SERVICE_VERSION`; missing required configuration is converted to a
- * defect.
+ * `OTEL_RESOURCE_ATTRIBUTES`, `OTEL_SERVICE_NAME`, and
+ * `OTEL_SERVICE_VERSION` override explicit options; missing required
+ * configuration is converted to a defect.
  *
  * @category constructors
  * @since 4.0.0
@@ -120,19 +120,30 @@ export const fromConfig: (
   readonly serviceVersion?: string | undefined
   readonly attributes?: Record<string, unknown> | undefined
 }) {
+  const env = yield* Config.schema(
+    Schema.UndefinedOr(Config.Record(Schema.String, Schema.String)),
+    "OTEL_RESOURCE_ATTRIBUTES"
+  )
+
+  const serviceName = (yield* Config.schema(Schema.UndefinedOr(Schema.String), "OTEL_SERVICE_NAME"))
+    ?? env?.["service.name"] as string | undefined
+    ?? options?.attributes?.["service.name"] as string | undefined
+    ?? options?.serviceName
+    ?? (yield* Config.string("OTEL_SERVICE_NAME"))
+
+  const serviceVersion = (yield* Config.schema(Schema.UndefinedOr(Schema.String), "OTEL_SERVICE_VERSION"))
+    ?? env?.["service.version"] as string | undefined
+    ?? options?.attributes?.["service.version"] as string | undefined
+    ?? options?.serviceVersion
+
   const attributes = {
-    ...(yield* Config.schema(
-      Schema.UndefinedOr(Config.Record(Schema.String, Schema.String)),
-      "OTEL_RESOURCE_ATTRIBUTES"
-    )),
-    ...options?.attributes
+    ...options?.attributes,
+    ...env
   }
-  const serviceName = options?.serviceName ?? attributes["service.name"] as string ??
-    (yield* Config.schema(Schema.String, "OTEL_SERVICE_NAME"))
+
   delete attributes["service.name"]
-  const serviceVersion = options?.serviceVersion ?? attributes["service.version"] as string ??
-    (yield* Config.schema(Schema.UndefinedOr(Schema.String), "OTEL_SERVICE_VERSION"))
   delete attributes["service.version"]
+
   return make({
     serviceName,
     serviceVersion,

package/src/unstable/observability/OtlpTracer.ts

@@ -24,6 +24,7 @@
  * @since 4.0.0
  */
 import * as Cause from "../../Cause.ts"
+import * as Config from "../../Config.ts"
 import type * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
@@ -36,6 +37,7 @@ import * as Tracer from "../../Tracer.ts"
 import type { ExtractTag, Mutable } from "../../Types.ts"
 import type * as Headers from "../http/Headers.ts"
 import type * as HttpClient from "../http/HttpClient.ts"
+import * as OtlpEnv from "./internal/otlpEnv.ts"
 import * as Exporter from "./OtlpExporter.ts"
 import type { KeyValue, Resource } from "./OtlpResource.ts"
 import { entriesToAttributes } from "./OtlpResource.ts"
@@ -147,6 +149,56 @@ export const layer: (options: {
   readonly shutdownTimeout?: Duration.Input | undefined
 }) => Layer.Layer<never, never, OtlpSerialization | HttpClient.HttpClient> = flow(make, Layer.effect(Tracer.Tracer))
 
+/**
+ * Creates an OTLP traces layer from OpenTelemetry configuration.
+ *
+ * @category layers
+ * @since 4.0.0
+ */
+export const layerFromConfig = (options?: {
+  readonly resource?: {
+    readonly serviceName?: string | undefined
+    readonly serviceVersion?: string | undefined
+    readonly attributes?: Record<string, unknown>
+  } | undefined
+  readonly headers?: Headers.Input | undefined
+  readonly context?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
+}): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization> =>
+  Effect.gen(function*() {
+    const { disabled, endpoint, exporters } = yield* Config.all({
+      disabled: Config.boolean("OTEL_SDK_DISABLED").pipe(Config.withDefault(false)),
+      endpoint: OtlpEnv.endpoint("TRACES"),
+      exporters: OtlpEnv.exporters("TRACES")
+    })
+
+    if (disabled || !endpoint || !exporters.includes("otlp")) {
+      return Layer.empty
+    }
+
+    const { baseTimeout, tracesTimeout, exportTimeout, scheduleDelay, maxBatchSize } = yield* Config.all({
+      baseTimeout: Config.option(Config.int("OTEL_EXPORTER_OTLP_TIMEOUT")),
+      tracesTimeout: Config.option(Config.int("OTEL_EXPORTER_OTLP_TRACES_TIMEOUT")),
+      exportTimeout: Config.option(Config.int("OTEL_BSP_EXPORT_TIMEOUT")),
+      scheduleDelay: Config.option(Config.int("OTEL_BSP_SCHEDULE_DELAY")),
+      maxBatchSize: Config.option(Config.int("OTEL_BSP_MAX_EXPORT_BATCH_SIZE"))
+    })
+
+    const shutdownTimeout = Option.firstSomeOf([tracesTimeout, baseTimeout, exportTimeout]).pipe(
+      Option.map((_) => Duration.millis(_))
+    )
+    const exportInterval = Option.map(scheduleDelay, (_) => Duration.millis(_))
+
+    return layer({
+      url: endpoint,
+      resource: options?.resource,
+      headers: options?.headers ?? (yield* OtlpEnv.headers("TRACES")),
+      exportInterval: Option.getOrUndefined(exportInterval),
+      maxBatchSize: Option.getOrUndefined(maxBatchSize),
+      context: options?.context,
+      shutdownTimeout: Option.getOrUndefined(shutdownTimeout)
+    })
+  }).pipe(Effect.orDie, Layer.unwrap)
+
 // internal
 
 interface SpanImpl extends Tracer.Span {

package/src/unstable/observability/internal/otlpEnv.ts

@@ -0,0 +1,58 @@
+import * as Config from "../../../Config.ts"
+import * as Effect from "../../../Effect.ts"
+import * as Option from "../../../Option.ts"
+import * as Schema from "../../../Schema.ts"
+import * as SchemaGetter from "../../../SchemaGetter.ts"
+import * as SchemaTransformation from "../../../SchemaTransformation.ts"
+import * as HttpClientRequest from "../../http/HttpClientRequest.ts"
+
+export type Signal = "LOGS" | "METRICS" | "TRACES"
+
+const ExporterList = Config.Array(
+  Schema.String.pipe(
+    Schema.decode(SchemaTransformation.trim()),
+    Schema.decode(SchemaTransformation.toLowerCase())
+  )
+).pipe(
+  Schema.decode({
+    decode: SchemaGetter.transform((_: ReadonlyArray<string>) => _.filter((_) => _ !== "")),
+    encode: SchemaGetter.passthrough()
+  })
+)
+
+const HeadersRecord = Config.Record(Schema.String, Schema.String)
+
+export const headers = (signal: Signal) =>
+  Config.make((provider) =>
+    Effect.gen(function*() {
+      const headers = yield* Config.option(Config.schema(HeadersRecord, `OTEL_EXPORTER_OTLP_${signal}_HEADERS`)).parse(
+        provider
+      )
+      if (Option.isSome(headers)) {
+        return headers.value
+      }
+
+      const fallback = yield* Config.option(Config.schema(HeadersRecord, "OTEL_EXPORTER_OTLP_HEADERS")).parse(provider)
+      return Option.getOrUndefined(fallback)
+    })
+  )
+
+export const endpoint = (signal: Signal) =>
+  Config.make((provider) =>
+    Effect.gen(function*() {
+      const endpoint = yield* Config.option(Config.string(`OTEL_EXPORTER_OTLP_${signal}_ENDPOINT`)).parse(provider)
+      if (Option.isSome(endpoint)) {
+        return endpoint.value
+      }
+
+      const fallback = yield* Config.option(Config.string("OTEL_EXPORTER_OTLP_ENDPOINT")).parse(provider)
+      return Option.isSome(fallback) && fallback.value !== ""
+        ? HttpClientRequest.appendUrl(HttpClientRequest.get(fallback.value), `/v1/${signal.toLowerCase()}`).url
+        : undefined
+    })
+  )
+
+export const exporters = (signal: Signal) =>
+  Config.option(Config.schema(ExporterList, `OTEL_${signal}_EXPORTER`)).pipe(
+    Config.map(Option.getOrElse<ReadonlyArray<string>>(() => []))
+  )