effect 4.0.0-beta.67 → 4.0.0-beta.69

package/dist/unstable/observability/index.d.ts

@@ -2,44 +2,200 @@
  * @since 4.0.0
  */
 /**
+ * Convenience layers for exporting Effect logs, metrics, and traces over
+ * OTLP/HTTP.
+ *
+ * This module wires the signal-specific OTLP logger, metrics, and tracer
+ * exporters together so an application can install full observability with a
+ * single layer. It is useful for services that report to an OpenTelemetry
+ * Collector, vendor OTLP endpoint, or local collector during development
+ * without configuring each signal independently.
+ *
+ * Pass `baseUrl` as the OTLP/HTTP root URL, such as `http://localhost:4318`;
+ * this module appends `/v1/logs`, `/v1/metrics`, and `/v1/traces` itself.
+ * Use `layerJson` or `layerProtobuf` when you want the serialization layer
+ * provided for you, or use `layer` with a custom `OtlpSerialization`
+ * implementation. Configure authentication with `headers`, provide resource
+ * metadata explicitly or through the standard OTEL resource environment
+ * variables, and tune batch size, export intervals, metric temporality, and
+ * shutdown timeout for the target backend so buffered telemetry is accepted
+ * and flushed before shutdown.
+ *
  * @since 4.0.0
  */
 export * as Otlp from "./Otlp.ts";
 /**
+ * Low-level OTLP/HTTP batch exporter used by the observability modules for
+ * logs, metrics, and traces.
+ *
+ * This module owns the scoped transport loop for already-encoded telemetry
+ * payloads: callers provide the OTLP endpoint, request headers, a body encoder,
+ * and batching settings, then push records that should be delivered to a
+ * collector. It is useful when implementing a concrete signal exporter, such
+ * as the OTLP logger or tracer, or when wiring a snapshot-based exporter like
+ * metrics into the same lifecycle and retry behavior.
+ *
+ * The exporter sends HTTP POST requests with the provided `HttpClient`, disables
+ * tracer propagation for its own traffic, retries transient failures, and
+ * honors numeric `retry-after` values on 429 responses. Exports run on
+ * `exportInterval`, flush during scope finalization up to `shutdownTimeout`,
+ * and can also be triggered early when the buffered item count reaches
+ * `maxBatchSize`.
+ *
+ * Use `maxBatchSize: "disabled"` only for pull-style exporters whose `body`
+ * callback builds a fresh payload without relying on drained buffered items,
+ * because pushed data is not cleared in that mode. After an unrecovered export
+ * failure the exporter drops the buffered batch and disables exporting for 60
+ * seconds, so choose intervals, batch sizes, headers, and shutdown timeouts with
+ * collector limits and process shutdown behavior in mind.
+ *
  * @since 4.0.0
  */
 export * as OtlpExporter from "./OtlpExporter.ts";
 /**
+ * Exports Effect log records to an OpenTelemetry Protocol (OTLP) logs endpoint.
+ *
+ * Use this module to send Effect log messages, annotations, fiber identifiers,
+ * causes, and active span identifiers to an OpenTelemetry Collector or OTLP
+ * compatible observability backend. `make` is useful for custom logger wiring,
+ * while `layer` installs the logger for an application and can merge it with
+ * any existing loggers.
+ *
+ * Records are buffered by the shared OTLP exporter. `exportInterval`,
+ * `maxBatchSize`, and `shutdownTimeout` control periodic exports, early batch
+ * flushes, and how long scope finalization waits for the final flush. Resource
+ * options are attached to every export and override OpenTelemetry resource
+ * environment variables, so ensure a `service.name` is available through the
+ * options, `OTEL_RESOURCE_ATTRIBUTES`, or `OTEL_SERVICE_NAME`; use `headers`
+ * for collector authentication and `excludeLogSpans` when log span duration
+ * attributes would be too noisy.
+ *
  * @since 4.0.0
  */
 export * as OtlpLogger from "./OtlpLogger.ts";
 /**
+ * OTLP/HTTP metrics exporter for Effect's Metric system.
+ *
+ * This module periodically snapshots the metrics registered in the current
+ * Effect context, serializes them as OTLP resource metrics, and posts them to a
+ * metrics endpoint such as an OpenTelemetry Collector or vendor OTLP intake.
+ * It is typically installed with `layer` in long-running services that already
+ * update `Metric` counters, gauges, histograms, frequencies, or summaries and
+ * need those values exported without adding instrumentation-specific plumbing
+ * to the application code.
+ *
+ * Pass the concrete `/v1/metrics` endpoint to `make` or `layer`, or use the
+ * higher-level `Otlp` module when you want `baseUrl` path construction for all
+ * signals. The exporter requires an `HttpClient` and an `OtlpSerialization`
+ * implementation, takes resource metadata from explicit options or standard
+ * OTEL resource environment variables, and uses the resource `service.name` as
+ * the instrumentation scope name. Choose `temporality` for the target backend:
+ * cumulative is the default, while delta derives per-export changes from the
+ * previous snapshot. Gauges always report their current value, and delta
+ * histograms and summaries keep interval counts and sums from previous
+ * snapshots, so tune export intervals and shutdown timeouts with backend
+ * expectations and process shutdown behavior in mind.
+ *
  * @since 4.0.0
  */
 export * as OtlpMetrics from "./OtlpMetrics.ts";
 /**
+ * Helpers and data types for describing the OTLP resource attached to exported
+ * logs, metrics, and traces.
+ *
+ * A resource identifies the service that produced telemetry and carries
+ * process- or deployment-level attributes that should be shared across every
+ * signal sent by the Effect OTLP logger, metrics exporter, and tracer. Use this
+ * module when building explicit resource metadata, reading the standard OTEL
+ * resource environment variables, or converting application metadata into OTLP
+ * `KeyValue` / `AnyValue` shapes before serialization.
+ *
+ * `service.name` is required because the signal exporters also use it as the
+ * instrumentation scope name. Explicit resource options take precedence over
+ * `OTEL_RESOURCE_ATTRIBUTES`, `OTEL_SERVICE_NAME`, and
+ * `OTEL_SERVICE_VERSION`; `service.name` and `service.version` are normalized
+ * through the service metadata inputs and re-added as canonical OTLP
+ * attributes rather than left in the custom attribute map. Attribute values are
+ * converted to OTLP scalar or array values where possible, with unsupported
+ * runtime values formatted as strings.
+ *
  * @since 4.0.0
  */
 export * as OtlpResource from "./OtlpResource.ts";
 /**
+ * Defines the serialization boundary used by the OTLP observability layers.
+ *
+ * `OtlpSerialization` converts Effect's in-memory OTLP trace, metric, and log
+ * data into `HttpBody` values so exporters can send them to collectors over
+ * OTLP/HTTP. Use this module to choose between the JSON encoding that is useful
+ * for debugging and collector endpoints that explicitly accept OTLP/HTTP JSON,
+ * and the protobuf encoding commonly expected by production OpenTelemetry
+ * collectors.
+ *
+ * The JSON layer writes the telemetry structures directly with
+ * `HttpBody.jsonUnsafe`; the protobuf layer encodes the same structures with
+ * the internal OTLP protobuf encoder and sets the `application/x-protobuf`
+ * content type. Endpoint paths, authentication headers, batching, retries, and
+ * shutdown flushing are handled by the OTLP exporter layers that consume this
+ * service, while this module focuses only on preserving the wire format chosen
+ * for traces, metrics, and logs.
+ *
  * @since 4.0.0
  */
 export * as OtlpSerialization from "./OtlpSerialization.ts";
 /**
+ * Exports Effect spans to an OpenTelemetry Protocol (OTLP) traces endpoint.
+ *
+ * This module creates a `Tracer.Tracer` backed by the shared OTLP/HTTP batch
+ * exporter, so Effect spans created with tracing APIs can be delivered to an
+ * OpenTelemetry Collector, vendor OTLP intake, or local development collector.
+ * Use `make` when you need to install the tracer manually, or `layer` when an
+ * application should provide it through the Effect environment.
+ *
+ * Pass a concrete traces endpoint, typically `/v1/traces`, or use the
+ * higher-level `Otlp` module when you want `baseUrl` path construction for all
+ * observability signals. The tracer exports only ended sampled spans, converts
+ * span attributes, events, links, status, parent identifiers, and failure
+ * causes into OTLP trace data, and groups every batch under the configured
+ * resource. Resource options are resolved through `OtlpResource`, so ensure a
+ * stable `service.name` is available through options or standard OTEL resource
+ * environment variables because it is also used as the instrumentation scope
+ * name. Tune `exportInterval`, `maxBatchSize`, and `shutdownTimeout` for the
+ * target backend and process shutdown behavior, provide `headers` for
+ * authentication or routing, choose an `OtlpSerialization` layer accepted by
+ * the endpoint, and use `context` only when a backend needs custom evaluation
+ * around the active span.
+ *
  * @since 4.0.0
  */
 export * as OtlpTracer from "./OtlpTracer.ts";
 /**
  * Prometheus metrics exporter for Effect's Metric system.
  *
- * This module provides functionality to export Effect metrics in the Prometheus
- * exposition format, making them scrapeable by Prometheus servers.
+ * This module snapshots the metrics registered in the current Effect context
+ * and renders them in the Prometheus text exposition format. It is intended for
+ * services that already record `Metric` counters, gauges, histograms,
+ * frequencies, or summaries and need a pull-based `/metrics` endpoint, or for
+ * integrations that want the formatted scrape body for a custom HTTP server.
+ *
+ * Use `format` when you need the current runtime's registry rendered as a
+ * string, `formatUnsafe` when you already have the `Context`, and `layerHttp`
+ * when an `HttpRouter` should serve `GET /metrics` directly. Formatting happens
+ * at scrape time; the module does not push metrics, schedule exports, or start
+ * an HTTP server on its own. Make sure the route is installed in the same
+ * application context that records the metrics you want to expose.
+ *
+ * Metric and label names are sanitized for Prometheus, optional prefixes and
+ * name mappers are applied before output, and metric attributes become labels.
+ * Keep attributes low-cardinality, avoid relying on invalid characters being
+ * preserved exactly, and configure Prometheus to scrape the route served by
+ * `layerHttp` with the expected `text/plain; version=0.0.4` response.
  *
  * **Example** (Exporting Prometheus metrics)
  *
  * ```ts
  * import { Effect, Metric } from "effect"
- * import * as PrometheusMetrics from "effect/unstable/observability/PrometheusMetrics"
+ * import { PrometheusMetrics } from "effect/unstable/observability"
  *
  * const program = Effect.gen(function*() {
  *   // Create and update metrics

package/dist/unstable/observability/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/unstable/observability/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;GAEG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;GAEG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;GAEG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;GAEG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C;;GAEG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;GAEG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAE3D;;GAEG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/unstable/observability/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA"}

package/dist/unstable/observability/index.js

@@ -3,44 +3,200 @@
  */
 // @barrel: Auto-generated exports. Do not edit manually.
 /**
+ * Convenience layers for exporting Effect logs, metrics, and traces over
+ * OTLP/HTTP.
+ *
+ * This module wires the signal-specific OTLP logger, metrics, and tracer
+ * exporters together so an application can install full observability with a
+ * single layer. It is useful for services that report to an OpenTelemetry
+ * Collector, vendor OTLP endpoint, or local collector during development
+ * without configuring each signal independently.
+ *
+ * Pass `baseUrl` as the OTLP/HTTP root URL, such as `http://localhost:4318`;
+ * this module appends `/v1/logs`, `/v1/metrics`, and `/v1/traces` itself.
+ * Use `layerJson` or `layerProtobuf` when you want the serialization layer
+ * provided for you, or use `layer` with a custom `OtlpSerialization`
+ * implementation. Configure authentication with `headers`, provide resource
+ * metadata explicitly or through the standard OTEL resource environment
+ * variables, and tune batch size, export intervals, metric temporality, and
+ * shutdown timeout for the target backend so buffered telemetry is accepted
+ * and flushed before shutdown.
+ *
  * @since 4.0.0
  */
 export * as Otlp from "./Otlp.js";
 /**
+ * Low-level OTLP/HTTP batch exporter used by the observability modules for
+ * logs, metrics, and traces.
+ *
+ * This module owns the scoped transport loop for already-encoded telemetry
+ * payloads: callers provide the OTLP endpoint, request headers, a body encoder,
+ * and batching settings, then push records that should be delivered to a
+ * collector. It is useful when implementing a concrete signal exporter, such
+ * as the OTLP logger or tracer, or when wiring a snapshot-based exporter like
+ * metrics into the same lifecycle and retry behavior.
+ *
+ * The exporter sends HTTP POST requests with the provided `HttpClient`, disables
+ * tracer propagation for its own traffic, retries transient failures, and
+ * honors numeric `retry-after` values on 429 responses. Exports run on
+ * `exportInterval`, flush during scope finalization up to `shutdownTimeout`,
+ * and can also be triggered early when the buffered item count reaches
+ * `maxBatchSize`.
+ *
+ * Use `maxBatchSize: "disabled"` only for pull-style exporters whose `body`
+ * callback builds a fresh payload without relying on drained buffered items,
+ * because pushed data is not cleared in that mode. After an unrecovered export
+ * failure the exporter drops the buffered batch and disables exporting for 60
+ * seconds, so choose intervals, batch sizes, headers, and shutdown timeouts with
+ * collector limits and process shutdown behavior in mind.
+ *
  * @since 4.0.0
  */
 export * as OtlpExporter from "./OtlpExporter.js";
 /**
+ * Exports Effect log records to an OpenTelemetry Protocol (OTLP) logs endpoint.
+ *
+ * Use this module to send Effect log messages, annotations, fiber identifiers,
+ * causes, and active span identifiers to an OpenTelemetry Collector or OTLP
+ * compatible observability backend. `make` is useful for custom logger wiring,
+ * while `layer` installs the logger for an application and can merge it with
+ * any existing loggers.
+ *
+ * Records are buffered by the shared OTLP exporter. `exportInterval`,
+ * `maxBatchSize`, and `shutdownTimeout` control periodic exports, early batch
+ * flushes, and how long scope finalization waits for the final flush. Resource
+ * options are attached to every export and override OpenTelemetry resource
+ * environment variables, so ensure a `service.name` is available through the
+ * options, `OTEL_RESOURCE_ATTRIBUTES`, or `OTEL_SERVICE_NAME`; use `headers`
+ * for collector authentication and `excludeLogSpans` when log span duration
+ * attributes would be too noisy.
+ *
  * @since 4.0.0
  */
 export * as OtlpLogger from "./OtlpLogger.js";
 /**
+ * OTLP/HTTP metrics exporter for Effect's Metric system.
+ *
+ * This module periodically snapshots the metrics registered in the current
+ * Effect context, serializes them as OTLP resource metrics, and posts them to a
+ * metrics endpoint such as an OpenTelemetry Collector or vendor OTLP intake.
+ * It is typically installed with `layer` in long-running services that already
+ * update `Metric` counters, gauges, histograms, frequencies, or summaries and
+ * need those values exported without adding instrumentation-specific plumbing
+ * to the application code.
+ *
+ * Pass the concrete `/v1/metrics` endpoint to `make` or `layer`, or use the
+ * higher-level `Otlp` module when you want `baseUrl` path construction for all
+ * signals. The exporter requires an `HttpClient` and an `OtlpSerialization`
+ * implementation, takes resource metadata from explicit options or standard
+ * OTEL resource environment variables, and uses the resource `service.name` as
+ * the instrumentation scope name. Choose `temporality` for the target backend:
+ * cumulative is the default, while delta derives per-export changes from the
+ * previous snapshot. Gauges always report their current value, and delta
+ * histograms and summaries keep interval counts and sums from previous
+ * snapshots, so tune export intervals and shutdown timeouts with backend
+ * expectations and process shutdown behavior in mind.
+ *
  * @since 4.0.0
  */
 export * as OtlpMetrics from "./OtlpMetrics.js";
 /**
+ * Helpers and data types for describing the OTLP resource attached to exported
+ * logs, metrics, and traces.
+ *
+ * A resource identifies the service that produced telemetry and carries
+ * process- or deployment-level attributes that should be shared across every
+ * signal sent by the Effect OTLP logger, metrics exporter, and tracer. Use this
+ * module when building explicit resource metadata, reading the standard OTEL
+ * resource environment variables, or converting application metadata into OTLP
+ * `KeyValue` / `AnyValue` shapes before serialization.
+ *
+ * `service.name` is required because the signal exporters also use it as the
+ * instrumentation scope name. Explicit resource options take precedence over
+ * `OTEL_RESOURCE_ATTRIBUTES`, `OTEL_SERVICE_NAME`, and
+ * `OTEL_SERVICE_VERSION`; `service.name` and `service.version` are normalized
+ * through the service metadata inputs and re-added as canonical OTLP
+ * attributes rather than left in the custom attribute map. Attribute values are
+ * converted to OTLP scalar or array values where possible, with unsupported
+ * runtime values formatted as strings.
+ *
  * @since 4.0.0
  */
 export * as OtlpResource from "./OtlpResource.js";
 /**
+ * Defines the serialization boundary used by the OTLP observability layers.
+ *
+ * `OtlpSerialization` converts Effect's in-memory OTLP trace, metric, and log
+ * data into `HttpBody` values so exporters can send them to collectors over
+ * OTLP/HTTP. Use this module to choose between the JSON encoding that is useful
+ * for debugging and collector endpoints that explicitly accept OTLP/HTTP JSON,
+ * and the protobuf encoding commonly expected by production OpenTelemetry
+ * collectors.
+ *
+ * The JSON layer writes the telemetry structures directly with
+ * `HttpBody.jsonUnsafe`; the protobuf layer encodes the same structures with
+ * the internal OTLP protobuf encoder and sets the `application/x-protobuf`
+ * content type. Endpoint paths, authentication headers, batching, retries, and
+ * shutdown flushing are handled by the OTLP exporter layers that consume this
+ * service, while this module focuses only on preserving the wire format chosen
+ * for traces, metrics, and logs.
+ *
  * @since 4.0.0
  */
 export * as OtlpSerialization from "./OtlpSerialization.js";
 /**
+ * Exports Effect spans to an OpenTelemetry Protocol (OTLP) traces endpoint.
+ *
+ * This module creates a `Tracer.Tracer` backed by the shared OTLP/HTTP batch
+ * exporter, so Effect spans created with tracing APIs can be delivered to an
+ * OpenTelemetry Collector, vendor OTLP intake, or local development collector.
+ * Use `make` when you need to install the tracer manually, or `layer` when an
+ * application should provide it through the Effect environment.
+ *
+ * Pass a concrete traces endpoint, typically `/v1/traces`, or use the
+ * higher-level `Otlp` module when you want `baseUrl` path construction for all
+ * observability signals. The tracer exports only ended sampled spans, converts
+ * span attributes, events, links, status, parent identifiers, and failure
+ * causes into OTLP trace data, and groups every batch under the configured
+ * resource. Resource options are resolved through `OtlpResource`, so ensure a
+ * stable `service.name` is available through options or standard OTEL resource
+ * environment variables because it is also used as the instrumentation scope
+ * name. Tune `exportInterval`, `maxBatchSize`, and `shutdownTimeout` for the
+ * target backend and process shutdown behavior, provide `headers` for
+ * authentication or routing, choose an `OtlpSerialization` layer accepted by
+ * the endpoint, and use `context` only when a backend needs custom evaluation
+ * around the active span.
+ *
  * @since 4.0.0
  */
 export * as OtlpTracer from "./OtlpTracer.js";
 /**
  * Prometheus metrics exporter for Effect's Metric system.
  *
- * This module provides functionality to export Effect metrics in the Prometheus
- * exposition format, making them scrapeable by Prometheus servers.
+ * This module snapshots the metrics registered in the current Effect context
+ * and renders them in the Prometheus text exposition format. It is intended for
+ * services that already record `Metric` counters, gauges, histograms,
+ * frequencies, or summaries and need a pull-based `/metrics` endpoint, or for
+ * integrations that want the formatted scrape body for a custom HTTP server.
+ *
+ * Use `format` when you need the current runtime's registry rendered as a
+ * string, `formatUnsafe` when you already have the `Context`, and `layerHttp`
+ * when an `HttpRouter` should serve `GET /metrics` directly. Formatting happens
+ * at scrape time; the module does not push metrics, schedule exports, or start
+ * an HTTP server on its own. Make sure the route is installed in the same
+ * application context that records the metrics you want to expose.
+ *
+ * Metric and label names are sanitized for Prometheus, optional prefixes and
+ * name mappers are applied before output, and metric attributes become labels.
+ * Keep attributes low-cardinality, avoid relying on invalid characters being
+ * preserved exactly, and configure Prometheus to scrape the route served by
+ * `layerHttp` with the expected `text/plain; version=0.0.4` response.
  *
  * **Example** (Exporting Prometheus metrics)
  *
  * ```ts
  * import { Effect, Metric } from "effect"
- * import * as PrometheusMetrics from "effect/unstable/observability/PrometheusMetrics"
+ * import { PrometheusMetrics } from "effect/unstable/observability"
  *
  * const program = Effect.gen(function*() {
  *   // Create and update metrics

package/dist/unstable/observability/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["Otlp","OtlpExporter","OtlpLogger","OtlpMetrics","OtlpResource","OtlpSerialization","OtlpTracer","PrometheusMetrics"],"sources":["../../../src/unstable/observability/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAIA;AAEA;;;AAGA,OAAO,KAAKA,IAAI,MAAM,WAAW;AAEjC;;;AAGA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;AAGA,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAE7C;;;AAGA,OAAO,KAAKC,WAAW,MAAM,kBAAkB;AAE/C;;;AAGA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;AAGA,OAAO,KAAKC,iBAAiB,MAAM,wBAAwB;AAE3D;;;AAGA,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,OAAO,KAAKC,iBAAiB,MAAM,wBAAwB","ignoreList":[]}
+{"version":3,"file":"index.js","names":["Otlp","OtlpExporter","OtlpLogger","OtlpMetrics","OtlpResource","OtlpSerialization","OtlpTracer","PrometheusMetrics"],"sources":["../../../src/unstable/observability/index.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAIA;AAEA;;;;;;;;;;;;;;;;;;;;;;AAsBA,OAAO,KAAKA,IAAI,MAAM,WAAW;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,KAAKC,WAAW,MAAM,kBAAkB;AAE/C;;;;;;;;;;;;;;;;;;;;;;AAsBA,OAAO,KAAKC,YAAY,MAAM,mBAAmB;AAEjD;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,KAAKC,iBAAiB,MAAM,wBAAwB;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,OAAO,KAAKC,UAAU,MAAM,iBAAiB;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,OAAO,KAAKC,iBAAiB,MAAM,wBAAwB","ignoreList":[]}

package/dist/unstable/persistence/KeyValueStore.d.ts

@@ -36,7 +36,7 @@ declare const TypeId: "~effect/persistence/KeyValueStore";
 /**
  * Effectful key/value store service for string and binary values.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export interface KeyValueStore {
@@ -88,7 +88,7 @@ export interface KeyValueStore {
  * Primitive operations are required, while helpers such as `has`, `isEmpty`,
  * and `modify` can be supplied to override the defaults.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export type MakeOptions = Partial<KeyValueStore> & {
@@ -121,7 +121,7 @@ export type MakeOptions = Partial<KeyValueStore> & {
  * Implementation callbacks for adapting a string-only backing store into a
  * `KeyValueStore`.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export type MakeStringOptions = Partial<Omit<KeyValueStore, "set">> & {
@@ -154,7 +154,7 @@ declare const KeyValueStoreError_base: new <A extends Record<string, any> = {}>(
  * Error raised by key/value store operations, including the failed method,
  * optional key, message, and cause.
  *
- * @category Errors
+ * @category errors
  * @since 4.0.0
  */
 export declare class KeyValueStoreError extends KeyValueStoreError_base<{

package/dist/unstable/persistence/KeyValueStore.js

@@ -42,7 +42,7 @@ const ErrorTypeId = "~effect/persistence/KeyValueStore/KeyValueStoreError";
  * Error raised by key/value store operations, including the failed method,
  * optional key, message, and cause.
  *
- * @category Errors
+ * @category errors
  * @since 4.0.0
  */
 export class KeyValueStoreError extends /*#__PURE__*/Data.TaggedError("KeyValueStoreError") {

package/dist/unstable/persistence/Persistable.d.ts

@@ -41,7 +41,7 @@ export declare const symbol: "~effect/persistence/Persistable";
  * A primary-keyed request value whose success and error results can be
  * serialized for persistence.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export interface Persistable<A extends Schema.Top, E extends Schema.Top> extends PrimaryKey.PrimaryKey {
@@ -53,35 +53,35 @@ export interface Persistable<A extends Schema.Top, E extends Schema.Top> extends
 /**
  * Any persistable request regardless of its success and error schemas.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export type Any = Persistable<Schema.Top, Schema.Top>;
 /**
  * Extracts the success schema from a persistable request.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export type SuccessSchema<A extends Any> = A["~effect/persistence/Persistable"]["success"];
 /**
  * Extracts the success value type from a persistable request.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export type Success<A extends Any> = A["~effect/persistence/Persistable"]["success"]["Type"];
 /**
  * Extracts the error schema from a persistable request.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export type ErrorSchema<A extends Any> = A["~effect/persistence/Persistable"]["error"];
 /**
  * Extracts the error value type from a persistable request.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export type Error<A extends Any> = A["~effect/persistence/Persistable"]["error"]["Type"];
@@ -89,14 +89,14 @@ export type Error<A extends Any> = A["~effect/persistence/Persistable"]["error"]
  * Services required to decode a persisted success or error value for the
  * request.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export type DecodingServices<A extends Any> = A["~effect/persistence/Persistable"]["success"]["DecodingServices"] | A["~effect/persistence/Persistable"]["error"]["DecodingServices"];
 /**
  * Services required to encode a success or error value for persistence.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export type EncodingServices<A extends Any> = A["~effect/persistence/Persistable"]["success"]["EncodingServices"] | A["~effect/persistence/Persistable"]["error"]["EncodingServices"];
@@ -104,7 +104,7 @@ export type EncodingServices<A extends Any> = A["~effect/persistence/Persistable
  * All schema services required to encode and decode a persistable request
  * result.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export type Services<A extends Any> = A["~effect/persistence/Persistable"]["success"]["DecodingServices"] | A["~effect/persistence/Persistable"]["success"]["EncodingServices"] | A["~effect/persistence/Persistable"]["error"]["DecodingServices"] | A["~effect/persistence/Persistable"]["error"]["EncodingServices"];
@@ -112,7 +112,7 @@ export type Services<A extends Any> = A["~effect/persistence/Persistable"]["succ
  * Computes the time to live for a persisted result from the result `Exit` and
  * request value.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export type TimeToLiveFn<K extends Any> = (exit: Exit.Exit<Success<K>, Error<K>>, request: K) => Duration.Input;
@@ -122,7 +122,7 @@ export type TimeToLiveFn<K extends Any> = (exit: Exit.Exit<Success<K>, Error<K>>
  * The generated class stores the supplied tag, derives its primary key from
  * the payload, and carries schemas for persisted success and error exits.
  *
- * @category Constructors
+ * @category constructors
  * @since 4.0.0
  */
 export declare const Class: <Config extends {

package/dist/unstable/persistence/Persistable.js

@@ -15,7 +15,7 @@ export const symbol = "~effect/persistence/Persistable";
  * The generated class stores the supplied tag, derives its primary key from
  * the payload, and carries schemas for persisted success and error exits.
  *
- * @category Constructors
+ * @category constructors
  * @since 4.0.0
  */
 export const Class = () => (tag, options) => {

package/dist/unstable/persistence/PersistedCache.d.ts

@@ -28,7 +28,7 @@ declare const TypeId: "~effect/persistence/PersistedCache";
 /**
  * Cache that combines an in-memory `Cache` with a persisted backing store.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export interface PersistedCache<K extends Persistable.Any, out R = never> {
@@ -44,7 +44,7 @@ export interface PersistedCache<K extends Persistable.Any, out R = never> {
  * exits with the configured persistent TTL, and also keeps a scoped in-memory
  * cache with its own capacity and TTL.
  *
- * @category Constructors
+ * @category constructors
  * @since 4.0.0
  */
 export declare const make: <K extends Persistable.Any, R = never, ServiceMode extends "lookup" | "construction" = never>(lookup: (key: K) => Effect.Effect<Persistable.Success<K>, Persistable.Error<K>, R>, options: {

package/dist/unstable/persistence/PersistedCache.js

@@ -31,7 +31,7 @@ const TypeId = "~effect/persistence/PersistedCache";
  * exits with the configured persistent TTL, and also keeps a scoped in-memory
  * cache with its own capacity and TTL.
  *
- * @category Constructors
+ * @category constructors
  * @since 4.0.0
  */
 export const make = /*#__PURE__*/Effect.fnUntraced(function* (lookup, options) {

package/dist/unstable/persistence/PersistedQueue.d.ts

@@ -11,14 +11,14 @@ import * as Redis from "./Redis.ts";
 /**
  * Runtime type identifier for `PersistedQueue` values.
  *
- * @category Type IDs
+ * @category type IDs
  * @since 4.0.0
  */
 export declare const TypeId: TypeId;
 /**
  * Type-level identifier used to brand `PersistedQueue` values.
  *
- * @category Type IDs
+ * @category type IDs
  * @since 4.0.0
  */
 export type TypeId = "~effect/persistence/PersistedQueue";
@@ -29,7 +29,7 @@ export type TypeId = "~effect/persistence/PersistedQueue";
  * marking it complete on success or retrying it until the maximum attempts is
  * reached.
  *
- * @category Models
+ * @category models
  * @since 4.0.0
  */
 export interface PersistedQueue<in out A, out R = never> {
@@ -110,14 +110,14 @@ export declare const layer: Layer.Layer<PersistedQueueFactory, never, PersistedQ
 /**
  * Runtime type identifier for `PersistedQueueError`.
  *
- * @category Errors
+ * @category errors
  * @since 4.0.0
  */
 export declare const ErrorTypeId: ErrorTypeId;
 /**
  * Type-level identifier used to brand `PersistedQueueError` values.
  *
- * @category Errors
+ * @category errors
  * @since 4.0.0
  */
 export type ErrorTypeId = "~@effect/experimental/PersistedQueue/PersistedQueueError";
@@ -129,7 +129,7 @@ declare const PersistedQueueError_base: Schema.Class<PersistedQueueError, Schema
 /**
  * Error raised by persisted queue store operations.
  *
- * @category Errors
+ * @category errors
  * @since 4.0.0
  */
 export declare class PersistedQueueError extends PersistedQueueError_base {