@smthrs/observability 0.34.0 → 1.0.0-rc.12

package/dist/cjs/Metric.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Effect metric registry for flows runtime signals.
+ *
+ * @since 0.1.0
+ */
+import * as Metric from "effect/Metric";
+/**
+ * Counts flow runs that reached a terminal state.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const runThroughput: Metric.Counter<number>;
+/**
+ * The number of execution seats currently held.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const activeSeats: Metric.Gauge<number>;
+/**
+ * Counts runs parked because a quota was exhausted.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const quotaParks: Metric.Counter<number>;
+/**
+ * Counts agent answers refused by their declared output schema.
+ *
+ * @category metrics
+ * @since 1.0.0-rc.1
+ */
+export declare const structuredOutputRejections: Metric.Counter<number>;
+/**
+ * Counts agent steps that failed after spending every output correction.
+ *
+ * @category metrics
+ * @since 1.0.0-rc.1
+ */
+export declare const structuredOutputExhausted: Metric.Counter<number>;
+/**
+ * Counts operational log records lost before durable delivery.
+ *
+ * Advances once per record dropped by a saturated forwarding queue, once per
+ * journal delivery failure, and once per defect the forwarding worker recovers
+ * from, so telemetry loss is distinguishable from an idle logger.
+ *
+ * @category metrics
+ * @since 1.0.0-rc.0
+ */
+export declare const droppedLogRecords: Metric.Counter<number>;
+/**
+ * All metrics declared by this package.
+ *
+ * @category registry
+ * @since 0.1.0
+ */
+export declare const registry: {
+    readonly runThroughput: Metric.Counter<number>;
+    readonly activeSeats: Metric.Gauge<number>;
+    readonly quotaParks: Metric.Counter<number>;
+    readonly structuredOutputRejections: Metric.Counter<number>;
+    readonly structuredOutputExhausted: Metric.Counter<number>;
+    readonly droppedLogRecords: Metric.Counter<number>;
+};
+//# sourceMappingURL=Metric.d.ts.map

package/dist/cjs/Metric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Metric.d.ts","sourceRoot":"","sources":["../../src/Metric.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC;;;;;GAKG;AACH,eAAO,MAAM,aAAa,wBAExB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,sBAEtB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,wBAErB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,wBAErC,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,wBAEpC,CAAA;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,wBAE5B,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;;;;;;;CAOX,CAAA"}

package/dist/cjs/Metric.js

@@ -0,0 +1,68 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Metric_exports = {};
+__export(Metric_exports, {
+  activeSeats: () => activeSeats,
+  droppedLogRecords: () => droppedLogRecords,
+  quotaParks: () => quotaParks,
+  registry: () => registry,
+  runThroughput: () => runThroughput,
+  structuredOutputExhausted: () => structuredOutputExhausted,
+  structuredOutputRejections: () => structuredOutputRejections
+});
+module.exports = __toCommonJS(Metric_exports);
+var Metric = __toESM(require("effect/Metric"), 1);
+const prefix = "flows_";
+const runThroughput = Metric.counter(`${prefix}run_throughput`, {
+  description: "Completed flow runs"
+});
+const activeSeats = Metric.gauge(`${prefix}seat_active`, {
+  description: "Currently active execution seats"
+});
+const quotaParks = Metric.counter(`${prefix}quota_park`, {
+  description: "Runs parked by quota enforcement"
+});
+const structuredOutputRejections = Metric.counter(`${prefix}agent_structured_output_rejections`, {
+  description: "Agent answers refused by their declared output schema"
+});
+const structuredOutputExhausted = Metric.counter(`${prefix}agent_structured_output_exhausted`, {
+  description: "Agent steps whose output corrections were exhausted"
+});
+const droppedLogRecords = Metric.counter(`${prefix}observability_log_dropped`, {
+  description: "Operational log records dropped before durable delivery"
+});
+const registry = {
+  runThroughput,
+  activeSeats,
+  quotaParks,
+  structuredOutputRejections,
+  structuredOutputExhausted,
+  droppedLogRecords
+};
+//# sourceMappingURL=Metric.js.map

