effect 4.0.0-beta.76 → 4.0.0-beta.78

package/dist/unstable/persistence/Redis.js.map

@@ -1 +1 @@
-{"version":3,"file":"Redis.js","names":["Cache","Context","Effect","Equal","constant","identity","Hash","Schema","Redis","Service","make","fnUntraced","options","scriptCache","lookup","script","send","lua","capacity","Number","POSITIVE_INFINITY","eval_","params","flatMap","get","sha","numberOfKeys","toString","map","param","String","eval","ErrorTypeId","RedisError","ErrorClass","_tag","tag","cause","Defect","ScriptTypeId","ScriptProto","result","withReturnType","symbol","that","random","f","Object","assign","create"],"sources":["../../../src/unstable/persistence/Redis.ts"],"sourcesContent":[null],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,OAAO,KAAKA,KAAK,MAAM,gBAAgB;AACvC,OAAO,KAAKC,OAAO,MAAM,kBAAkB;AAC3C,OAAO,KAAKC,MAAM,MAAM,iBAAiB;AACzC,OAAO,KAAKC,KAAK,MAAM,gBAAgB;AACvC,SAASC,QAAQ,EAAEC,QAAQ,QAAQ,mBAAmB;AACtD,OAAO,KAAKC,IAAI,MAAM,eAAe;AACrC,OAAO,KAAKC,MAAM,MAAM,iBAAiB;AAEzC;;;;;;AAMA,OAAM,MAAOC,KAAM,sBAAQP,OAAO,CAACQ,OAAO,EAStC,CAAC,0BAA0B,CAAC;AAEhC;;;;;;;;;;;AAWA,OAAO,MAAMC,IAAI,gBAAGR,MAAM,CAACS,UAAU,CAAC,WACpCC,OAEC;EAED,MAAMC,WAAW,GAAG,OAAOb,KAAK,CAACU,IAAI,CAAC;IACpCI,MAAM,EAAGC,MAAmB,IAAKH,OAAO,CAACI,IAAI,CAAS,QAAQ,EAAE,MAAM,EAAED,MAAM,CAACE,GAAG,CAAC;IACnFC,QAAQ,EAAEC,MAAM,CAACC;GAClB,CAAC;EAEF,MAAMC,KAAK,GAMTN,MAAsB,IAExB,CAAC,GAAGO,MAAwB,KAC1BpB,MAAM,CAACqB,OAAO,CAACvB,KAAK,CAACwB,GAAG,CAACX,WAAW,EAAEE,MAAM,CAAC,EAAGU,GAAG,IACjDb,OAAO,CAACI,IAAI,CACV,SAAS,EACTS,GAAG,EACHV,MAAM,CAACW,YAAY,CAAC,GAAGJ,MAAM,CAAC,CAACK,QAAQ,EAAE,EACzC,GAAGZ,MAAM,CAACO,MAAM,CAAC,GAAGA,MAAM,CAAC,CAACM,GAAG,CAAEC,KAAK,IAAKC,MAAM,CAACD,KAAK,CAAC,CAAC,CAC1D,CAAC;EAEN,OAAOxB,QAAQ,CAAmB;IAChCW,IAAI,EAAEJ,OAAO,CAACI,IAAI;IAClBe,IAAI,EAAEV;GACP,CAAC;AACJ,CAAC,CAAC;AAGF,MAAMW,WAAW,GAAgB,sCAAsC;AAEvE;;;;;;AAMA,OAAM,MAAOC,UAAW,sBAAQ1B,MAAM,CAAC2B,UAAU,CAAaF,WAAW,CAAC,CAAC;EACzEG,IAAI,eAAE5B,MAAM,CAAC6B,GAAG,CAAC,YAAY,CAAC;EAC9BC,KAAK,eAAE9B,MAAM,CAAC+B,MAAM;CACrB,CAAC;EACA;;;;;EAKS,CAACN,WAAW,IAAiBA,WAAW;;AAInD,MAAMO,YAAY,GAAiB,kCAAkC;AAoCrE,MAAMC,WAAW,GAAG;EAClB,CAACD,YAAY,GAAG;IACdjB,MAAM,EAAEjB,QAAQ;IAChBoC,MAAM,EAAEpC;GACT;EACDqC,cAAcA,CAAA;IACZ,OAAO,IAAI;EACb,CAAC;EACD,CAACvC,KAAK,CAACwC,MAAM,EAAEC,IAAa;IAC1B,OAAO,IAAI,KAAKA,IAAI;EACtB,CAAC;EACD,CAACtC,IAAI,CAACqC,MAAM,IAAC;IACX,OAAOrC,IAAI,CAACuC,MAAM,CAAC,IAAI,CAAC;EAC1B;CACD;AAED;;;;;;;;;;;AAWA,OAAO,MAAM9B,MAAM,GAAGA,CACpB+B,CAAgD,EAChDlC,OAGC,KAKDmC,MAAM,CAACC,MAAM,CAACD,MAAM,CAACE,MAAM,CAACT,WAAW,CAAC,EAAE;EACxC,GAAG5B,OAAO;EACVU,MAAM,EAAEwB,CAAC;EACTpB,YAAY,EAAE,OAAOd,OAAO,CAACc,YAAY,KAAK,QAAQ,GAAGtB,QAAQ,CAACQ,OAAO,CAACc,YAAY,CAAC,GAAGd,OAAO,CAACc;CACnG,CAAC","ignoreList":[]}
+{"version":3,"file":"Redis.js","names":["Cache","Context","Effect","Equal","constant","identity","Hash","Schema","Redis","Service","make","fnUntraced","options","scriptCache","lookup","script","send","lua","capacity","Number","POSITIVE_INFINITY","eval_","params","evalSha","sha","numberOfKeys","toString","map","param","String","get","pipe","flatMap","catchIf","error","cause","includes","refresh","eval","ErrorTypeId","RedisError","ErrorClass","_tag","tag","Defect","ScriptTypeId","ScriptProto","result","withReturnType","symbol","that","random","f","Object","assign","create"],"sources":["../../../src/unstable/persistence/Redis.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "effect",
   "type": "module",
-  "version": "4.0.0-beta.76",
+  "version": "4.0.0-beta.78",
   "license": "MIT",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "homepage": "https://effect.website",

package/src/Config.ts

@@ -82,6 +82,7 @@ import * as Predicate from "./Predicate.ts"
 import * as Rec from "./Record.ts"
 import * as Schema from "./Schema.ts"
 import * as SchemaAST from "./SchemaAST.ts"
+import * as SchemaGetter from "./SchemaGetter.ts"
 import * as SchemaIssue from "./SchemaIssue.ts"
 import * as SchemaParser from "./SchemaParser.ts"
 import * as SchemaTransformation from "./SchemaTransformation.ts"
@@ -1121,6 +1122,49 @@ export const Record = <K extends Schema.Record.Key, V extends Schema.Top>(key: K
   return Schema.Union([record, recordString])
 }
 
+/**
+ * @category schemas
+ * @since 4.0.0
+ */
+const ArrayConfig = <V extends Schema.Top>(value: V, options?: {
+  readonly separator?: string | undefined
+}) => {
+  const array = Schema.Array(value)
+  const separator = options?.separator ?? ","
+  const arrayString = Schema.String.pipe(
+    Schema.decodeTo(
+      Schema.Array(Schema.String),
+      {
+        decode: SchemaGetter.split(options),
+        encode: SchemaGetter.transform((input: ReadonlyArray<string>) => input.join(separator))
+      }
+    ),
+    Schema.decodeTo(array)
+  )
+
+  return Schema.Union([arrayString, array])
+}
+
+export {
+  /**
+   * Schema for array types that can also be parsed from a flat separated string.
+   *
+   * **When to use**
+   *
+   * Use when reading array values from a single env var, such as comma-separated
+   * exporter names.
+   *
+   * **Details**
+   *
+   * Accepts either a JSON-like array from the provider or a flat string like
+   * `"a,b,c"`. The `separator` defaults to `","` and can be customized.
+   *
+   * @category schemas
+   * @since 4.0.0
+   */
+  ArrayConfig as Array
+}
+
 // -----------------------------------------------------------------------------
 // constructors
 // -----------------------------------------------------------------------------

package/src/SchemaTransformation.ts

@@ -1112,7 +1112,7 @@ const encodeJsonError = (
 ): JsonError => {
   const encoded: JsonError = {
     name: input.name,
-    message: input.message
+    message: typeof input.message === "string" ? input.message : ""
   }
   if (options?.includeStack && typeof input.stack === "string") {
     encoded.stack = input.stack

package/src/unstable/observability/Otlp.ts

@@ -110,6 +110,42 @@ export const layer = (options: {
   )
 }
 
+/**
+ * Creates a combined OTLP layer for logs, metrics, and traces 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 tracerContext?: (<X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X) | undefined
+  readonly loggerExcludeLogSpans?: boolean | undefined
+  readonly loggerMergeWithExisting?: boolean | undefined
+}): Layer.Layer<never, never, HttpClient.HttpClient | OtlpSerialization.OtlpSerialization> =>
+  Layer.mergeAll(
+    OtlpLogger.layerFromConfig({
+      resource: options?.resource,
+      headers: options?.headers,
+      excludeLogSpans: options?.loggerExcludeLogSpans,
+      mergeWithExisting: options?.loggerMergeWithExisting
+    }),
+    OtlpMetrics.layerFromConfig({
+      resource: options?.resource,
+      headers: options?.headers
+    }),
+    OtlpTracer.layerFromConfig({
+      resource: options?.resource,
+      headers: options?.headers,
+      context: options?.tracerContext
+    })
+  )
+
 /**
  * Creates the combined OTLP logs, metrics, and traces layer using JSON
  * serialization.

package/src/unstable/observability/OtlpLogger.ts

@@ -37,15 +37,18 @@
 import * as Arr from "../../Array.ts"
 import * as Cause from "../../Cause.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 type * as Layer from "../../Layer.ts"
+import * as Layer from "../../Layer.ts"
 import * as Logger from "../../Logger.ts"
 import type * as LogLevel from "../../LogLevel.ts"
+import * as Option from "../../Option.ts"
 import { CurrentLogAnnotations, CurrentLogSpans } from "../../References.ts"
 import type * as Scope from "../../Scope.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 { AnyValue, Fixed64, KeyValue, Resource } from "./OtlpResource.ts"
 import * as OtlpResource from "./OtlpResource.ts"
@@ -144,6 +147,58 @@ export const layer = (options: {
     mergeWithExisting: options.mergeWithExisting ?? true
   })
 
+/**
+ * Creates an OTLP logs 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 excludeLogSpans?: boolean | undefined
+  readonly mergeWithExisting?: boolean | 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("LOGS"),
+      exporters: OtlpEnv.exporters("LOGS")
+    })
+
+    if (disabled || !endpoint || !exporters.includes("otlp")) {
+      return Layer.empty
+    }
+
+    const { baseTimeout, logsTimeout, exportTimeout, scheduleDelay, maxBatchSize } = yield* Config.all({
+      baseTimeout: Config.option(Config.int("OTEL_EXPORTER_OTLP_TIMEOUT")),
+      logsTimeout: Config.option(Config.int("OTEL_EXPORTER_OTLP_LOGS_TIMEOUT")),
+      exportTimeout: Config.option(Config.int("OTEL_BLRP_EXPORT_TIMEOUT")),
+      scheduleDelay: Config.option(Config.int("OTEL_BLRP_SCHEDULE_DELAY")),
+      maxBatchSize: Config.option(Config.int("OTEL_BLRP_MAX_EXPORT_BATCH_SIZE"))
+    })
+
+    const shutdownTimeout = Option.firstSomeOf([logsTimeout, baseTimeout, exportTimeout]).pipe(
+      Option.map((_) => Duration.millis(_))
+    )
+    const exportInterval = Option.map(scheduleDelay, (_) => Duration.millis(_))
+
+    return layer({
+      url: endpoint.toString(),
+      resource: options?.resource,
+      headers: options?.headers ?? (yield* OtlpEnv.headers("LOGS")),
+      exportInterval: Option.getOrUndefined(exportInterval),
+      maxBatchSize: Option.getOrUndefined(maxBatchSize),
+      shutdownTimeout: Option.getOrUndefined(shutdownTimeout),
+      excludeLogSpans: options?.excludeLogSpans,
+      mergeWithExisting: options?.mergeWithExisting
+    })
+  }).pipe(Effect.orDie, Layer.unwrap)
+
 /**
  * OTLP logs payload serialized by `OtlpLogger`.
  *

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,58 @@ 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").pipe(
+          Config.map(Duration.millis)
+        )
+      ),
+      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.toString(),
+      resource: options?.resource,
+      headers: options?.headers ?? (yield* OtlpEnv.headers("METRICS")),
+      exportInterval: Option.getOrUndefined(exportInterval),
+      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,59 @@ 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").pipe(
+          Config.map(Duration.millis)
+        )
+      ),
+      maxBatchSize: Config.option(Config.int("OTEL_BSP_MAX_EXPORT_BATCH_SIZE"))
+    })
+
+    const shutdownTimeout = Option.firstSomeOf([tracesTimeout, baseTimeout, exportTimeout]).pipe(
+      Option.map((_) => Duration.millis(_))
+    )
+
+    return layer({
+      url: endpoint.toString(),
+      resource: options?.resource,
+      headers: options?.headers ?? (yield* OtlpEnv.headers("TRACES")),
+      exportInterval: Option.getOrUndefined(scheduleDelay),
+      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,39 @@
+import * as Config from "../../../Config.ts"
+import * as Schema from "../../../Schema.ts"
+import * as SchemaGetter from "../../../SchemaGetter.ts"
+
+export type Signal = "LOGS" | "METRICS" | "TRACES"
+
+const ExporterList = Config.Array(Schema.String).pipe(
+  Schema.decode({
+    decode: SchemaGetter.transform((_) => _.map((_) => _.toLowerCase().trim()).filter((_) => _ !== "")),
+    encode: SchemaGetter.passthrough()
+  })
+)
+
+const HeadersRecord = Config.Record(Schema.String, Schema.String)
+
+export const headers = (signal: Signal) =>
+  Config.schema(HeadersRecord, `OTEL_EXPORTER_OTLP_${signal}_HEADERS`).pipe(
+    Config.orElse(() => Config.schema(HeadersRecord, "OTEL_EXPORTER_OTLP_HEADERS")),
+    Config.withDefault(undefined)
+  )
+
+export const endpoint = (signal: Signal) =>
+  Config.url(`OTEL_EXPORTER_OTLP_${signal}_ENDPOINT`).pipe(
+    Config.orElse(() =>
+      Config.url("OTEL_EXPORTER_OTLP_ENDPOINT").pipe(
+        Config.map((url) => {
+          const slash = url.pathname.endsWith("/") ? "" : "/"
+          url.pathname += `${slash}v1/${signal.toLowerCase()}`
+          return url
+        })
+      )
+    ),
+    Config.withDefault(undefined)
+  )
+
+export const exporters = (signal: Signal) =>
+  Config.schema(ExporterList, `OTEL_${signal}_EXPORTER`).pipe(
+    Config.withDefault<ReadonlyArray<string>>([])
+  )

package/src/unstable/persistence/RateLimiter.ts

@@ -630,11 +630,13 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
     },
     tokenBucket(options) {
       const key = `${prefix}${options.key}`
+      const lastRefillKey = `${key}:refill`
       const refillMillis = Duration.toMillis(options.refillRate)
       return Effect.clockWith((clock) =>
         Effect.mapError(
           tokenBucket(
             key,
+            lastRefillKey,
             options.tokens,
             refillMillis,
             options.limit,
@@ -687,17 +689,18 @@ return { next, nextpttl }
 const tokenBucketScript = Redis.script(
   (
     key: string,
+    lastRefillKey: string,
     tokens: number,
     refillMillis: number,
     limit: number,
     now: number,
     overflow: 0 | 1
-  ) => [key, tokens, refillMillis, limit, now, overflow],
+  ) => [key, lastRefillKey, tokens, refillMillis, limit, now, overflow],
   {
-    numberOfKeys: 1,
+    numberOfKeys: 2,
     lua: `
 local key = KEYS[1]
-local last_refill_key = key .. ":refill"
+local last_refill_key = KEYS[2]
 local tokens = tonumber(ARGV[1])
 local refill_ms = tonumber(ARGV[2])
 local limit = tonumber(ARGV[3])

package/src/unstable/persistence/Redis.ts

@@ -89,14 +89,22 @@ export const make = Effect.fnUntraced(function*(
   >(
     script: Script<Config>
   ) =>
-  (...params: Config["params"]): Effect.Effect<Config["result"], RedisError> =>
-    Effect.flatMap(Cache.get(scriptCache, script), (sha) =>
+  (...params: Config["params"]): Effect.Effect<Config["result"], RedisError> => {
+    const evalSha = (sha: string) =>
       options.send<Config["result"]>(
         "EVALSHA",
         sha,
         script.numberOfKeys(...params).toString(),
         ...script.params(...params).map((param) => String(param))
-      ))
+      )
+    return Cache.get(scriptCache, script).pipe(
+      Effect.flatMap(evalSha),
+      Effect.catchIf(
+        (error) => String(error.cause).includes("NOSCRIPT"),
+        () => Cache.refresh(scriptCache, script).pipe(Effect.flatMap(evalSha))
+      )
+    )
+  }
 
   return identity<Redis["Service"]>({
     send: options.send,