@smthrs/observability 0.34.0 → 1.0.0-rc.3

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

@@ -0,0 +1 @@
+{"version":3,"file":"Otlp.d.ts","sourceRoot":"","sources":["../../src/Otlp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAGhD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AASrC,OAAO,KAAK,OAAO,MAAM,8BAA8B,CAAA;AAEvD,OAAO,KAAK,UAAU,MAAM,iCAAiC,CAAA;AAI7D,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,UAAU,CAAA;AAEzC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,eAAe,CAAA;AAMjD;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAAc,CAAA;AAM1C;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAAW,CAAA;AAE5C;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,QAAyE,CAAA;AA2KxG;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,4EAA4E;IAC5E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACzC,kFAAkF;IAClF,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5C;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;IACzD;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,KAAK,GAAG,SAAS,CAAA;IAC5C,+FAA+F;IAC/F,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAA;IACpD,uEAAuE;IACvE,QAAQ,CAAC,eAAe,CAAC,EAAE,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAA;CACtD;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,KAAK,GAChB,SAAS,OAAO,KACf,KAAK,CAAC,KAAK,CACZ,KAAK,EACL,QAAQ,CAAC,4BAA4B,GAAG,QAAQ,CAAC,uBAAuB,EACxE,UAAU,CAAC,UAAU,CAyCpB,CAAA;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,GACrB,SAAS,OAAO,KACf,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,QAAQ,CAAC,4BAA4B,GAAG,QAAQ,CAAC,uBAAuB,CACnC,CAAA;AAE3D;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,4BAA4B,GAAG,QAAQ,CAAC,uBAAuB,CAAA;AAEjG;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,GAAG,SAAS,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAc7E,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,GAC3B,aAAa,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,EACzD,UAAS,IAAI,CAAC,OAAO,EAAE,SAAS,GAAG,SAAS,CAAM,KACjD,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,UAAU,CAI/B,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAe,CAAA"}

package/dist/cjs/Otlp.js

@@ -0,0 +1,235 @@
+"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 Otlp_exports = {};
+__export(Otlp_exports, {
+  defaultServiceName: () => defaultServiceName,
+  defaultServiceVersion: () => defaultServiceVersion,
+  layer: () => layer,
+  layerEnvironment: () => layerEnvironment,
+  layerFetch: () => layerFetch,
+  layerNoop: () => layerNoop,
+  maxRequestBytes: () => maxRequestBytes,
+  maximumEnvelopeBytes: () => maximumEnvelopeBytes,
+  parseHeaders: () => parseHeaders,
+  reservedBatchBytes: () => reservedBatchBytes
+});
+module.exports = __toCommonJS(Otlp_exports);
+var Redaction = __toESM(require("@smthrs/journal/Redaction"), 1);
+var Cause = __toESM(require("effect/Cause"), 1);
+var import_Clock = require("effect/Clock");
+var ConfigProvider = __toESM(require("effect/ConfigProvider"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Exit = __toESM(require("effect/Exit"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Logger = __toESM(require("effect/Logger"), 1);
+var Metric = __toESM(require("effect/Metric"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var References = __toESM(require("effect/References"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var Semaphore = __toESM(require("effect/Semaphore"), 1);
+var Tracer = __toESM(require("effect/Tracer"), 1);
+var FetchHttpClient = __toESM(require("effect/unstable/http/FetchHttpClient"), 1);
+var Headers = __toESM(require("effect/unstable/http/Headers"), 1);
+var HttpClient = __toESM(require("effect/unstable/http/HttpClient"), 1);
+var HttpClientResponse = __toESM(require("effect/unstable/http/HttpClientResponse"), 1);
+var Otlp = __toESM(require("effect/unstable/observability/Otlp"), 1);
+var Endpoint = __toESM(require("./Endpoint.js"), 1);
+var Resource = __toESM(require("./Resource.js"), 1);
+const defaultServiceName = "flows";
+const defaultServiceVersion = "1.0.0-rc.3";
+const maxBatchSize = 1e3;
+const maxInFlight = 4;
+const maxRequestBytes = 1024 * 1024;
+const requestTimeout = "10 seconds";
+const diagnosticIntervalMillis = 6e4;
+const maximumEnvelopeBytes = 8 * 1024;
+const reservedBatchBytes = maxRequestBytes - Resource.maximumResourceBytes - maximumEnvelopeBytes;
+const boundedClient = Layer.effect(
+  HttpClient.HttpClient,
+  Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient;
+    const clock = yield* import_Clock.Clock;
+    const ambientLoggers = yield* Effect.withFiber((fiber) => Effect.succeed(fiber.getRef(Logger.CurrentLoggers)));
+    const permits = Semaphore.makeUnsafe(maxInFlight);
+    const droppedExports = Metric.counter("flows_observability_otlp_dropped");
+    let nextDiagnosticAt = -Infinity;
+    const discard = (reason, request, bytes) => Metric.update(droppedExports, 1).pipe(
+      Effect.andThen(Effect.suspend(() => {
+        const now = clock.currentTimeMillisUnsafe();
+        if (now < nextDiagnosticAt) return Effect.void;
+        nextDiagnosticAt = now + diagnosticIntervalMillis;
+        return Metric.value(droppedExports).pipe(
+          Effect.flatMap(
+            (dropped) => Effect.logWarning("An OTLP export batch was discarded").pipe(
+              Effect.provideService(References.CurrentLogSpans, []),
+              Effect.provideService(References.CurrentLogAnnotations, {
+                code: "otlp_export_discarded",
+                reason,
+                bytes,
+                limit: maxRequestBytes,
+                dropped: dropped.count
+              })
+            )
+          ),
+          Effect.provideService(Logger.CurrentLoggers, ambientLoggers)
+        );
+      })),
+      Effect.as(HttpClientResponse.fromWeb(request, new Response(null, { status: 204 })))
+    );
+    return HttpClient.transform(client, (requestEffect, request) => Effect.suspend(() => {
+      const bytes = request.body.contentLength;
+      if (bytes > maxRequestBytes) return discard("oversized", request, bytes);
+      const confinedRequest = Effect.flatMap(Effect.serviceOption(FetchHttpClient.RequestInit), (init) => requestEffect.pipe(
+        Effect.provideService(FetchHttpClient.RequestInit, {
+          ...Option.getOrUndefined(init),
+          redirect: "manual"
+        })
+      ));
+      return confinedRequest.pipe(
+        Effect.timeoutOrElse({
+          duration: requestTimeout,
+          orElse: () => discard("stalled", request, bytes)
+        }),
+        permits.withPermitsIfAvailable(1),
+        Effect.flatMap(Option.match({
+          onNone: () => discard("saturated", request, bytes),
+          onSome: Effect.succeed
+        }))
+      );
+    }));
+  })
+);
+const loopbackIpv4 = /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+const isLoopback = (endpoint) => {
+  const hostname = new URL(endpoint).hostname;
+  return hostname === "localhost" || hostname === "[::1]" || loopbackIpv4.test(hostname);
+};
+const vendorCredentialHeaders = /* @__PURE__ */ new Set(["x-honeycomb-team"]);
+const isCredentialHeader = (name) => Redaction.isSensitiveKey(name) || vendorCredentialHeaders.has(name.toLowerCase());
+const refusePlaintextCredentials = (baseUrl, headers) => {
+  if (!baseUrl.toLowerCase().startsWith("http:") || isLoopback(baseUrl)) return Effect.void;
+  const credential = Object.keys(Headers.fromInput(headers)).some(isCredentialHeader);
+  return credential ? Effect.fail(
+    new Endpoint.InvalidExporterEndpoint({
+      code: "invalid_exporter_endpoint",
+      path: "baseUrl",
+      message: "OTLP collector baseUrl must use https:// when headers carry credentials, unless it is a loopback address"
+    })
+  ) : Effect.void;
+};
+const redactText = (text) => String(Redaction.redact(text));
+class RedactedSpanError extends Schema.TaggedError()("@smthrs/observability/RedactedSpanError", {
+  message: Schema.String
+}) {
+}
+const redactedExit = (exit) => {
+  if (exit._tag === "Success" || Cause.hasInterruptsOnly(exit.cause)) return exit;
+  const errors = Cause.prettyErrors(exit.cause, { includeCauseInStack: true }).map((error) => {
+    const redacted = new RedactedSpanError({ message: redactText(error.message) });
+    Object.defineProperty(redacted, "name", { value: redactText(error.name), configurable: true, writable: true });
+    redacted.stack = redactText(String(error.stack));
+    return redacted;
+  });
+  return Exit.failCause(errors.map(Cause.fail).reduce(Cause.combine, Cause.empty));
+};
+const redactedSpans = Layer.effect(Tracer.Tracer)(
+  Effect.map(Effect.tracer, (tracer) => Tracer.make({
+    ...tracer,
+    span(options) {
+      const span = tracer.span(options);
+      const end = span.end.bind(span);
+      const attribute = span.attribute.bind(span);
+      span.end = (endTime, exit) => end(endTime, redactedExit(exit));
+      span.attribute = (key, value) => attribute(key, typeof value === "string" ? redactText(value) : value);
+      return span;
+    }
+  }))
+);
+const layer = (options) => Layer.unwrap(
+  Effect.map(
+    Effect.all([
+      Resource.decode({
+        serviceName: options.serviceName ?? defaultServiceName,
+        serviceVersion: options.serviceVersion ?? defaultServiceVersion,
+        ...options.attributes === void 0 ? {} : { attributes: options.attributes }
+      }),
+      Endpoint.decode(options.baseUrl, "baseUrl").pipe(
+        Effect.tap((baseUrl) => refusePlaintextCredentials(baseUrl, options.headers))
+      )
+    ]),
+    ([decoded, baseUrl]) => {
+      const resource = Resource.toOpenTelemetryConfiguration(decoded);
+      return Otlp.layerJson({
+        baseUrl,
+        resource: {
+          serviceName: resource.serviceName,
+          // `serviceVersion` is supplied above before Resource decoding.
+          serviceVersion: resource.serviceVersion,
+          ...resource.attributes === void 0 ? {} : { attributes: resource.attributes }
+        },
+        headers: options.headers,
+        maxBatchSize,
+        loggerExportInterval: options.exportInterval,
+        metricsExportInterval: options.exportInterval,
+        tracerExportInterval: options.exportInterval,
+        shutdownTimeout: options.shutdownTimeout
+      }).pipe(
+        Layer.provide(boundedClient),
+        // Upstream merges OTEL_RESOURCE_ATTRIBUTES even with explicit
+        // options. Keep unvalidated ambient metadata out of every request.
+        Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({}))),
+        (exporter) => Layer.provideMerge(redactedSpans, exporter)
+      );
+    }
+  )
+);
+const layerFetch = (options) => layer(options).pipe(Layer.provide(FetchHttpClient.layer));
+const parseHeaders = (value) => {
+  const headers = {};
+  for (const pair of (value ?? "").split(",")) {
+    const separator = pair.indexOf("=");
+    const key = pair.slice(0, separator).trim();
+    if (separator < 0 || key === "") continue;
+    const raw = pair.slice(separator + 1).trim();
+    let decoded = raw;
+    try {
+      decoded = decodeURIComponent(raw);
+    } catch {
+    }
+    headers[key] = decoded;
+  }
+  return headers;
+};
+const layerEnvironment = (environment, options = {}) => {
+  const endpoint = environment["OTEL_EXPORTER_OTLP_ENDPOINT"]?.trim();
+  if (endpoint === void 0 || endpoint === "") return layerNoop;
+  return layerFetch({ ...options, baseUrl: endpoint, headers: parseHeaders(environment["OTEL_EXPORTER_OTLP_HEADERS"]) });
+};
+const layerNoop = Layer.empty;
+//# sourceMappingURL=Otlp.js.map

package/dist/cjs/Otlp.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Otlp.ts"],
+  "sourcesContent": ["/**\n * Default OTLP export wiring for flows telemetry.\n *\n * The store packages already open spans through Effect's tracer and update\n * `Metric` counters on their hot paths; what they deliberately do not do is\n * ship an exporter. This module is that exporter: one layer that installs\n * Effect's own OTLP logger, metrics exporter, and tracer\n * (`effect/unstable/observability/Otlp`) against a collector endpoint, with\n * the flows service identity filled in. Nothing beyond `effect` is involved;\n * no OpenTelemetry SDK dependency.\n *\n * Browser support is met by construction rather than by a no-op variant:\n * export happens over Effect's `HttpClient`, and {@link layerFetch} binds the\n * `fetch` implementation the host already has, so no entry point here ever\n * resolves a `node:` built-in. See the\n * {@link https://smithers.sh/docs/reference/api/observability | observability API contract}.\n *\n * @since 0.1.0\n */\n\nimport * as Redaction from \"@smthrs/journal/Redaction\"\nimport * as Cause from \"effect/Cause\"\nimport { Clock } from \"effect/Clock\"\nimport * as ConfigProvider from \"effect/ConfigProvider\"\nimport type * as Duration from \"effect/Duration\"\nimport * as Effect from \"effect/Effect\"\nimport * as Exit from \"effect/Exit\"\nimport * as Layer from \"effect/Layer\"\nimport * as Logger from \"effect/Logger\"\nimport * as Metric from \"effect/Metric\"\nimport * as Option from \"effect/Option\"\nimport * as References from \"effect/References\"\nimport * as Schema from \"effect/Schema\"\nimport * as Semaphore from \"effect/Semaphore\"\nimport * as Tracer from \"effect/Tracer\"\nimport * as FetchHttpClient from \"effect/unstable/http/FetchHttpClient\"\nimport * as Headers from \"effect/unstable/http/Headers\"\nimport type * as HttpBody from \"effect/unstable/http/HttpBody\"\nimport * as HttpClient from \"effect/unstable/http/HttpClient\"\nimport type * as HttpClientRequest from \"effect/unstable/http/HttpClientRequest\"\nimport * as HttpClientResponse from \"effect/unstable/http/HttpClientResponse\"\nimport * as Otlp from \"effect/unstable/observability/Otlp\"\nimport * as Endpoint from \"./Endpoint.ts\"\nimport * as Resource from \"./Resource.ts\"\n\n/**\n * The `service.name` resource attribute installed when the caller supplies\n * none: the flows distribution itself. Override it per application with\n * {@link Options.serviceName}.\n *\n * @category resource\n * @since 0.1.0\n */\nexport const defaultServiceName = \"flows\"\n\n/**\n * The `service.version` resource attribute installed when the caller supplies\n * none. Mirrors the release version in this package's `package.json`.\n *\n * A published package cannot read its own manifest on every runtime it\n * supports, so the version lives here as a literal.\n * `scripts/set-release-version.mjs` rewrites this declaration with the\n * manifests, and its `--check` mode reports drift, so a release bump cannot\n * leave it behind.\n *\n * @category resource\n * @since 0.1.0\n */\nexport const defaultServiceVersion = \"1.0.0-rc.3\"\n\n// The upstream logger and tracer each buffer at most one 1,000-record batch.\n// Do not queue at the transport: upstream forks every full batch independently.\nconst maxBatchSize = 1000\nconst maxInFlight = 4\n/**\n * Maximum encoded export request size, in bytes.\n * @category transport\n * @since 1.0.0-rc.0\n */\nexport const maxRequestBytes = 1024 * 1024\nconst requestTimeout = \"10 seconds\"\nconst diagnosticIntervalMillis = 60_000\n// The envelope around the resource in every request repeats `service.name` as\n// the instrumentation scope name: at most 1,024 code units, at most six bytes\n// each once JSON-escaped, so under 8 KiB together with the envelope's own keys.\n/**\n * Reserved bytes for request wrappers and the escaped instrumentation scope.\n * @category transport\n * @since 1.0.0-rc.0\n */\nexport const maximumEnvelopeBytes = 8 * 1024\n\n/**\n * Bytes of every export request kept free for the signal batch itself.\n *\n * The transport discards a request over 1 MiB, and the resource rides in every\n * request, so the largest resource `Resource.decode` admits\n * (`Resource.maximumResourceBytes`, 128 KiB) and the envelope that repeats the\n * service name (under 8 KiB) come off the top. The 888 KiB left gives each\n * record of a full 1,000-record logger or tracer batch about 900 bytes, three\n * to four times a bare log record or span, and gives the metrics snapshot room\n * for several thousand series. Every resource the decoder accepts therefore\n * leaves an ordinary batch of any signal exportable; what this reserve does\n * not bound is a single application record or a registry large enough to\n * exceed it on its own.\n *\n * @category transport\n * @since 1.0.0-rc.0\n */\nexport const reservedBatchBytes = maxRequestBytes - Resource.maximumResourceBytes - maximumEnvelopeBytes\n\ntype DiscardReason = \"oversized\" | \"stalled\" | \"saturated\"\n\nconst boundedClient = Layer.effect(\n  HttpClient.HttpClient,\n  Effect.gen(function*() {\n    const client = yield* HttpClient.HttpClient\n    const clock = yield* Clock\n    // The loggers installed when this transport is acquired. The OTLP logger\n    // the same acquisition installs does not exist yet, so a diagnostic pinned\n    // to this set cannot enter the exporter it describes, whichever fiber runs\n    // the export: the interval and shutdown fibers inherit this set anyway,\n    // but a flush requested from application code runs with the application's\n    // loggers, which by then include this exporter.\n    const ambientLoggers = yield* Effect.withFiber((fiber) => Effect.succeed(fiber.getRef(Logger.CurrentLoggers)))\n    const permits = Semaphore.makeUnsafe(maxInFlight)\n    // The counter lives with the transport it describes.\n    const droppedExports = Metric.counter(\"flows_observability_otlp_dropped\")\n    let nextDiagnosticAt = -Infinity\n    // A local discard is terminal, so the upstream retry loop must not retain\n    // or retry its payload, and the counter records batches, not records. The\n    // warning is the diagnostic the counter cannot be: the counter is exported\n    // through this same transport and shares every outage with it. One\n    // warning per minute keeps a sustained outage from flooding the ambient\n    // loggers; the running total in its annotations carries the volume.\n    // Replace ambient annotations and log spans to bound the diagnostic itself.\n    const discard = (reason: DiscardReason, request: HttpClientRequest.HttpClientRequest, bytes: number) =>\n      Metric.update(droppedExports, 1).pipe(\n        Effect.andThen(Effect.suspend(() => {\n          const now = clock.currentTimeMillisUnsafe()\n          if (now < nextDiagnosticAt) return Effect.void\n          nextDiagnosticAt = now + diagnosticIntervalMillis\n          return Metric.value(droppedExports).pipe(\n            Effect.flatMap((dropped) =>\n              Effect.logWarning(\"An OTLP export batch was discarded\").pipe(\n                Effect.provideService(References.CurrentLogSpans, []),\n                Effect.provideService(References.CurrentLogAnnotations, {\n                  code: \"otlp_export_discarded\",\n                  reason,\n                  bytes,\n                  limit: maxRequestBytes,\n                  dropped: dropped.count\n                })\n              )\n            ),\n            Effect.provideService(Logger.CurrentLoggers, ambientLoggers)\n          )\n        })),\n        Effect.as(HttpClientResponse.fromWeb(request, new Response(null, { status: 204 })))\n      )\n    return HttpClient.transform(client, (requestEffect, request) =>\n      Effect.suspend(() => {\n        // layerJson always supplies a Uint8Array body with a byte length.\n        const bytes = (request.body as HttpBody.Uint8Array).contentLength\n        if (bytes > maxRequestBytes) return discard(\"oversized\", request, bytes)\n        // Fetch must expose redirects before any credential or signal body\n        // leaves the configured endpoint, even when the caller enables follow.\n        const confinedRequest = Effect.flatMap(Effect.serviceOption(FetchHttpClient.RequestInit), (init) =>\n          requestEffect.pipe(\n            Effect.provideService(FetchHttpClient.RequestInit, {\n              ...Option.getOrUndefined(init),\n              redirect: \"manual\"\n            })\n          ))\n        return confinedRequest.pipe(\n          Effect.timeoutOrElse({\n            duration: requestTimeout,\n            orElse: () =>\n              discard(\"stalled\", request, bytes)\n          }),\n          permits.withPermitsIfAvailable(1),\n          Effect.flatMap(Option.match({\n            onNone: () =>\n              discard(\"saturated\", request, bytes),\n            onSome: Effect.succeed\n          }))\n        )\n      }))\n  })\n)\n\nconst loopbackIpv4 = /^127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$/\n\n/** Whether a decoded endpoint's host never leaves this machine. */\nconst isLoopback = (endpoint: string): boolean => {\n  const hostname = new URL(endpoint).hostname\n  return hostname === \"localhost\" || hostname === \"[::1]\" || loopbackIpv4.test(hostname)\n}\n\n/**\n * Refuses a credential header bound for a plaintext collector off this\n * machine. Anyone on the network path could read the token from every export\n * request, and the exporter would never report it. Loopback `http://` stays\n * allowed for a local collector or sidecar; non-credential headers such as a\n * tenant id stay allowed on any endpoint.\n */\n/**\n * Vendor credential headers whose names `Redaction.isSensitiveKey` does not\n * recognize. Honeycomb sends its ingest key as `x-honeycomb-team`.\n */\nconst vendorCredentialHeaders: ReadonlySet<string> = new Set([\"x-honeycomb-team\"])\n\nconst isCredentialHeader = (name: string): boolean =>\n  Redaction.isSensitiveKey(name) || vendorCredentialHeaders.has(name.toLowerCase())\n\nconst refusePlaintextCredentials = (\n  baseUrl: string,\n  headers: Headers.Input | undefined\n): Effect.Effect<void, Endpoint.InvalidExporterEndpoint> => {\n  if (!baseUrl.toLowerCase().startsWith(\"http:\") || isLoopback(baseUrl)) return Effect.void\n  const credential = Object.keys(Headers.fromInput(headers)).some(isCredentialHeader)\n  return credential\n    ? Effect.fail(\n      new Endpoint.InvalidExporterEndpoint({\n        code: \"invalid_exporter_endpoint\",\n        path: \"baseUrl\",\n        message:\n          \"OTLP collector baseUrl must use https:// when headers carry credentials, unless it is a loopback address\"\n      })\n    )\n    : Effect.void\n}\n\nconst redactText = (text: string): string => String(Redaction.redact(text))\n\n/**\n * A failed span's error rebuilt with its text redacted. It keeps the original\n * error's `name` and `stack` (redacted) so the collector's exception type and\n * trace stay readable; it is exported to the collector and never thrown.\n */\nclass RedactedSpanError extends Schema.TaggedError<RedactedSpanError>()(\"@smthrs/observability/RedactedSpanError\", {\n  message: Schema.String\n}) {}\n\n/**\n * A span failure rendered with credentials removed. The exporter serializes a\n * failed span's cause into its status message and `exception` events, which\n * would otherwise carry any token an error message quoted to the collector.\n */\nconst redactedExit = (exit: Exit.Exit<unknown, unknown>): Exit.Exit<unknown, unknown> => {\n  if (exit._tag === \"Success\" || Cause.hasInterruptsOnly(exit.cause)) return exit\n  const errors = Cause.prettyErrors(exit.cause, { includeCauseInStack: true }).map((error) => {\n    const redacted = new RedactedSpanError({ message: redactText(error.message) })\n    Object.defineProperty(redacted, \"name\", { value: redactText(error.name), configurable: true, writable: true })\n    // `prettyErrors` always renders a stack.\n    redacted.stack = redactText(String(error.stack))\n    return redacted\n  })\n  return Exit.failCause(errors.map(Cause.fail).reduce(Cause.combine, Cause.empty as Cause.Cause<unknown>))\n}\n\n/**\n * Wraps the installed tracer so every exported span's failure and string\n * attributes pass through the journal redaction rules first.\n */\nconst redactedSpans = Layer.effect(Tracer.Tracer)(\n  Effect.map(Effect.tracer, (tracer) =>\n    Tracer.make({\n      ...tracer,\n      span(options) {\n        const span = tracer.span(options)\n        const end = span.end.bind(span)\n        const attribute = span.attribute.bind(span)\n        span.end = (endTime, exit) => end(endTime, redactedExit(exit))\n        span.attribute = (key, value) => attribute(key, typeof value === \"string\" ? redactText(value) : value)\n        return span\n      }\n    }))\n)\n\n/**\n * Configuration for the default OTLP wiring.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Options {\n  /**\n   * The collector base URL, for example `http://localhost:4318`. Signals are\n   * posted below it at `/v1/logs`, `/v1/metrics`, and `/v1/traces`. It must be\n   * an absolute `http://` or `https://` URL without credentials, a query,\n   * fragment, backslashes, spaces, or controls. A base path is allowed. Invalid\n   * values fail acquisition with {@link Endpoint.InvalidExporterEndpoint}.\n   * Use {@link Options.headers} for authentication.\n   */\n  readonly baseUrl: string\n  /** Overrides {@link defaultServiceName} as the `service.name` attribute. */\n  readonly serviceName?: string | undefined\n  /** Overrides {@link defaultServiceVersion} as the `service.version` attribute. */\n  readonly serviceVersion?: string | undefined\n  /**\n   * Additional resource attributes attached to every exported signal, decoded\n   * by `Resource.Attributes`. The whole resource must encode to at most\n   * `Resource.maximumResourceBytes`; a larger one fails acquisition with\n   * {@link Resource.InvalidResourceConfiguration} rather than making every\n   * request oversized.\n   */\n  readonly attributes?: Record<string, unknown> | undefined\n  /**\n   * Headers sent with every export request, for example vendor auth. A header\n   * whose name names a credential (`authorization`, `x-api-key`, anything\n   * `Redaction.isSensitiveKey` recognizes, plus `x-honeycomb-team`) requires\n   * an `https://` baseUrl unless the host is loopback; otherwise acquisition\n   * fails with\n   * {@link Endpoint.InvalidExporterEndpoint}.\n   */\n  readonly headers?: Headers.Input | undefined\n  /** Export cadence for all three signals; each signal's Effect default applies when omitted. */\n  readonly exportInterval?: Duration.Input | undefined\n  /** Upper bound on the shutdown flush when the layer's scope closes. */\n  readonly shutdownTimeout?: Duration.Input | undefined\n}\n\n/**\n * Creates the OTLP logs, metrics, and traces layer with flows resource\n * defaults, JSON-serialized. Exports share a four-request limit with no waiting\n * queue. Requests larger than 1 MiB or stalled for ten seconds are discarded;\n * `flows_observability_otlp_dropped` counts discarded batches, and at most\n * once a minute a `Warn` record with code `otlp_export_discarded` names the\n * reason, the request size, and the running total through the loggers that\n * were installed when the layer was acquired, never through this exporter.\n *\n * **Details**\n *\n * The layer still requires an `HttpClient`, which is how it stays\n * platform-neutral: a Node host may hand it `@effect/platform-node`'s Undici\n * client (re-exported by `@smthrs/platform-node`), a browser or test\n * hands it something else. Use {@link layerFetch} when the host's global\n * `fetch` is good enough. On Node 26 and every browser it is.\n * Fetch redirects are refused. Supply `FetchHttpClient.RequestInit` around\n * the whole exporting effect to retain other fetch options; options scoped\n * only to the supplied client's layer are replaced by the redirect policy.\n * Other HTTP transports must independently refuse automatic redirects.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer = (\n  options: Options\n): Layer.Layer<\n  never,\n  Resource.InvalidResourceConfiguration | Endpoint.InvalidExporterEndpoint,\n  HttpClient.HttpClient\n> =>\n  Layer.unwrap(\n    Effect.map(\n      Effect.all([\n        Resource.decode({\n          serviceName: options.serviceName ?? defaultServiceName,\n          serviceVersion: options.serviceVersion ?? defaultServiceVersion,\n          ...(options.attributes === undefined ? {} : { attributes: options.attributes })\n        }),\n        Endpoint.decode(options.baseUrl, \"baseUrl\").pipe(\n          Effect.tap((baseUrl) => refusePlaintextCredentials(baseUrl, options.headers))\n        )\n      ]),\n      ([decoded, baseUrl]) => {\n        const resource = Resource.toOpenTelemetryConfiguration(decoded)\n        return (\n          Otlp.layerJson({\n            baseUrl,\n            resource: {\n              serviceName: resource.serviceName,\n              // `serviceVersion` is supplied above before Resource decoding.\n              serviceVersion: resource.serviceVersion!,\n              ...(resource.attributes === undefined ? {} : { attributes: resource.attributes })\n            },\n            headers: options.headers,\n            maxBatchSize,\n            loggerExportInterval: options.exportInterval,\n            metricsExportInterval: options.exportInterval,\n            tracerExportInterval: options.exportInterval,\n            shutdownTimeout: options.shutdownTimeout\n          }).pipe(\n            Layer.provide(boundedClient),\n            // Upstream merges OTEL_RESOURCE_ATTRIBUTES even with explicit\n            // options. Keep unvalidated ambient metadata out of every request.\n            Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({}))),\n            (exporter) => Layer.provideMerge(redactedSpans, exporter)\n          )\n        )\n      }\n    )\n  )\n\n/**\n * Provides {@link layer} over the host's global `fetch`, the default wiring\n * for a Node host, and browser-safe by construction because it never touches\n * a `node:` built-in.\n *\n * **Example**\n *\n * ```ts\n * import * as Otlp from \"@smthrs/observability/Otlp\"\n *\n * const Telemetry = Otlp.layerFetch({ baseUrl: \"http://localhost:4318\" })\n * ```\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerFetch = (\n  options: Options\n): Layer.Layer<never, Resource.InvalidResourceConfiguration | Endpoint.InvalidExporterEndpoint> =>\n  layer(options).pipe(Layer.provide(FetchHttpClient.layer))\n\n/**\n * Why an OTLP layer refused to start.\n *\n * @category errors\n * @since 1.0.0\n */\nexport type LayerError = Resource.InvalidResourceConfiguration | Endpoint.InvalidExporterEndpoint\n\n/**\n * Parses `OTEL_EXPORTER_OTLP_HEADERS`: comma-separated `key=value` pairs whose\n * values are percent-decoded, as the OpenTelemetry exporter specification\n * defines. A pair without `=` or with an empty key is skipped.\n *\n * @category environment\n * @since 1.0.0\n */\nexport const parseHeaders = (value: string | undefined): Record<string, string> => {\n  const headers: Record<string, string> = {}\n  for (const pair of (value ?? \"\").split(\",\")) {\n    const separator = pair.indexOf(\"=\")\n    const key = pair.slice(0, separator).trim()\n    if (separator < 0 || key === \"\") continue\n    const raw = pair.slice(separator + 1).trim()\n    let decoded = raw\n    try {\n      decoded = decodeURIComponent(raw)\n    } catch { /* A malformed escape is kept verbatim. */ }\n    headers[key] = decoded\n  }\n  return headers\n}\n\n/**\n * {@link layerFetch} when the environment names a collector, otherwise\n * {@link layerNoop}.\n *\n * `OTEL_EXPORTER_OTLP_ENDPOINT` is the collector base URL and\n * `OTEL_EXPORTER_OTLP_HEADERS` the headers sent with every export. An unset or\n * empty endpoint installs no exporter at all.\n *\n * @category layers\n * @since 1.0.0\n */\nexport const layerEnvironment = (\n  environment: Readonly<Record<string, string | undefined>>,\n  options: Omit<Options, \"baseUrl\" | \"headers\"> = {}\n): Layer.Layer<never, LayerError> => {\n  const endpoint = environment[\"OTEL_EXPORTER_OTLP_ENDPOINT\"]?.trim()\n  if (endpoint === undefined || endpoint === \"\") return layerNoop\n  return layerFetch({ ...options, baseUrl: endpoint, headers: parseHeaders(environment[\"OTEL_EXPORTER_OTLP_HEADERS\"]) })\n}\n\n/**\n * Exports nothing. The explicit stand-in for hosts with no collector, such as\n * a development shell, a test, or a browser deployment that has not opted in, so\n * wiring code can switch layers rather than branch.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerNoop: Layer.Layer<never> = Layer.empty\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/Resource.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Explicit, validated OpenTelemetry resource metadata for Smithers.
+ *
+ * @since 0.1.0
+ */
+import * as OtelResource from "@effect/opentelemetry/Resource";
+import type { Attributes as OtelAttributes } from "@opentelemetry/api";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+/**
+ * Largest service-name or service-version field accepted by a resource.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumIdentityLength = 1024;
+/**
+ * Largest attribute key accepted by a resource.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumAttributeKeyLength = 1024;
+/**
+ * Largest string value accepted by one resource attribute.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumAttributeStringLength = 65536;
+/**
+ * Largest number of elements accepted in one array attribute value.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumAttributeArrayLength = 256;
+/**
+ * Largest number of attributes accepted by one resource.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumAttributes = 256;
+/**
+ * Largest OTLP/JSON encoding accepted for one whole resource, in UTF-8 bytes.
+ *
+ * The measure is the OTLP `Resource` message the exporters place in every
+ * request, `{"attributes":[{"key":…,"value":{…}}],"droppedAttributesCount":0}`
+ * with service identity and SDK-added `telemetry.sdk.name` and
+ * `telemetry.sdk.language` included, after JSON escaping and UTF-8 encoding.
+ * These SDK fields are conservatively reserved even for the default Effect
+ * exporter. Caller attributes overwritten by SDK identity or metadata are
+ * still counted. It is the bound the per-field limits cannot express: 256
+ * attributes at the string ceiling would encode to 16 MiB, and the resource
+ * rides in every export request, so the default transport, which discards a
+ * request over 1 MiB, would deliver nothing at all. 128 KiB admits one
+ * ASCII attribute at the string ceiling and leaves that transport 888 KiB of every
+ * request for the signal batch; see `Otlp.reservedBatchBytes`.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumResourceBytes = 131072;
+/**
+ * Runtime schema for one OpenTelemetry resource attribute value.
+ *
+ * @category schemas
+ * @since 1.0.0-rc.0
+ */
+export declare const AttributeValue: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>, Schema.$Array<Schema.Number>, Schema.$Array<Schema.Boolean>]>;
+/**
+ * Runtime schema for OpenTelemetry resource attributes.
+ *
+ * @category schemas
+ * @since 1.0.0-rc.0
+ */
+export declare const Attributes: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>, Schema.$Array<Schema.Number>, Schema.$Array<Schema.Boolean>]>>;
+/**
+ * Runtime schema for the service identity attached to exported telemetry.
+ *
+ * @category schemas
+ * @since 1.0.0-rc.0
+ */
+export declare const Configuration: Schema.Struct<{
+    readonly serviceName: Schema.NonEmptyString;
+    readonly serviceVersion: Schema.optional<Schema.NonEmptyString>;
+    readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>, Schema.$Array<Schema.Number>, Schema.$Array<Schema.Boolean>]>>>;
+}>;
+/**
+ * Configuration used to identify the service emitting telemetry.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export type Configuration = typeof Configuration.Type;
+declare const InvalidResourceConfiguration_base: Schema.Class<InvalidResourceConfiguration, Schema.TaggedStruct<"@smthrs/observability/InvalidResourceConfiguration", {
+    readonly code: Schema.Literal<"invalid_resource_configuration">;
+    readonly path: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Stable resource-configuration refusal shared by every OTEL layer.
+ *
+ * @category errors
+ * @since 1.0.0-rc.0
+ */
+export declare class InvalidResourceConfiguration extends InvalidResourceConfiguration_base {
+}
+/**
+ * Decodes one resource configuration without retaining rejected values.
+ *
+ * @category decoding
+ * @since 1.0.0-rc.0
+ */
+export declare const decode: (configuration: unknown) => Effect.Effect<Configuration, InvalidResourceConfiguration>;
+/**
+ * Decodes one resource configuration for the package's pure projection API.
+ *
+ * @category decoding
+ * @since 1.0.0-rc.0
+ */
+export declare const decodeSync: (configuration: unknown) => Configuration;
+/**
+ * Projects a decoded resource into the exact optional-property shape expected
+ * by the OpenTelemetry SDK.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const toOpenTelemetryConfiguration: (configuration: Configuration) => {
+    readonly serviceName: string;
+    readonly serviceVersion?: string;
+    readonly attributes?: OtelAttributes;
+};
+/**
+ * Converts explicit service metadata into OpenTelemetry resource attributes.
+ *
+ * No environment variables are read. Invalid metadata throws the same typed
+ * {@link InvalidResourceConfiguration} every layer returns during acquisition.
+ *
+ * @category conversions
+ * @since 1.0.0-rc.0
+ */
+export declare const configToAttributes: (configuration: Configuration) => OtelAttributes;
+/**
+ * Provides an explicitly validated OpenTelemetry resource.
+ *
+ * @category layers
+ * @since 1.0.0-rc.0
+ */
+export declare const layer: (configuration: Configuration) => Layer.Layer<OtelResource.Resource, InvalidResourceConfiguration>;
+/**
+ * The OpenTelemetry resource service.
+ *
+ * @category services
+ * @since 1.0.0-rc.0
+ */
+export declare const Resource: typeof OtelResource.Resource;
+export {};
+//# sourceMappingURL=Resource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Resource.d.ts","sourceRoot":"","sources":["../../src/Resource.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,YAAY,MAAM,gCAAgC,CAAA;AAC9D,OAAO,KAAK,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACtE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,OAAQ,CAAA;AAE1C;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,OAAQ,CAAA;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,QAAS,CAAA;AAElD;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,MAAM,CAAA;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,MAAM,CAAA;AAEpC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,oBAAoB,SAAU,CAAA;AAqB3C;;;;;GAKG;AACH,eAAO,MAAM,cAAc,kKAgB1B,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,iMAYtB,CAAA;AA0CD;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;EAqBzB,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;;;;;;AAErD;;;;;GAKG;AACH,qBAAa,4BAA6B,SAAQ,iCAOjD;CAAG;AAWJ;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GACjB,eAAe,OAAO,KACrB,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,4BAA4B,CAC6B,CAAA;AAEzF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,eAAe,OAAO,KAAG,aAMnD,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,GACvC,eAAe,aAAa,KAC3B;IACD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;IAChC,QAAQ,CAAC,UAAU,CAAC,EAAE,cAAc,CAAA;CAcpC,CAAA;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAAI,eAAe,aAAa,KAAG,cACwB,CAAA;AAE1F;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAChB,eAAe,aAAa,KAC3B,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,QAAQ,EAAE,4BAA4B,CAG/D,CAAA;AAEH;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,8BAAwB,CAAA"}

package/dist/cjs/Resource.js

@@ -0,0 +1,186 @@
+"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 Resource_exports = {};
+__export(Resource_exports, {
+  AttributeValue: () => AttributeValue,
+  Attributes: () => Attributes,
+  Configuration: () => Configuration,
+  InvalidResourceConfiguration: () => InvalidResourceConfiguration,
+  Resource: () => Resource,
+  configToAttributes: () => configToAttributes,
+  decode: () => decode,
+  decodeSync: () => decodeSync,
+  layer: () => layer,
+  maximumAttributeArrayLength: () => maximumAttributeArrayLength,
+  maximumAttributeKeyLength: () => maximumAttributeKeyLength,
+  maximumAttributeStringLength: () => maximumAttributeStringLength,
+  maximumAttributes: () => maximumAttributes,
+  maximumIdentityLength: () => maximumIdentityLength,
+  maximumResourceBytes: () => maximumResourceBytes,
+  toOpenTelemetryConfiguration: () => toOpenTelemetryConfiguration
+});
+module.exports = __toCommonJS(Resource_exports);
+var OtelResource = __toESM(require("@effect/opentelemetry/Resource"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var OtlpResource = __toESM(require("effect/unstable/observability/OtlpResource"), 1);
+var import_schemaIssuePath = require("./internal/schemaIssuePath.js");
+const maximumIdentityLength = 1024;
+const maximumAttributeKeyLength = 1024;
+const maximumAttributeStringLength = 65536;
+const maximumAttributeArrayLength = 256;
+const maximumAttributes = 256;
+const maximumResourceBytes = 131072;
+const loneSurrogate = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+const embeddedNul = new RegExp(String.fromCharCode(0));
+const isWellFormed = (value) => !loneSurrogate.test(value) && !embeddedNul.test(value);
+const identity = Schema.NonEmptyString.check(
+  Schema.isMaxLength(maximumIdentityLength),
+  Schema.makeFilter((value) => isWellFormed(value), { title: "wellFormedResourceIdentity" })
+);
+const attributeString = Schema.String.check(
+  Schema.isMaxLength(maximumAttributeStringLength),
+  Schema.makeFilter((value) => isWellFormed(value), { title: "wellFormedAttributeString" })
+);
+const attributeNumber = Schema.Number.check(
+  Schema.makeFilter((value) => Number.isFinite(value), { title: "finiteAttributeNumber" })
+);
+const AttributeValue = Schema.Union([
+  attributeString,
+  attributeNumber,
+  Schema.Boolean,
+  Schema.Array(attributeString),
+  Schema.Array(attributeNumber),
+  Schema.Array(Schema.Boolean)
+]).check(
+  Schema.makeFilter(
+    (value) => !Array.isArray(value) || value.length <= maximumAttributeArrayLength || {
+      path: [],
+      issue: `holds ${value.length} elements, over the ${maximumAttributeArrayLength} element limit`
+    },
+    { title: "boundedResourceAttributeArrays" }
+  )
+);
+const Attributes = Schema.Record(Schema.String, AttributeValue).check(
+  Schema.makeFilter(
+    (attributes) => Object.keys(attributes).length <= maximumAttributes,
+    { title: "boundedResourceAttributes" }
+  ),
+  Schema.makeFilter(
+    (attributes) => Object.keys(attributes).every(
+      (key) => key.length > 0 && key.length <= maximumAttributeKeyLength && isWellFormed(key)
+    ),
+    { title: "wellFormedResourceAttributeKeys" }
+  )
+);
+const encoder = new TextEncoder();
+const encodedResourceBytes = (configuration) => {
+  const bytes = (value) => encoder.encode(JSON.stringify(value)).byteLength;
+  const identityAttributes = OtelResource.configToAttributes({
+    serviceName: configuration.serviceName,
+    ...configuration.serviceVersion === void 0 ? {} : { serviceVersion: configuration.serviceVersion }
+  });
+  let total = bytes({
+    attributes: OtlpResource.entriesToAttributes(Object.entries(identityAttributes)),
+    droppedAttributesCount: 0
+  });
+  for (const [key, value] of Object.entries(configuration.attributes ?? {})) {
+    total += 1 + bytes({ key, value: Array.isArray(value) ? { arrayValue: { values: [] } } : null });
+    if (Array.isArray(value)) {
+      for (const [index, element] of value.entries()) {
+        total += (index === 0 ? 0 : 1) + bytes(OtlpResource.unknownToAttributeValue(element));
+        if (total > maximumResourceBytes) return total;
+      }
+    } else {
+      total += bytes(OtlpResource.unknownToAttributeValue(value)) - 4;
+    }
+    if (total > maximumResourceBytes) return total;
+  }
+  return total;
+};
+const Configuration = Schema.Struct({
+  serviceName: identity,
+  serviceVersion: Schema.optional(identity),
+  attributes: Schema.optional(Attributes)
+}).check(
+  Schema.makeFilter(
+    (configuration) => {
+      const bytes = encodedResourceBytes(configuration);
+      return bytes <= maximumResourceBytes || {
+        path: ["attributes"],
+        issue: `bring the resource to at least ${bytes} bytes of OTLP JSON, over the ${maximumResourceBytes} byte limit`
+      };
+    },
+    { title: "boundedResourceBytes" }
+  )
+);
+class InvalidResourceConfiguration extends Schema.TaggedError()(
+  "@smthrs/observability/InvalidResourceConfiguration",
+  {
+    code: Schema.Literal("invalid_resource_configuration"),
+    path: Schema.String,
+    message: Schema.String
+  }
+) {
+}
+const invalid = (cause) => {
+  const path = (0, import_schemaIssuePath.schemaIssuePath)(cause, "resource");
+  return new InvalidResourceConfiguration({
+    code: "invalid_resource_configuration",
+    path,
+    message: `OpenTelemetry resource ${path} ${(0, import_schemaIssuePath.schemaIssueMessage)(cause) ?? "is invalid"}`
+  });
+};
+const decode = (configuration) => Schema.decodeUnknownEffect(Configuration)(configuration).pipe(Effect.mapError(invalid));
+const decodeSync = (configuration) => {
+  try {
+    return Schema.decodeUnknownSync(Configuration)(configuration);
+  } catch (cause) {
+    throw invalid(cause);
+  }
+};
+const toOpenTelemetryConfiguration = (configuration) => ({
+  serviceName: configuration.serviceName,
+  ...configuration.serviceVersion === void 0 ? {} : { serviceVersion: configuration.serviceVersion },
+  ...configuration.attributes === void 0 ? {} : {
+    attributes: Object.fromEntries(
+      Object.entries(configuration.attributes).map(([key, value]) => [
+        key,
+        Array.isArray(value) ? [...value] : value
+      ])
+    )
+  }
+});
+const configToAttributes = (configuration) => OtelResource.configToAttributes(toOpenTelemetryConfiguration(decodeSync(configuration)));
+const layer = (configuration) => Layer.unwrap(
+  Effect.map(decode(configuration), (decoded) => OtelResource.layer(toOpenTelemetryConfiguration(decoded)))
+);
+const Resource = OtelResource.Resource;
+//# sourceMappingURL=Resource.js.map