package/dist/cjs/Metric.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Metric.ts"],
+  "sourcesContent": ["/**\n * Effect metric registry for flows runtime signals.\n *\n * @since 0.1.0\n */\n\nimport * as Metric from \"effect/Metric\"\n\nconst prefix = \"flows_\"\n\n/**\n * Counts flow runs that reached a terminal state.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const runThroughput = Metric.counter(`${prefix}run_throughput`, {\n  description: \"Completed flow runs\"\n})\n\n/**\n * The number of execution seats currently held.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const activeSeats = Metric.gauge(`${prefix}seat_active`, {\n  description: \"Currently active execution seats\"\n})\n\n/**\n * Counts runs parked because a quota was exhausted.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const quotaParks = Metric.counter(`${prefix}quota_park`, {\n  description: \"Runs parked by quota enforcement\"\n})\n\n/**\n * Counts agent answers refused by their declared output schema.\n *\n * @category metrics\n * @since 1.0.0-rc.1\n */\nexport const structuredOutputRejections = Metric.counter(`${prefix}agent_structured_output_rejections`, {\n  description: \"Agent answers refused by their declared output schema\"\n})\n\n/**\n * Counts agent steps that failed after spending every output correction.\n *\n * @category metrics\n * @since 1.0.0-rc.1\n */\nexport const structuredOutputExhausted = Metric.counter(`${prefix}agent_structured_output_exhausted`, {\n  description: \"Agent steps whose output corrections were exhausted\"\n})\n\n/**\n * Counts operational log records lost before durable delivery.\n *\n * Advances once per record dropped by a saturated forwarding queue, once per\n * journal delivery failure, and once per defect the forwarding worker recovers\n * from, so telemetry loss is distinguishable from an idle logger.\n *\n * @category metrics\n * @since 1.0.0-rc.0\n */\nexport const droppedLogRecords = Metric.counter(`${prefix}observability_log_dropped`, {\n  description: \"Operational log records dropped before durable delivery\"\n})\n\n/**\n * All metrics declared by this package.\n *\n * @category registry\n * @since 0.1.0\n */\nexport const registry = {\n  runThroughput,\n  activeSeats,\n  quotaParks,\n  structuredOutputRejections,\n  structuredOutputExhausted,\n  droppedLogRecords\n} as const\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,aAAwB;AAExB,MAAM,SAAS;AAQR,MAAM,gBAAgB,OAAO,QAAQ,GAAG,MAAM,kBAAkB;AAAA,EACrE,aAAa;AACf,CAAC;AAQM,MAAM,cAAc,OAAO,MAAM,GAAG,MAAM,eAAe;AAAA,EAC9D,aAAa;AACf,CAAC;AAQM,MAAM,aAAa,OAAO,QAAQ,GAAG,MAAM,cAAc;AAAA,EAC9D,aAAa;AACf,CAAC;AAQM,MAAM,6BAA6B,OAAO,QAAQ,GAAG,MAAM,sCAAsC;AAAA,EACtG,aAAa;AACf,CAAC;AAQM,MAAM,4BAA4B,OAAO,QAAQ,GAAG,MAAM,qCAAqC;AAAA,EACpG,aAAa;AACf,CAAC;AAYM,MAAM,oBAAoB,OAAO,QAAQ,GAAG,MAAM,6BAA6B;AAAA,EACpF,aAAa;AACf,CAAC;AAQM,MAAM,WAAW;AAAA,EACtB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;",
+  "names": []
+}

package/dist/cjs/NodeOtel.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Node-only OTLP/HTTP OpenTelemetry setup.
+ *
+ * @since 0.1.0
+ */
+import type * as Duration from "effect/Duration";
+import * as Layer from "effect/Layer";
+import * as Endpoint from "./Endpoint.ts";
+import * as Resource from "./Resource.ts";
+import type { Configuration as ResourceConfiguration } from "./Resource.ts";
+/**
+ * Node OTLP/HTTP layer options.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Options {
+    /**
+     * The collector base URL. It must be an absolute `http:` or `https:` URL
+     * without credentials and free of spaces and control characters; anything
+     * else fails layer acquisition with
+     * {@link Endpoint.InvalidExporterEndpoint}.
+     */
+    readonly endpoint: string;
+    readonly resource: ResourceConfiguration;
+    readonly shutdownTimeout?: Duration.Input | undefined;
+    readonly exportIntervalMillis?: number | undefined;
+}
+/**
+ * Builds a scoped Node OTLP/HTTP layer for all three telemetry signals.
+ * Exporter objects are created only when this layer is built.
+ * Resource metadata is explicit: ambient OTEL resource configuration cannot
+ * enlarge it after validation. The OpenTelemetry exporters still read the
+ * standard `OTEL_EXPORTER_OTLP_*` transport variables (headers, timeout,
+ * compression, TLS files) from the process environment and send them to the
+ * explicit endpoint, which always wins over `OTEL_EXPORTER_OTLP_ENDPOINT`.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerOtel: (options: Options) => Layer.Layer<never, Resource.InvalidResourceConfiguration | Endpoint.InvalidExporterEndpoint>;
+//# sourceMappingURL=NodeOtel.d.ts.map

package/dist/cjs/NodeOtel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeOtel.d.ts","sourceRoot":"","sources":["../../src/NodeOtel.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAUH,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAEhD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,EAAE,aAAa,IAAI,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAE3E;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAA;IACxC,QAAQ,CAAC,eAAe,CAAC,EAAE,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAA;IACrD,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACnD;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,SAAS,GACpB,SAAS,OAAO,KACf,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,QAAQ,CAAC,4BAA4B,GAAG,QAAQ,CAAC,uBAAuB,CAmC3F,CAAA"}

package/dist/cjs/NodeOtel.js

@@ -0,0 +1,78 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NodeOtel_exports = {};
+__export(NodeOtel_exports, {
+  layerOtel: () => layerOtel
+});
+module.exports = __toCommonJS(NodeOtel_exports);
+var NodeSdk = __toESM(require("@effect/opentelemetry/NodeSdk"), 1);
+var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
+var import_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
+var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+var import_sdk_logs = require("@opentelemetry/sdk-logs");
+var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var ConfigProvider = __toESM(require("effect/ConfigProvider"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Endpoint = __toESM(require("./Endpoint.js"), 1);
+var Resource = __toESM(require("./Resource.js"), 1);
+const layerOtel = (options) => Layer.unwrap(
+  Effect.map(
+    Effect.all([Resource.decode(options.resource), Endpoint.decode(options.endpoint, "endpoint")]),
+    ([decoded, endpoint]) => NodeSdk.layer(() => {
+      const resource = Resource.toOpenTelemetryConfiguration(decoded);
+      const spanProcessor = new import_sdk_trace_base.BatchSpanProcessor(
+        new import_exporter_trace_otlp_http.OTLPTraceExporter({ url: Endpoint.signalUrl(endpoint, "traces") })
+      );
+      const logRecordProcessor = new import_sdk_logs.BatchLogRecordProcessor({
+        exporter: new import_exporter_logs_otlp_http.OTLPLogExporter({ url: Endpoint.signalUrl(endpoint, "logs") })
+      });
+      const metricReader = options.exportIntervalMillis === void 0 ? new import_sdk_metrics.PeriodicExportingMetricReader({
+        exporter: new import_exporter_metrics_otlp_http.OTLPMetricExporter({ url: Endpoint.signalUrl(endpoint, "metrics") })
+      }) : new import_sdk_metrics.PeriodicExportingMetricReader({
+        exporter: new import_exporter_metrics_otlp_http.OTLPMetricExporter({ url: Endpoint.signalUrl(endpoint, "metrics") }),
+        exportIntervalMillis: options.exportIntervalMillis
+      });
+      return {
+        resource,
+        spanProcessor,
+        logRecordProcessor,
+        metricReader,
+        shutdownTimeout: options.shutdownTimeout
+      };
+    }).pipe(
+      // NodeSdk merges Resource.layerFromEnv after our admission check.
+      // Isolate that lookup so only the validated explicit resource and
+      // the SDK metadata already included in its budget reach exporters.
+      Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({})))
+    )
+  )
+);
+//# sourceMappingURL=NodeOtel.js.map

package/dist/cjs/NodeOtel.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/NodeOtel.ts"],
+  "sourcesContent": ["/**\n * Node-only OTLP/HTTP OpenTelemetry setup.\n *\n * @since 0.1.0\n */\n\nimport * as NodeSdk from \"@effect/opentelemetry/NodeSdk\"\nimport { OTLPLogExporter } from \"@opentelemetry/exporter-logs-otlp-http\"\nimport { OTLPMetricExporter } from \"@opentelemetry/exporter-metrics-otlp-http\"\nimport { OTLPTraceExporter } from \"@opentelemetry/exporter-trace-otlp-http\"\nimport { BatchLogRecordProcessor } from \"@opentelemetry/sdk-logs\"\nimport { PeriodicExportingMetricReader } from \"@opentelemetry/sdk-metrics\"\nimport { BatchSpanProcessor } from \"@opentelemetry/sdk-trace-base\"\nimport * as ConfigProvider from \"effect/ConfigProvider\"\nimport type * as Duration from \"effect/Duration\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport * as Endpoint from \"./Endpoint.ts\"\nimport * as Resource from \"./Resource.ts\"\nimport type { Configuration as ResourceConfiguration } from \"./Resource.ts\"\n\n/**\n * Node OTLP/HTTP layer options.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Options {\n  /**\n   * The collector base URL. It must be an absolute `http:` or `https:` URL\n   * without credentials and free of spaces and control characters; anything\n   * else fails layer acquisition with\n   * {@link Endpoint.InvalidExporterEndpoint}.\n   */\n  readonly endpoint: string\n  readonly resource: ResourceConfiguration\n  readonly shutdownTimeout?: Duration.Input | undefined\n  readonly exportIntervalMillis?: number | undefined\n}\n\n/**\n * Builds a scoped Node OTLP/HTTP layer for all three telemetry signals.\n * Exporter objects are created only when this layer is built.\n * Resource metadata is explicit: ambient OTEL resource configuration cannot\n * enlarge it after validation. The OpenTelemetry exporters still read the\n * standard `OTEL_EXPORTER_OTLP_*` transport variables (headers, timeout,\n * compression, TLS files) from the process environment and send them to the\n * explicit endpoint, which always wins over `OTEL_EXPORTER_OTLP_ENDPOINT`.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerOtel = (\n  options: Options\n): Layer.Layer<never, Resource.InvalidResourceConfiguration | Endpoint.InvalidExporterEndpoint> =>\n  Layer.unwrap(\n    Effect.map(\n      Effect.all([Resource.decode(options.resource), Endpoint.decode(options.endpoint, \"endpoint\")]),\n      ([decoded, endpoint]) =>\n        NodeSdk.layer(() => {\n          const resource = Resource.toOpenTelemetryConfiguration(decoded)\n          const spanProcessor = new BatchSpanProcessor(\n            new OTLPTraceExporter({ url: Endpoint.signalUrl(endpoint, \"traces\") })\n          )\n          const logRecordProcessor = new BatchLogRecordProcessor({\n            exporter: new OTLPLogExporter({ url: Endpoint.signalUrl(endpoint, \"logs\") })\n          })\n          const metricReader = options.exportIntervalMillis === undefined\n            ? new PeriodicExportingMetricReader({\n              exporter: new OTLPMetricExporter({ url: Endpoint.signalUrl(endpoint, \"metrics\") })\n            })\n            : new PeriodicExportingMetricReader({\n              exporter: new OTLPMetricExporter({ url: Endpoint.signalUrl(endpoint, \"metrics\") }),\n              exportIntervalMillis: options.exportIntervalMillis\n            })\n          return {\n            resource,\n            spanProcessor,\n            logRecordProcessor,\n            metricReader,\n            shutdownTimeout: options.shutdownTimeout\n          }\n        }).pipe(\n          // NodeSdk merges Resource.layerFromEnv after our admission check.\n          // Isolate that lookup so only the validated explicit resource and\n          // the SDK metadata already included in its budget reach exporters.\n          Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({})))\n        )\n    )\n  )\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,cAAyB;AACzB,qCAAgC;AAChC,wCAAmC;AACnC,sCAAkC;AAClC,sBAAwC;AACxC,yBAA8C;AAC9C,4BAAmC;AACnC,qBAAgC;AAEhC,aAAwB;AACxB,YAAuB;AACvB,eAA0B;AAC1B,eAA0B;AAkCnB,MAAM,YAAY,CACvB,YAEA,MAAM;AAAA,EACJ,OAAO;AAAA,IACL,OAAO,IAAI,CAAC,SAAS,OAAO,QAAQ,QAAQ,GAAG,SAAS,OAAO,QAAQ,UAAU,UAAU,CAAC,CAAC;AAAA,IAC7F,CAAC,CAAC,SAAS,QAAQ,MACjB,QAAQ,MAAM,MAAM;AAClB,YAAM,WAAW,SAAS,6BAA6B,OAAO;AAC9D,YAAM,gBAAgB,IAAI;AAAA,QACxB,IAAI,kDAAkB,EAAE,KAAK,SAAS,UAAU,UAAU,QAAQ,EAAE,CAAC;AAAA,MACvE;AACA,YAAM,qBAAqB,IAAI,wCAAwB;AAAA,QACrD,UAAU,IAAI,+CAAgB,EAAE,KAAK,SAAS,UAAU,UAAU,MAAM,EAAE,CAAC;AAAA,MAC7E,CAAC;AACD,YAAM,eAAe,QAAQ,yBAAyB,SAClD,IAAI,iDAA8B;AAAA,QAClC,UAAU,IAAI,qDAAmB,EAAE,KAAK,SAAS,UAAU,UAAU,SAAS,EAAE,CAAC;AAAA,MACnF,CAAC,IACC,IAAI,iDAA8B;AAAA,QAClC,UAAU,IAAI,qDAAmB,EAAE,KAAK,SAAS,UAAU,UAAU,SAAS,EAAE,CAAC;AAAA,QACjF,sBAAsB,QAAQ;AAAA,MAChC,CAAC;AACH,aAAO;AAAA,QACL;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,iBAAiB,QAAQ;AAAA,MAC3B;AAAA,IACF,CAAC,EAAE;AAAA;AAAA;AAAA;AAAA,MAID,MAAM,QAAQ,eAAe,MAAM,eAAe,YAAY,CAAC,CAAC,CAAC,CAAC;AAAA,IACpE;AAAA,EACJ;AACF;",
+  "names": []
+}

package/dist/cjs/Otel.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Provider-neutral composition for injected OpenTelemetry providers.
+ *
+ * @since 0.1.0
+ */
+import * as OtelMetrics from "@effect/opentelemetry/OtelMetrics";
+import type * as Api from "@opentelemetry/api";
+import type { LoggerProvider } from "@opentelemetry/sdk-logs";
+import type { MetricReader } from "@opentelemetry/sdk-metrics";
+import * as Layer from "effect/Layer";
+import { type Configuration as ResourceConfiguration, type InvalidResourceConfiguration, Resource } from "./Resource.ts";
+/**
+ * Injected providers used by the provider-neutral OTEL layer.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Options {
+    /** Validated resource for metrics and provider factories. */
+    readonly resource: ResourceConfiguration;
+    /**
+     * Borrowed: the layer bridges onto this provider and never flushes or shuts
+     * it down, including a provider a factory returns. Existing providers retain
+     * their resource. Factories must pass the supplied resource to the SDK.
+     */
+    readonly tracerProvider?: Api.TracerProvider | ((resource: typeof Resource.Service) => Api.TracerProvider) | undefined;
+    /** Borrowed on the same terms as `tracerProvider`. */
+    readonly loggerProvider?: LoggerProvider | ((resource: typeof Resource.Service) => LoggerProvider) | undefined;
+    /**
+     * Owned: the factory runs once during layer acquisition, after resource
+     * validation, and every reader it returns is shut down when the scope
+     * closes. Build the readers inside the factory rather than returning one a
+     * longer-lived composition still exports through, which that shutdown would
+     * disable. An empty array registers no reader at all.
+     */
+    readonly metricReader?: (() => MetricReader | ReadonlyArray<MetricReader>) | undefined;
+    readonly loggerMergeWithExisting?: boolean | undefined;
+    readonly metricTemporality?: OtelMetrics.TemporalityPreference | undefined;
+}
+/**
+ * Composes Effect tracer, logger, and metric bridges from already-created
+ * OpenTelemetry providers or provider factories, and from metric readers this
+ * layer acquires. Factories run during layer acquisition after resource
+ * validation, and the provider factories receive the metric resource.
+ * Already-created providers keep the resource captured at construction; the
+ * resource option only sets the metric resource for them. Spans and log
+ * records carry the instrumentation scope `effect` with the Effect version.
+ * Ownership splits: callers own provider flushing and shutdown, including
+ * factory-built providers, while the layer scope shuts down every reader the
+ * `metricReader` factory returned. No exporter is allocated by this module.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerOtel: (options: Options) => Layer.Layer<never, InvalidResourceConfiguration>;
+/**
+ * A no-op OTEL layer for callers that want an explicit optional slot.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerNoop: Layer.Layer<never>;
+//# sourceMappingURL=Otel.d.ts.map

package/dist/cjs/Otel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Otel.d.ts","sourceRoot":"","sources":["../../src/Otel.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,WAAW,MAAM,mCAAmC,CAAA;AAEhE,OAAO,KAAK,KAAK,GAAG,MAAM,oBAAoB,CAAA;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,EACL,KAAK,aAAa,IAAI,qBAAqB,EAC3C,KAAK,4BAA4B,EAEjC,QAAQ,EACT,MAAM,eAAe,CAAA;AAEtB;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAA;IACxC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EACpB,GAAG,CAAC,cAAc,GAClB,CAAC,CAAC,QAAQ,EAAE,OAAO,QAAQ,CAAC,OAAO,KAAK,GAAG,CAAC,cAAc,CAAC,GAC3D,SAAS,CAAA;IACb,sDAAsD;IACtD,QAAQ,CAAC,cAAc,CAAC,EACpB,cAAc,GACd,CAAC,CAAC,QAAQ,EAAE,OAAO,QAAQ,CAAC,OAAO,KAAK,cAAc,CAAC,GACvD,SAAS,CAAA;IACb;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,MAAM,YAAY,GAAG,aAAa,CAAC,YAAY,CAAC,CAAC,GAAG,SAAS,CAAA;IACtF,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACtD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,WAAW,CAAC,qBAAqB,GAAG,SAAS,CAAA;CAC3E;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,SAAS,GAAI,SAAS,OAAO,KAAG,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,4BAA4B,CAsC3F,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAe,CAAA"}

package/dist/cjs/Otel.js

@@ -0,0 +1,75 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Otel_exports = {};
+__export(Otel_exports, {
+  layerNoop: () => layerNoop,
+  layerOtel: () => layerOtel
+});
+module.exports = __toCommonJS(Otel_exports);
+var OtelLogger = __toESM(require("@effect/opentelemetry/OtelLogger"), 1);
+var OtelMetrics = __toESM(require("@effect/opentelemetry/OtelMetrics"), 1);
+var OtelTracer = __toESM(require("@effect/opentelemetry/OtelTracer"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var import_Resource = require("./Resource.js");
+const layerOtel = (options) => {
+  const resource = (0, import_Resource.layer)(options.resource);
+  const tracerProvider = options.tracerProvider;
+  const loggerProvider = options.loggerProvider;
+  const tracer = tracerProvider === void 0 ? Layer.empty : Layer.provide(
+    OtelTracer.layer,
+    Layer.effect(
+      OtelTracer.OtelTracerProvider,
+      Effect.map(
+        import_Resource.Resource,
+        (resource2) => typeof tracerProvider === "function" ? tracerProvider(resource2) : tracerProvider
+      )
+    )
+  );
+  const logger = loggerProvider === void 0 ? Layer.empty : Layer.provide(
+    OtelLogger.layer({ mergeWithExisting: options.loggerMergeWithExisting }),
+    Layer.effect(
+      OtelLogger.OtelLoggerProvider,
+      Effect.map(
+        import_Resource.Resource,
+        (resource2) => typeof loggerProvider === "function" ? loggerProvider(resource2) : loggerProvider
+      )
+    )
+  );
+  const acquireMetricReader = options.metricReader;
+  const metrics = acquireMetricReader === void 0 ? Layer.empty : OtelMetrics.layer(
+    () => acquireMetricReader(),
+    {
+      temporality: options.metricTemporality
+    }
+  );
+  return Layer.mergeAll(tracer, logger, metrics).pipe(Layer.provideMerge(resource));
+};
+const layerNoop = Layer.empty;
+//# sourceMappingURL=Otel.js.map

package/dist/cjs/Otel.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Otel.ts"],
+  "sourcesContent": ["/**\n * Provider-neutral composition for injected OpenTelemetry providers.\n *\n * @since 0.1.0\n */\n\nimport * as OtelLogger from \"@effect/opentelemetry/OtelLogger\"\nimport * as OtelMetrics from \"@effect/opentelemetry/OtelMetrics\"\nimport * as OtelTracer from \"@effect/opentelemetry/OtelTracer\"\nimport type * as Api from \"@opentelemetry/api\"\nimport type { LoggerProvider } from \"@opentelemetry/sdk-logs\"\nimport type { MetricReader } from \"@opentelemetry/sdk-metrics\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport {\n  type Configuration as ResourceConfiguration,\n  type InvalidResourceConfiguration,\n  layer as resourceLayer,\n  Resource\n} from \"./Resource.ts\"\n\n/**\n * Injected providers used by the provider-neutral OTEL layer.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Options {\n  /** Validated resource for metrics and provider factories. */\n  readonly resource: ResourceConfiguration\n  /**\n   * Borrowed: the layer bridges onto this provider and never flushes or shuts\n   * it down, including a provider a factory returns. Existing providers retain\n   * their resource. Factories must pass the supplied resource to the SDK.\n   */\n  readonly tracerProvider?:\n    | Api.TracerProvider\n    | ((resource: typeof Resource.Service) => Api.TracerProvider)\n    | undefined\n  /** Borrowed on the same terms as `tracerProvider`. */\n  readonly loggerProvider?:\n    | LoggerProvider\n    | ((resource: typeof Resource.Service) => LoggerProvider)\n    | undefined\n  /**\n   * Owned: the factory runs once during layer acquisition, after resource\n   * validation, and every reader it returns is shut down when the scope\n   * closes. Build the readers inside the factory rather than returning one a\n   * longer-lived composition still exports through, which that shutdown would\n   * disable. An empty array registers no reader at all.\n   */\n  readonly metricReader?: (() => MetricReader | ReadonlyArray<MetricReader>) | undefined\n  readonly loggerMergeWithExisting?: boolean | undefined\n  readonly metricTemporality?: OtelMetrics.TemporalityPreference | undefined\n}\n\n/**\n * Composes Effect tracer, logger, and metric bridges from already-created\n * OpenTelemetry providers or provider factories, and from metric readers this\n * layer acquires. Factories run during layer acquisition after resource\n * validation, and the provider factories receive the metric resource.\n * Already-created providers keep the resource captured at construction; the\n * resource option only sets the metric resource for them. Spans and log\n * records carry the instrumentation scope `effect` with the Effect version.\n * Ownership splits: callers own provider flushing and shutdown, including\n * factory-built providers, while the layer scope shuts down every reader the\n * `metricReader` factory returned. No exporter is allocated by this module.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerOtel = (options: Options): Layer.Layer<never, InvalidResourceConfiguration> => {\n  const resource = resourceLayer(options.resource)\n  const tracerProvider = options.tracerProvider\n  const loggerProvider = options.loggerProvider\n  const tracer = tracerProvider === undefined\n    ? Layer.empty\n    : Layer.provide(\n      OtelTracer.layer,\n      Layer.effect(\n        OtelTracer.OtelTracerProvider,\n        Effect.map(\n          Resource,\n          (resource) => typeof tracerProvider === \"function\" ? tracerProvider(resource) : tracerProvider\n        )\n      )\n    )\n  const logger = loggerProvider === undefined\n    ? Layer.empty\n    : Layer.provide(\n      OtelLogger.layer({ mergeWithExisting: options.loggerMergeWithExisting }),\n      Layer.effect(\n        OtelLogger.OtelLoggerProvider,\n        Effect.map(\n          Resource,\n          (resource) => typeof loggerProvider === \"function\" ? loggerProvider(resource) : loggerProvider\n        )\n      )\n    )\n  const acquireMetricReader = options.metricReader\n  const metrics = acquireMetricReader === undefined\n    ? Layer.empty\n    : OtelMetrics.layer(\n      () => acquireMetricReader() as unknown as MetricReader | readonly [MetricReader, ...Array<MetricReader>],\n      {\n        temporality: options.metricTemporality\n      }\n    )\n  return Layer.mergeAll(tracer, logger, metrics).pipe(Layer.provideMerge(resource))\n}\n\n/**\n * A no-op OTEL layer for callers that want an explicit optional slot.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerNoop: Layer.Layer<never> = Layer.empty\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,iBAA4B;AAC5B,kBAA6B;AAC7B,iBAA4B;AAI5B,aAAwB;AACxB,YAAuB;AACvB,sBAKO;AAoDA,MAAM,YAAY,CAAC,YAAuE;AAC/F,QAAM,eAAW,gBAAAA,OAAc,QAAQ,QAAQ;AAC/C,QAAM,iBAAiB,QAAQ;AAC/B,QAAM,iBAAiB,QAAQ;AAC/B,QAAM,SAAS,mBAAmB,SAC9B,MAAM,QACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,MACJ,WAAW;AAAA,MACX,OAAO;AAAA,QACL;AAAA,QACA,CAACC,cAAa,OAAO,mBAAmB,aAAa,eAAeA,SAAQ,IAAI;AAAA,MAClF;AAAA,IACF;AAAA,EACF;AACF,QAAM,SAAS,mBAAmB,SAC9B,MAAM,QACN,MAAM;AAAA,IACN,WAAW,MAAM,EAAE,mBAAmB,QAAQ,wBAAwB,CAAC;AAAA,IACvE,MAAM;AAAA,MACJ,WAAW;AAAA,MACX,OAAO;AAAA,QACL;AAAA,QACA,CAACA,cAAa,OAAO,mBAAmB,aAAa,eAAeA,SAAQ,IAAI;AAAA,MAClF;AAAA,IACF;AAAA,EACF;AACF,QAAM,sBAAsB,QAAQ;AACpC,QAAM,UAAU,wBAAwB,SACpC,MAAM,QACN,YAAY;AAAA,IACZ,MAAM,oBAAoB;AAAA,IAC1B;AAAA,MACE,aAAa,QAAQ;AAAA,IACvB;AAAA,EACF;AACF,SAAO,MAAM,SAAS,QAAQ,QAAQ,OAAO,EAAE,KAAK,MAAM,aAAa,QAAQ,CAAC;AAClF;AAQO,MAAM,YAAgC,MAAM;",
+  "names": ["resourceLayer", "resource"]
+}