@equipe-tech/observability 0.1.0 → 0.2.1

package/dist/MetricsRuntime.js

@@ -0,0 +1,1286 @@
+import { Context, Effect, Layer, Metric, Predicate, Schema } from "effect";
+import { HttpBody, HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { OtlpExporter } from "effect/unstable/observability";
+import { MetricsError } from "./Metrics.js";
+const instrumentNamePattern = /^[A-Za-z][A-Za-z0-9_.\-/]{0,254}$/;
+const unitPattern = /^(?:1|%|[A-Za-z][A-Za-z0-9]*(?:[./*^][A-Za-z0-9]+)*)$/;
+const containsControlCharacter = (value) => {
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        if (codePoint !== undefined && (codePoint <= 31 || codePoint === 127)) {
+            return true;
+        }
+    }
+    return false;
+};
+const maximumInstruments = 100;
+const maximumInstrumentSeries = 1_000;
+const maximumRuntimeSeries = 10_000;
+const maximumAttributes = 16;
+const maximumCallbacks = 16;
+const maximumObservations = 100;
+const MetricAttributeInput = Schema.Struct({
+    key: Schema.String,
+    value: Schema.Union([Schema.String, Schema.Number, Schema.Boolean]),
+});
+const MetricAttributesInput = Schema.Array(MetricAttributeInput);
+const InstrumentDefinitionInput = Schema.Struct({
+    name: Schema.String,
+    description: Schema.String,
+    unit: Schema.String,
+});
+const HistogramDefinitionInput = Schema.Struct({
+    name: Schema.String,
+    description: Schema.String,
+    unit: Schema.String,
+    boundaries: Schema.Array(Schema.Number),
+});
+const GaugeObservationsInput = Schema.Array(Schema.Struct({
+    value: Schema.Number,
+    attributes: MetricAttributesInput.pipe(Schema.optionalKey),
+}));
+const MetricsOptionsInput = Schema.Struct({
+    enabled: Schema.Boolean.pipe(Schema.optionalKey),
+    serviceName: Schema.String,
+    serviceVersion: Schema.String,
+    environment: Schema.String,
+    otlpEndpoint: Schema.String,
+    exportIntervalMilliseconds: Schema.Number.pipe(Schema.optionalKey),
+    flushTimeoutMilliseconds: Schema.Number.pipe(Schema.optionalKey),
+});
+const decodeMetricAttributes = Schema.decodeUnknownSync(MetricAttributesInput);
+const decodeInstrumentDefinition = Schema.decodeUnknownSync(InstrumentDefinitionInput);
+const decodeHistogramDefinition = Schema.decodeUnknownSync(HistogramDefinitionInput);
+const decodeGaugeObservations = Schema.decodeUnknownSync(GaugeObservationsInput);
+const decodeMetricsOptions = Schema.decodeUnknownSync(MetricsOptionsInput);
+const metricError = (code, operation, message, instrumentName, retryable, cause) => {
+    const options = {
+        code,
+        operation,
+        message,
+        retryable,
+        cause,
+    };
+    if (instrumentName === undefined) {
+        return new MetricsError(options);
+    }
+    return new MetricsError({ ...options, instrumentName });
+};
+const parseOptions = (input) => {
+    let options;
+    try {
+        options = decodeMetricsOptions(input);
+    }
+    catch (cause) {
+        throw metricError("INVALID_CONFIGURATION", "createMetrics", "Metrics configuration is invalid. Provide valid service metadata and an HTTP OTLP endpoint.", undefined, false, cause);
+    }
+    if (options.serviceName.length === 0 ||
+        options.serviceVersion.length === 0 ||
+        options.environment.length === 0) {
+        throw metricError("INVALID_CONFIGURATION", "createMetrics", "Metrics configuration is invalid. Service name, version, and environment must be nonempty.", undefined, false);
+    }
+    let endpoint;
+    try {
+        endpoint = new URL(options.otlpEndpoint);
+    }
+    catch (cause) {
+        throw metricError("INVALID_CONFIGURATION", "createMetrics", "Metrics configuration is invalid. Set otlpEndpoint to an HTTP or HTTPS URL without credentials.", undefined, false, cause);
+    }
+    if ((endpoint.protocol !== "http:" && endpoint.protocol !== "https:") ||
+        endpoint.username.length > 0 ||
+        endpoint.password.length > 0) {
+        throw metricError("INVALID_CONFIGURATION", "createMetrics", "Metrics configuration is invalid. Set otlpEndpoint to an HTTP or HTTPS URL without credentials.", undefined, false);
+    }
+    const exportIntervalMilliseconds = options.exportIntervalMilliseconds ?? 10_000;
+    const flushTimeoutMilliseconds = options.flushTimeoutMilliseconds ?? 3_000;
+    if (!Number.isSafeInteger(exportIntervalMilliseconds) ||
+        exportIntervalMilliseconds < 1 ||
+        !Number.isSafeInteger(flushTimeoutMilliseconds) ||
+        flushTimeoutMilliseconds < 1) {
+        throw metricError("INVALID_CONFIGURATION", "createMetrics", "Metrics configuration is invalid. Export and flush intervals must be positive safe integer milliseconds.", undefined, false);
+    }
+    endpoint.pathname = `${endpoint.pathname.replace(/\/$/, "")}/v1/metrics`;
+    endpoint.search = "";
+    endpoint.hash = "";
+    const enabled = options.enabled ?? true;
+    const poolKey = JSON.stringify([
+        endpoint.toString(),
+        options.serviceName,
+        options.serviceVersion,
+        options.environment,
+        exportIntervalMilliseconds,
+        flushTimeoutMilliseconds,
+    ]);
+    return {
+        enabled,
+        serviceName: options.serviceName,
+        serviceVersion: options.serviceVersion,
+        environment: options.environment,
+        metricsEndpoint: endpoint.toString(),
+        exportIntervalMilliseconds,
+        flushTimeoutMilliseconds,
+        poolKey,
+    };
+};
+const parseDefinition = (input, operation) => {
+    let definition;
+    try {
+        definition = decodeInstrumentDefinition(input);
+    }
+    catch (cause) {
+        throw metricError("INVALID_INSTRUMENT", operation, "Metric instrument definition is invalid. Provide a valid name, description, and unit.", undefined, false, cause);
+    }
+    if (!instrumentNamePattern.test(definition.name) ||
+        definition.description.length < 1 ||
+        definition.description.length > 1_024 ||
+        containsControlCharacter(definition.description) ||
+        definition.unit.length > 63 ||
+        !unitPattern.test(definition.unit)) {
+        throw metricError("INVALID_INSTRUMENT", operation, `Metric instrument "${definition.name}" is invalid. Check its name, description, and unit.`, definition.name, false);
+    }
+    return definition;
+};
+const parseHistogramDefinition = (input) => {
+    let definition;
+    try {
+        definition = decodeHistogramDefinition(input);
+    }
+    catch (cause) {
+        throw metricError("INVALID_INSTRUMENT", "histogram", "Histogram definition is invalid. Provide a valid definition and finite boundaries.", undefined, false, cause);
+    }
+    const common = parseDefinition(definition, "histogram");
+    if (definition.boundaries.length < 1 || definition.boundaries.length > 50) {
+        throw metricError("INVALID_INSTRUMENT", "histogram", `Histogram "${definition.name}" must have between 1 and 50 boundaries.`, definition.name, false);
+    }
+    let previous = Number.NEGATIVE_INFINITY;
+    for (const boundary of definition.boundaries) {
+        if (!Number.isFinite(boundary) || boundary <= previous) {
+            throw metricError("INVALID_INSTRUMENT", "histogram", `Histogram "${definition.name}" boundaries must be finite and strictly increasing.`, definition.name, false);
+        }
+        previous = boundary;
+    }
+    return { ...common, boundaries: [...definition.boundaries] };
+};
+const attributeIdentity = (value) => {
+    if (Predicate.isString(value)) {
+        return `s:${JSON.stringify(value)}`;
+    }
+    if (Predicate.isBoolean(value)) {
+        return value ? "b:1" : "b:0";
+    }
+    return `n:${Object.is(value, -0) ? 0 : value}`;
+};
+const parseAttributes = (input, operation, instrumentName) => {
+    let attributes;
+    try {
+        attributes = decodeMetricAttributes(input ?? []);
+    }
+    catch (cause) {
+        throw metricError("INVALID_MEASUREMENT", operation, `Metric "${instrumentName}" attributes are invalid. Use bounded scalar attributes.`, instrumentName, false, cause);
+    }
+    if (attributes.length > maximumAttributes) {
+        throw metricError("LIMIT_EXCEEDED", operation, `Metric "${instrumentName}" exceeds the ${maximumAttributes}-attribute limit.`, instrumentName, false);
+    }
+    const keys = new Set();
+    const normalized = [];
+    for (const attribute of attributes) {
+        const numberIsInvalid = Predicate.isNumber(attribute.value) && !Number.isFinite(attribute.value);
+        const stringIsInvalid = Predicate.isString(attribute.value) &&
+            (attribute.value.length > 256 || containsControlCharacter(attribute.value));
+        if (attribute.key.length > 128 ||
+            !instrumentNamePattern.test(attribute.key) ||
+            attribute.key === "unit" ||
+            attribute.key === "time_unit" ||
+            keys.has(attribute.key) ||
+            numberIsInvalid ||
+            stringIsInvalid) {
+            throw metricError("INVALID_MEASUREMENT", operation, `Metric "${instrumentName}" attributes are invalid. Use unique bounded keys and finite scalar values.`, instrumentName, false);
+        }
+        keys.add(attribute.key);
+        normalized.push({
+            key: attribute.key,
+            value: Predicate.isNumber(attribute.value) && Object.is(attribute.value, -0) ? 0 : attribute.value,
+        });
+    }
+    normalized.sort((left, right) => left.key.localeCompare(right.key));
+    return {
+        identity: normalized
+            .map((attribute) => `${attribute.key}=${attributeIdentity(attribute.value)}`)
+            .join("|"),
+        values: normalized,
+    };
+};
+const attributesToOtlp = (attributes) => attributes.map((attribute) => {
+    if (Predicate.isString(attribute.value)) {
+        return { key: attribute.key, value: { stringValue: attribute.value } };
+    }
+    if (Predicate.isBoolean(attribute.value)) {
+        return { key: attribute.key, value: { boolValue: attribute.value } };
+    }
+    if (Number.isInteger(attribute.value)) {
+        return { key: attribute.key, value: { intValue: attribute.value } };
+    }
+    return { key: attribute.key, value: { doubleValue: attribute.value } };
+});
+const directAttributesToOtlp = (attributes) => {
+    if (attributes === undefined) {
+        return [];
+    }
+    const values = [];
+    for (const [key, value] of Object.entries(attributes)) {
+        if (key !== "unit" && key !== "time_unit") {
+            values.push({ key, value: { stringValue: value } });
+        }
+    }
+    return values;
+};
+const sameDefinition = (entry, kind, definition, boundaries) => {
+    if (entry.kind !== kind ||
+        entry.definition.name !== definition.name ||
+        entry.definition.description !== definition.description ||
+        entry.definition.unit !== definition.unit) {
+        return false;
+    }
+    if (entry.kind !== "histogram") {
+        return boundaries === undefined;
+    }
+    if (boundaries === undefined || entry.definition.boundaries.length !== boundaries.length) {
+        return false;
+    }
+    return entry.definition.boundaries.every((boundary, index) => boundary === boundaries[index]);
+};
+const histogramBucketIndex = (boundaries, value) => {
+    for (let index = 0; index < boundaries.length; index++) {
+        const boundary = boundaries[index];
+        if (boundary !== undefined && value <= boundary) {
+            return index;
+        }
+    }
+    return boundaries.length;
+};
+const nanosNow = () => String(BigInt(Date.now()) * 1000000n);
+class MetricsRuntimeState {
+    registry = new Map();
+    directContext = Context.make(Metric.MetricRegistry, this.registry);
+    catalog = new Map();
+    runtimeLifetimeSeries = new Set();
+    lifetimeSeriesByInstrument = new Map();
+    lifetimeInstrumentNames = new Set();
+    leases = new Set();
+    transports = new Map();
+    options;
+    removeFromPool;
+    startTimeUnixNano = nanosNow();
+    tail = Promise.resolve();
+    timer;
+    nextLeaseId = 1;
+    nextCallbackId = 1;
+    referenceCount = 0;
+    periodicFailureActive = false;
+    constructor(options, removeFromPool) {
+        this.options = options;
+        this.removeFromPool = removeFromPool;
+        this.timer = setInterval(() => {
+            this.scheduleExport(this.options.flushTimeoutMilliseconds).then((result) => this.recordPeriodicOutcome(result.gaugeFailures.length > 0), () => this.recordPeriodicOutcome(true));
+        }, options.exportIntervalMilliseconds);
+        this.timer.unref?.();
+    }
+    acquire(transport) {
+        const leaseId = this.nextLeaseId++;
+        this.leases.add(leaseId);
+        this.transports.set(leaseId, transport);
+        this.referenceCount++;
+        return { leaseId, state: this };
+    }
+    nextGaugeCallbackId() {
+        return this.nextCallbackId++;
+    }
+    flush(timeoutMilliseconds) {
+        return this.scheduleExport(timeoutMilliseconds);
+    }
+    async closeLease(leaseId, timeoutMilliseconds) {
+        let result;
+        let failure;
+        try {
+            result = await this.scheduleExport(timeoutMilliseconds);
+        }
+        catch (cause) {
+            result = { gaugeFailures: [] };
+            failure =
+                cause instanceof MetricsError
+                    ? cause
+                    : metricError("EXPORT_FAILED", "close", "The final metrics export failed. The runtime lease was still released.", undefined, true, cause);
+        }
+        this.removeLeaseState(leaseId);
+        this.leases.delete(leaseId);
+        this.transports.delete(leaseId);
+        this.referenceCount--;
+        if (this.referenceCount === 0) {
+            if (this.timer !== undefined) {
+                clearInterval(this.timer);
+                this.timer = undefined;
+            }
+            this.removeFromPool();
+        }
+        if (failure !== undefined) {
+            throw failure;
+        }
+        return result;
+    }
+    registerCounter(leaseId, definition) {
+        const existing = this.catalog.get(definition.name);
+        if (existing !== undefined) {
+            if (existing.kind !== "counter" ||
+                !sameDefinition(existing, "counter", definition, undefined)) {
+                throw this.instrumentConflict("counter", definition.name);
+            }
+            existing.leases.add(leaseId);
+            return existing;
+        }
+        this.assertInstrumentCapacity(definition.name);
+        const entry = {
+            kind: "counter",
+            definition,
+            leases: new Set([leaseId]),
+            residualSeries: new Map(),
+            seriesByLease: new Map(),
+            lifetimeSeries: this.lifetimeSeriesFor(definition.name),
+        };
+        this.catalog.set(definition.name, entry);
+        return entry;
+    }
+    registerHistogram(leaseId, definition) {
+        const existing = this.catalog.get(definition.name);
+        if (existing !== undefined) {
+            if (existing.kind !== "histogram" ||
+                !sameDefinition(existing, "histogram", definition, definition.boundaries)) {
+                throw this.instrumentConflict("histogram", definition.name);
+            }
+            existing.leases.add(leaseId);
+            return existing;
+        }
+        this.assertInstrumentCapacity(definition.name);
+        const entry = {
+            kind: "histogram",
+            definition,
+            leases: new Set([leaseId]),
+            residualSeries: new Map(),
+            seriesByLease: new Map(),
+            lifetimeSeries: this.lifetimeSeriesFor(definition.name),
+        };
+        this.catalog.set(definition.name, entry);
+        return entry;
+    }
+    registerGauge(leaseId, definition, callback) {
+        const existing = this.catalog.get(definition.name);
+        let entry;
+        if (existing !== undefined) {
+            if (!sameDefinition(existing, "gauge", definition, undefined) || existing.kind !== "gauge") {
+                throw this.instrumentConflict("observableGauge", definition.name);
+            }
+            entry = existing;
+        }
+        else {
+            this.assertInstrumentCapacity(definition.name);
+            entry = {
+                kind: "gauge",
+                definition,
+                leases: new Set(),
+                callbacks: new Map(),
+                lifetimeSeries: this.lifetimeSeriesFor(definition.name),
+            };
+            this.catalog.set(definition.name, entry);
+        }
+        if (entry.callbacks.size >= maximumCallbacks) {
+            throw metricError("LIMIT_EXCEEDED", "observableGauge", `Observable gauge "${definition.name}" exceeds the ${maximumCallbacks}-callback limit.`, definition.name, false);
+        }
+        const callbackId = this.nextGaugeCallbackId();
+        entry.leases.add(leaseId);
+        entry.callbacks.set(callbackId, { id: callbackId, leaseId, callback });
+        return { entry, callbackId };
+    }
+    unregisterGauge(name, callbackId) {
+        const entry = this.catalog.get(name);
+        if (entry === undefined || entry.kind !== "gauge") {
+            return;
+        }
+        const registration = entry.callbacks.get(callbackId);
+        if (registration === undefined) {
+            return;
+        }
+        entry.callbacks.delete(callbackId);
+        const leaseStillRegistered = Array.from(entry.callbacks.values()).some((candidate) => candidate.leaseId === registration.leaseId);
+        if (!leaseStillRegistered) {
+            entry.leases.delete(registration.leaseId);
+        }
+        if (entry.callbacks.size === 0) {
+            this.catalog.delete(name);
+        }
+    }
+    addCounter(leaseId, entry, value, attributes) {
+        this.assertLease(leaseId, "add", entry.definition.name);
+        if (!Number.isFinite(value) || value < 0) {
+            throw metricError("INVALID_MEASUREMENT", "add", `Counter "${entry.definition.name}" accepts only finite values greater than or equal to zero.`, entry.definition.name, false);
+        }
+        this.prepareSeries(entry, attributes, "add");
+        let leaseSeries = entry.seriesByLease.get(leaseId);
+        if (leaseSeries === undefined) {
+            leaseSeries = new Map();
+            entry.seriesByLease.set(leaseId, leaseSeries);
+        }
+        const current = leaseSeries.get(attributes.identity);
+        if (current === undefined) {
+            leaseSeries.set(attributes.identity, { attributes, value });
+            this.commitSeries(entry, attributes.identity);
+        }
+        else {
+            current.value += value;
+        }
+    }
+    recordHistogram(leaseId, entry, value, attributes) {
+        this.assertLease(leaseId, "record", entry.definition.name);
+        if (!Number.isFinite(value)) {
+            throw metricError("INVALID_MEASUREMENT", "record", `Histogram "${entry.definition.name}" accepts only finite values.`, entry.definition.name, false);
+        }
+        this.prepareSeries(entry, attributes, "record");
+        let leaseSeries = entry.seriesByLease.get(leaseId);
+        if (leaseSeries === undefined) {
+            leaseSeries = new Map();
+            entry.seriesByLease.set(leaseId, leaseSeries);
+        }
+        const current = leaseSeries.get(attributes.identity);
+        if (current === undefined) {
+            const bucketCounts = Array.from({ length: entry.definition.boundaries.length + 1 }, () => 0);
+            const bucketIndex = histogramBucketIndex(entry.definition.boundaries, value);
+            bucketCounts[bucketIndex] = 1;
+            leaseSeries.set(attributes.identity, {
+                attributes,
+                count: 1,
+                sum: value,
+                min: value,
+                max: value,
+                bucketCounts,
+            });
+            this.commitSeries(entry, attributes.identity);
+        }
+        else {
+            current.count++;
+            current.sum += value;
+            current.min = Math.min(current.min, value);
+            current.max = Math.max(current.max, value);
+            const bucketIndex = histogramBucketIndex(entry.definition.boundaries, value);
+            const count = current.bucketCounts[bucketIndex];
+            current.bucketCounts[bucketIndex] = (count ?? 0) + 1;
+        }
+    }
+    lifetimeSeriesFor(name) {
+        let series = this.lifetimeSeriesByInstrument.get(name);
+        if (series === undefined) {
+            series = new Set();
+            this.lifetimeSeriesByInstrument.set(name, series);
+        }
+        return series;
+    }
+    recordPeriodicOutcome(failed) {
+        if (failed === this.periodicFailureActive) {
+            return;
+        }
+        this.periodicFailureActive = failed;
+        console.warn(failed
+            ? "OBS_METRICS_PERIODIC_EXPORT_FAILED: The periodic metrics export entered a failed state."
+            : "OBS_METRICS_PERIODIC_EXPORT_RECOVERED: The periodic metrics export recovered.");
+    }
+    assertInstrumentCapacity(name) {
+        if (this.lifetimeInstrumentNames.has(name)) {
+            return;
+        }
+        if (this.lifetimeInstrumentNames.size >= maximumInstruments) {
+            throw metricError("LIMIT_EXCEEDED", "registerInstrument", `Metric runtime exceeds the ${maximumInstruments}-instrument lifetime limit while registering "${name}".`, name, false);
+        }
+        this.lifetimeInstrumentNames.add(name);
+    }
+    instrumentConflict(operation, name) {
+        return metricError("INSTRUMENT_CONFLICT", operation, `Metric instrument "${name}" conflicts with an existing definition. Reuse the exact kind, unit, description, and boundaries.`, name, false);
+    }
+    assertLease(leaseId, operation, name) {
+        if (!this.leases.has(leaseId)) {
+            throw metricError("CLOSED", operation, `Metrics lifecycle is closed. Create a new lifecycle before using "${name}".`, name, false);
+        }
+    }
+    prepareSeries(entry, attributes, operation) {
+        const runtimeIdentity = `${entry.definition.name}:${attributes.identity}`;
+        if (!entry.lifetimeSeries.has(attributes.identity) &&
+            entry.lifetimeSeries.size >= maximumInstrumentSeries) {
+            throw metricError("LIMIT_EXCEEDED", operation, `Metric "${entry.definition.name}" exceeds the ${maximumInstrumentSeries}-series lifetime limit.`, entry.definition.name, false);
+        }
+        if (!this.runtimeLifetimeSeries.has(runtimeIdentity) &&
+            this.runtimeLifetimeSeries.size >= maximumRuntimeSeries) {
+            throw metricError("LIMIT_EXCEEDED", operation, `Metric runtime exceeds the ${maximumRuntimeSeries}-series lifetime limit.`, entry.definition.name, false);
+        }
+        return runtimeIdentity;
+    }
+    commitSeries(entry, identity) {
+        entry.lifetimeSeries.add(identity);
+        this.runtimeLifetimeSeries.add(`${entry.definition.name}:${identity}`);
+    }
+    transportForExport() {
+        let selected;
+        for (const transport of this.transports.values()) {
+            if (selected === undefined || transport.kind === "layer") {
+                selected = transport;
+            }
+        }
+        if (selected === undefined) {
+            throw metricError("EXPORT_FAILED", "flush", "Metrics export has no active transport. Acquire a runtime lease before flushing.", undefined, false);
+        }
+        return selected.send;
+    }
+    scheduleExport(timeoutMilliseconds) {
+        const controller = new AbortController();
+        let timedOut = false;
+        const operation = this.tail.then(async () => {
+            if (controller.signal.aborted) {
+                throw metricError("FLUSH_TIMED_OUT", "flush", `Metrics flush exceeded ${timeoutMilliseconds} milliseconds. Retry the flush before closing.`, undefined, true);
+            }
+            const collection = this.collectPayload();
+            const transport = this.transportForExport();
+            try {
+                await transport(collection.payload, controller.signal);
+            }
+            catch (cause) {
+                if (timedOut || controller.signal.aborted) {
+                    throw metricError("FLUSH_TIMED_OUT", "flush", `Metrics flush exceeded ${timeoutMilliseconds} milliseconds. Retry the flush before closing.`, undefined, true, cause);
+                }
+                throw metricError("EXPORT_FAILED", "flush", "Metrics export failed. Verify the OTLP endpoint and retry the flush.", undefined, true, cause);
+            }
+            return collection.result;
+        });
+        this.tail = operation.then(() => undefined, () => undefined);
+        let timer;
+        const timeout = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => {
+                timedOut = true;
+                controller.abort();
+                reject(metricError("FLUSH_TIMED_OUT", "flush", `Metrics flush exceeded ${timeoutMilliseconds} milliseconds. Retry the flush before closing.`, undefined, true));
+            }, timeoutMilliseconds);
+        });
+        return Promise.race([operation, timeout]).finally(() => {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+            }
+        });
+    }
+    collectPayload() {
+        const timeUnixNano = nanosNow();
+        const metrics = [];
+        const names = new Map();
+        for (const snapshot of Metric.snapshotUnsafe(this.directContext)) {
+            this.appendDirectMetric(metrics, names, snapshot, timeUnixNano);
+        }
+        const gaugeFailures = [];
+        for (const entry of this.catalog.values()) {
+            const existing = names.get(entry.definition.name);
+            const definitionIdentity = `${entry.kind}:${entry.definition.unit}:${entry.definition.description}`;
+            if (existing !== undefined && existing.definition !== definitionIdentity) {
+                throw metricError("EXPORT_FAILED", "flush", `Metric "${entry.definition.name}" conflicts with a direct Effect metric. Rename one instrument before retrying.`, entry.definition.name, false);
+            }
+            names.set(entry.definition.name, { kind: entry.kind, definition: definitionIdentity });
+            if (entry.kind === "counter") {
+                metrics.push(this.collectCounter(entry, timeUnixNano));
+            }
+            else if (entry.kind === "histogram") {
+                metrics.push(this.collectHistogram(entry, timeUnixNano));
+            }
+            else {
+                const gauge = this.collectGauge(entry, timeUnixNano);
+                gaugeFailures.push(...gauge.failures);
+                if (gauge.metric !== undefined) {
+                    metrics.push(gauge.metric);
+                }
+            }
+        }
+        return {
+            payload: {
+                resourceMetrics: [
+                    {
+                        resource: {
+                            attributes: [
+                                { key: "service.name", value: { stringValue: this.options.serviceName } },
+                                { key: "service.version", value: { stringValue: this.options.serviceVersion } },
+                                {
+                                    key: "deployment.environment.name",
+                                    value: { stringValue: this.options.environment },
+                                },
+                            ],
+                            droppedAttributesCount: 0,
+                        },
+                        scopeMetrics: [
+                            {
+                                scope: { name: this.options.serviceName },
+                                metrics,
+                            },
+                        ],
+                    },
+                ],
+            },
+            result: { gaugeFailures },
+        };
+    }
+    appendDirectMetric(metrics, names, snapshot, timeUnixNano) {
+        const unit = snapshot.attributes?.unit ?? snapshot.attributes?.time_unit ?? "1";
+        const description = snapshot.description ?? "";
+        const definitionIdentity = `${snapshot.type}:${unit}:${description}`;
+        const existing = names.get(snapshot.id);
+        if (existing !== undefined && existing.definition !== definitionIdentity) {
+            throw metricError("EXPORT_FAILED", "flush", `Direct Effect metric "${snapshot.id}" has incompatible definitions. Rename or align the definitions before retrying.`, snapshot.id, false);
+        }
+        const attributes = directAttributesToOtlp(snapshot.attributes);
+        const previous = metrics.find((metric) => metric.name === snapshot.id);
+        names.set(snapshot.id, { kind: snapshot.type, definition: definitionIdentity });
+        if (snapshot.type === "Counter") {
+            const point = this.numberPoint(snapshot.state.count, attributes, timeUnixNano);
+            if (previous?.sum !== undefined) {
+                previous.sum.dataPoints.push(point);
+            }
+            else {
+                metrics.push({
+                    name: snapshot.id,
+                    description,
+                    unit,
+                    sum: {
+                        aggregationTemporality: 2,
+                        isMonotonic: snapshot.state.incremental,
+                        dataPoints: [point],
+                    },
+                });
+            }
+        }
+        else if (snapshot.type === "Gauge") {
+            const point = this.numberPoint(snapshot.state.value, attributes, timeUnixNano);
+            if (previous?.gauge !== undefined) {
+                previous.gauge.dataPoints.push(point);
+            }
+            else {
+                metrics.push({ name: snapshot.id, description, unit, gauge: { dataPoints: [point] } });
+            }
+        }
+        else if (snapshot.type === "Histogram") {
+            const buckets = [];
+            const bounds = [];
+            let previousCount = 0;
+            for (let index = 0; index < snapshot.state.buckets.length; index++) {
+                const bucket = snapshot.state.buckets[index];
+                if (bucket !== undefined) {
+                    if (index < snapshot.state.buckets.length - 1) {
+                        bounds.push(bucket[0]);
+                    }
+                    buckets.push(bucket[1] - previousCount);
+                    previousCount = bucket[1];
+                }
+            }
+            const point = {
+                attributes,
+                startTimeUnixNano: this.startTimeUnixNano,
+                timeUnixNano,
+                count: snapshot.state.count,
+                sum: snapshot.state.sum,
+                min: snapshot.state.min,
+                max: snapshot.state.max,
+                explicitBounds: bounds,
+                bucketCounts: buckets,
+            };
+            if (previous?.histogram !== undefined) {
+                previous.histogram.dataPoints.push(point);
+            }
+            else {
+                metrics.push({
+                    name: snapshot.id,
+                    description,
+                    unit,
+                    histogram: { aggregationTemporality: 2, dataPoints: [point] },
+                });
+            }
+        }
+        else if (snapshot.type === "Frequency") {
+            const dataPoints = [];
+            for (const [key, value] of snapshot.state.occurrences) {
+                dataPoints.push({
+                    ...this.numberPoint(value, attributes, timeUnixNano),
+                    attributes: [...attributes, { key: "key", value: { stringValue: key } }],
+                });
+            }
+            if (previous?.sum !== undefined) {
+                previous.sum.dataPoints.push(...dataPoints);
+            }
+            else {
+                metrics.push({
+                    name: snapshot.id,
+                    description,
+                    unit,
+                    sum: { aggregationTemporality: 2, isMonotonic: true, dataPoints },
+                });
+            }
+        }
+        else {
+            const derivedNames = [
+                `${snapshot.id}_quantiles`,
+                `${snapshot.id}_count`,
+                `${snapshot.id}_sum`,
+            ];
+            for (const derivedName of derivedNames) {
+                const derivedDefinition = `${definitionIdentity}:${derivedName}`;
+                const derivedExisting = names.get(derivedName);
+                if (derivedExisting !== undefined && derivedExisting.definition !== derivedDefinition) {
+                    throw metricError("EXPORT_FAILED", "flush", `Direct Effect summary "${snapshot.id}" conflicts with metric "${derivedName}". Rename one instrument before retrying.`, snapshot.id, false);
+                }
+                names.set(derivedName, { kind: "Summary", definition: derivedDefinition });
+            }
+            const dataPoints = [];
+            dataPoints.push({
+                ...this.numberPoint(snapshot.state.min, attributes, timeUnixNano),
+                attributes: [...attributes, { key: "quantile", value: { stringValue: "min" } }],
+            });
+            for (const [quantile, value] of snapshot.state.quantiles) {
+                dataPoints.push({
+                    ...this.numberPoint(value ?? 0, attributes, timeUnixNano),
+                    attributes: [
+                        ...attributes,
+                        { key: "quantile", value: { stringValue: quantile.toString() } },
+                    ],
+                });
+            }
+            dataPoints.push({
+                ...this.numberPoint(snapshot.state.max, attributes, timeUnixNano),
+                attributes: [...attributes, { key: "quantile", value: { stringValue: "max" } }],
+            });
+            const countPoint = this.numberPoint(snapshot.state.count, attributes, timeUnixNano);
+            const sumPoint = this.numberPoint(snapshot.state.sum, attributes, timeUnixNano);
+            const existingQuantiles = metrics.find((metric) => metric.name === `${snapshot.id}_quantiles`);
+            const existingCount = metrics.find((metric) => metric.name === `${snapshot.id}_count`);
+            const existingSum = metrics.find((metric) => metric.name === `${snapshot.id}_sum`);
+            if (existingQuantiles?.sum !== undefined &&
+                existingCount?.sum !== undefined &&
+                existingSum?.sum !== undefined) {
+                existingQuantiles.sum.dataPoints.push(...dataPoints);
+                existingCount.sum.dataPoints.push(countPoint);
+                existingSum.sum.dataPoints.push(sumPoint);
+            }
+            else {
+                metrics.push({
+                    name: `${snapshot.id}_quantiles`,
+                    description,
+                    unit,
+                    sum: { aggregationTemporality: 2, isMonotonic: false, dataPoints },
+                }, {
+                    name: `${snapshot.id}_count`,
+                    description,
+                    unit: "1",
+                    sum: {
+                        aggregationTemporality: 2,
+                        isMonotonic: true,
+                        dataPoints: [countPoint],
+                    },
+                }, {
+                    name: `${snapshot.id}_sum`,
+                    description,
+                    unit: "1",
+                    sum: {
+                        aggregationTemporality: 2,
+                        isMonotonic: true,
+                        dataPoints: [sumPoint],
+                    },
+                });
+            }
+        }
+    }
+    numberPoint(value, attributes, timeUnixNano) {
+        const common = {
+            attributes,
+            startTimeUnixNano: this.startTimeUnixNano,
+            timeUnixNano,
+        };
+        if (Predicate.isBigInt(value)) {
+            return { ...common, asInt: Number(value) };
+        }
+        return { ...common, asDouble: value };
+    }
+    collectCounter(entry, timeUnixNano) {
+        const combined = new Map();
+        for (const [identity, series] of entry.residualSeries) {
+            combined.set(identity, { attributes: series.attributes, value: series.value });
+        }
+        for (const leaseSeries of entry.seriesByLease.values()) {
+            for (const [identity, series] of leaseSeries) {
+                const current = combined.get(identity);
+                if (current === undefined) {
+                    combined.set(identity, { attributes: series.attributes, value: series.value });
+                }
+                else {
+                    current.value += series.value;
+                }
+            }
+        }
+        return {
+            name: entry.definition.name,
+            description: entry.definition.description,
+            unit: entry.definition.unit,
+            sum: {
+                aggregationTemporality: 2,
+                isMonotonic: true,
+                dataPoints: Array.from(combined.values()).map((series) => ({
+                    attributes: attributesToOtlp(series.attributes.values),
+                    startTimeUnixNano: this.startTimeUnixNano,
+                    timeUnixNano,
+                    asDouble: series.value,
+                })),
+            },
+        };
+    }
+    collectHistogram(entry, timeUnixNano) {
+        const combined = new Map();
+        for (const [identity, series] of entry.residualSeries) {
+            combined.set(identity, {
+                attributes: series.attributes,
+                count: series.count,
+                sum: series.sum,
+                min: series.min,
+                max: series.max,
+                bucketCounts: [...series.bucketCounts],
+            });
+        }
+        for (const leaseSeries of entry.seriesByLease.values()) {
+            for (const [identity, series] of leaseSeries) {
+                const current = combined.get(identity);
+                if (current === undefined) {
+                    combined.set(identity, {
+                        attributes: series.attributes,
+                        count: series.count,
+                        sum: series.sum,
+                        min: series.min,
+                        max: series.max,
+                        bucketCounts: [...series.bucketCounts],
+                    });
+                }
+                else {
+                    current.count += series.count;
+                    current.sum += series.sum;
+                    current.min = Math.min(current.min, series.min);
+                    current.max = Math.max(current.max, series.max);
+                    for (let index = 0; index < current.bucketCounts.length; index++) {
+                        current.bucketCounts[index] =
+                            (current.bucketCounts[index] ?? 0) + (series.bucketCounts[index] ?? 0);
+                    }
+                }
+            }
+        }
+        return {
+            name: entry.definition.name,
+            description: entry.definition.description,
+            unit: entry.definition.unit,
+            histogram: {
+                aggregationTemporality: 2,
+                dataPoints: Array.from(combined.values()).map((series) => ({
+                    attributes: attributesToOtlp(series.attributes.values),
+                    startTimeUnixNano: this.startTimeUnixNano,
+                    timeUnixNano,
+                    count: series.count,
+                    sum: series.sum,
+                    min: series.min,
+                    max: series.max,
+                    explicitBounds: entry.definition.boundaries,
+                    bucketCounts: series.bucketCounts,
+                })),
+            },
+        };
+    }
+    collectGauge(entry, timeUnixNano) {
+        const observations = [];
+        const failures = [];
+        const proposedIdentities = new Set();
+        for (const registration of entry.callbacks.values()) {
+            let callbackResult;
+            try {
+                callbackResult = registration.callback();
+            }
+            catch {
+                failures.push({
+                    instrumentName: entry.definition.name,
+                    code: "CALLBACK_FAILED",
+                    message: `Observable gauge "${entry.definition.name}" callback failed and was omitted from this export.`,
+                });
+                continue;
+            }
+            let callbackObservations;
+            try {
+                callbackObservations = decodeGaugeObservations(callbackResult);
+            }
+            catch {
+                failures.push({
+                    instrumentName: entry.definition.name,
+                    code: "INVALID_OBSERVATION",
+                    message: `Observable gauge "${entry.definition.name}" returned an invalid synchronous observation batch.`,
+                });
+                continue;
+            }
+            if (callbackObservations.length > maximumObservations) {
+                failures.push({
+                    instrumentName: entry.definition.name,
+                    code: "SERIES_LIMIT_EXCEEDED",
+                    message: `Observable gauge "${entry.definition.name}" exceeds the ${maximumObservations}-observation collection limit.`,
+                });
+                continue;
+            }
+            const callbackBatch = [];
+            const callbackIdentities = new Set();
+            let callbackFailed = false;
+            for (const observation of callbackObservations) {
+                if (!Number.isFinite(observation.value)) {
+                    failures.push({
+                        instrumentName: entry.definition.name,
+                        code: "INVALID_OBSERVATION",
+                        message: `Observable gauge "${entry.definition.name}" produced a non-finite observation.`,
+                    });
+                    callbackFailed = true;
+                    break;
+                }
+                try {
+                    const attributes = parseAttributes(observation.attributes, "collectObservableGauge", entry.definition.name);
+                    if (proposedIdentities.has(attributes.identity) ||
+                        callbackIdentities.has(attributes.identity)) {
+                        failures.push({
+                            instrumentName: entry.definition.name,
+                            code: "INVALID_OBSERVATION",
+                            message: `Observable gauge "${entry.definition.name}" produced duplicate attribute sets.`,
+                        });
+                        callbackFailed = true;
+                        break;
+                    }
+                    callbackIdentities.add(attributes.identity);
+                    callbackBatch.push({ value: observation.value, attributes });
+                }
+                catch (cause) {
+                    const code = cause instanceof MetricsError && cause.code === "LIMIT_EXCEEDED"
+                        ? "ATTRIBUTE_LIMIT_EXCEEDED"
+                        : "INVALID_OBSERVATION";
+                    failures.push({
+                        instrumentName: entry.definition.name,
+                        code,
+                        message: `Observable gauge "${entry.definition.name}" produced invalid bounded attributes.`,
+                    });
+                    callbackFailed = true;
+                    break;
+                }
+            }
+            if (!callbackFailed) {
+                for (const observation of callbackBatch) {
+                    proposedIdentities.add(observation.attributes.identity);
+                    observations.push(observation);
+                }
+            }
+        }
+        if (failures.length > 0) {
+            return { metric: undefined, failures };
+        }
+        const newIdentities = Array.from(proposedIdentities).filter((identity) => !entry.lifetimeSeries.has(identity));
+        const newRuntimeIdentities = newIdentities.filter((identity) => !this.runtimeLifetimeSeries.has(`${entry.definition.name}:${identity}`));
+        if (entry.lifetimeSeries.size + newIdentities.length > maximumInstrumentSeries ||
+            this.runtimeLifetimeSeries.size + newRuntimeIdentities.length > maximumRuntimeSeries) {
+            return {
+                metric: undefined,
+                failures: [
+                    {
+                        instrumentName: entry.definition.name,
+                        code: "SERIES_LIMIT_EXCEEDED",
+                        message: `Observable gauge "${entry.definition.name}" exceeds a lifetime series limit.`,
+                    },
+                ],
+            };
+        }
+        for (const identity of newIdentities) {
+            this.commitSeries(entry, identity);
+        }
+        return {
+            metric: {
+                name: entry.definition.name,
+                description: entry.definition.description,
+                unit: entry.definition.unit,
+                gauge: {
+                    dataPoints: observations.map((observation) => ({
+                        attributes: attributesToOtlp(observation.attributes.values),
+                        startTimeUnixNano: this.startTimeUnixNano,
+                        timeUnixNano,
+                        asDouble: observation.value,
+                    })),
+                },
+            },
+            failures: [],
+        };
+    }
+    foldCounterLease(entry, leaseId) {
+        const leaseSeries = entry.seriesByLease.get(leaseId);
+        if (leaseSeries === undefined) {
+            return;
+        }
+        for (const [identity, series] of leaseSeries) {
+            const residual = entry.residualSeries.get(identity);
+            if (residual === undefined) {
+                entry.residualSeries.set(identity, {
+                    attributes: series.attributes,
+                    value: series.value,
+                });
+            }
+            else {
+                residual.value += series.value;
+            }
+        }
+        entry.seriesByLease.delete(leaseId);
+    }
+    foldHistogramLease(entry, leaseId) {
+        const leaseSeries = entry.seriesByLease.get(leaseId);
+        if (leaseSeries === undefined) {
+            return;
+        }
+        for (const [identity, series] of leaseSeries) {
+            const residual = entry.residualSeries.get(identity);
+            if (residual === undefined) {
+                entry.residualSeries.set(identity, {
+                    attributes: series.attributes,
+                    count: series.count,
+                    sum: series.sum,
+                    min: series.min,
+                    max: series.max,
+                    bucketCounts: [...series.bucketCounts],
+                });
+            }
+            else {
+                residual.count += series.count;
+                residual.sum += series.sum;
+                residual.min = Math.min(residual.min, series.min);
+                residual.max = Math.max(residual.max, series.max);
+                for (let index = 0; index < residual.bucketCounts.length; index++) {
+                    residual.bucketCounts[index] =
+                        (residual.bucketCounts[index] ?? 0) + (series.bucketCounts[index] ?? 0);
+                }
+            }
+        }
+        entry.seriesByLease.delete(leaseId);
+    }
+    removeLeaseState(leaseId) {
+        for (const [name, entry] of this.catalog) {
+            entry.leases.delete(leaseId);
+            if (entry.kind === "counter") {
+                this.foldCounterLease(entry, leaseId);
+                if (entry.leases.size === 0 && entry.residualSeries.size === 0) {
+                    this.catalog.delete(name);
+                }
+            }
+            else if (entry.kind === "histogram") {
+                this.foldHistogramLease(entry, leaseId);
+                if (entry.leases.size === 0 && entry.residualSeries.size === 0) {
+                    this.catalog.delete(name);
+                }
+            }
+            else {
+                for (const [callbackId, registration] of entry.callbacks) {
+                    if (registration.leaseId === leaseId) {
+                        entry.callbacks.delete(callbackId);
+                    }
+                }
+                if (entry.leases.size === 0) {
+                    this.catalog.delete(name);
+                }
+            }
+        }
+    }
+}
+const runtimePool = new Map();
+const fetchTransport = (endpoint) => async (payload, signal) => {
+    const response = await fetch(endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(payload),
+        signal,
+    });
+    if (!response.ok) {
+        throw metricError("EXPORT_FAILED", "export", `OTLP metrics endpoint returned HTTP ${response.status}. Verify the endpoint and retry.`, undefined, true);
+    }
+};
+const acquireRuntime = (options, transport) => {
+    let state = runtimePool.get(options.poolKey);
+    if (state === undefined) {
+        state = new MetricsRuntimeState(options, () => {
+            if (runtimePool.get(options.poolKey) === state) {
+                runtimePool.delete(options.poolKey);
+            }
+        });
+        runtimePool.set(options.poolKey, state);
+    }
+    return state.acquire(transport);
+};
+class ActiveMetrics {
+    lease;
+    timeoutMilliseconds;
+    closed = false;
+    closePromise;
+    constructor(lease, timeoutMilliseconds) {
+        this.lease = lease;
+        this.timeoutMilliseconds = timeoutMilliseconds;
+    }
+    counter(definitionInput) {
+        this.assertOpen("counter");
+        const definition = parseDefinition(definitionInput, "counter");
+        const entry = this.lease.state.registerCounter(this.lease.leaseId, definition);
+        return {
+            add: (value, attributes) => {
+                this.assertOpen("add", definition.name);
+                const parsedAttributes = parseAttributes(attributes, "add", definition.name);
+                this.lease.state.addCounter(this.lease.leaseId, entry, value, parsedAttributes);
+            },
+        };
+    }
+    histogram(definitionInput) {
+        this.assertOpen("histogram");
+        const definition = parseHistogramDefinition(definitionInput);
+        const entry = this.lease.state.registerHistogram(this.lease.leaseId, definition);
+        return {
+            record: (value, attributes) => {
+                this.assertOpen("record", definition.name);
+                const parsedAttributes = parseAttributes(attributes, "record", definition.name);
+                this.lease.state.recordHistogram(this.lease.leaseId, entry, value, parsedAttributes);
+            },
+        };
+    }
+    observableGauge(definitionInput, callback) {
+        this.assertOpen("observableGauge");
+        const definition = parseDefinition(definitionInput, "observableGauge");
+        if (!Predicate.isFunction(callback)) {
+            throw metricError("INVALID_INSTRUMENT", "observableGauge", `Observable gauge "${definition.name}" requires a synchronous callback.`, definition.name, false);
+        }
+        const registered = this.lease.state.registerGauge(this.lease.leaseId, definition, callback);
+        let unregistered = false;
+        const unregister = () => {
+            if (unregistered) {
+                return;
+            }
+            unregistered = true;
+            this.lease.state.unregisterGauge(definition.name, registered.callbackId);
+        };
+        return { unregister, [Symbol.dispose]: unregister };
+    }
+    flush() {
+        this.assertOpen("flush");
+        return this.lease.state.flush(this.timeoutMilliseconds);
+    }
+    close() {
+        if (this.closePromise !== undefined) {
+            return this.closePromise;
+        }
+        this.closed = true;
+        this.closePromise = this.lease.state.closeLease(this.lease.leaseId, this.timeoutMilliseconds);
+        return this.closePromise;
+    }
+    assertOpen(operation, instrumentName) {
+        if (this.closed) {
+            throw metricError("CLOSED", operation, "Metrics lifecycle is closed. Create a new lifecycle before recording or flushing metrics.", instrumentName, false);
+        }
+    }
+}
+class DisabledMetrics {
+    closed = false;
+    closePromise;
+    counter(definitionInput) {
+        this.assertOpen("counter");
+        const definition = parseDefinition(definitionInput, "counter");
+        return {
+            add: (value, attributes) => {
+                this.assertOpen("add", definition.name);
+                if (!Number.isFinite(value) || value < 0) {
+                    throw metricError("INVALID_MEASUREMENT", "add", `Counter "${definition.name}" accepts only finite values greater than or equal to zero.`, definition.name, false);
+                }
+                parseAttributes(attributes, "add", definition.name);
+            },
+        };
+    }
+    histogram(definitionInput) {
+        this.assertOpen("histogram");
+        const definition = parseHistogramDefinition(definitionInput);
+        return {
+            record: (value, attributes) => {
+                this.assertOpen("record", definition.name);
+                if (!Number.isFinite(value)) {
+                    throw metricError("INVALID_MEASUREMENT", "record", `Histogram "${definition.name}" accepts only finite values.`, definition.name, false);
+                }
+                parseAttributes(attributes, "record", definition.name);
+            },
+        };
+    }
+    observableGauge(definitionInput, callback) {
+        this.assertOpen("observableGauge");
+        const definition = parseDefinition(definitionInput, "observableGauge");
+        if (!Predicate.isFunction(callback)) {
+            throw metricError("INVALID_INSTRUMENT", "observableGauge", `Observable gauge "${definition.name}" requires a synchronous callback.`, definition.name, false);
+        }
+        const unregister = () => undefined;
+        return { unregister, [Symbol.dispose]: unregister };
+    }
+    flush() {
+        this.assertOpen("flush");
+        return Promise.resolve({ gaugeFailures: [] });
+    }
+    close() {
+        if (this.closePromise !== undefined) {
+            return this.closePromise;
+        }
+        this.closed = true;
+        this.closePromise = Promise.resolve({ gaugeFailures: [] });
+        return this.closePromise;
+    }
+    assertOpen(operation, instrumentName) {
+        if (this.closed) {
+            throw metricError("CLOSED", operation, "Metrics lifecycle is closed. Create a new lifecycle before recording or flushing metrics.", instrumentName, false);
+        }
+    }
+}
+export const createStandaloneMetrics = async (optionsInput) => {
+    const options = parseOptions(optionsInput);
+    if (!options.enabled) {
+        return new DisabledMetrics();
+    }
+    const lease = acquireRuntime(options, {
+        kind: "fetch",
+        send: fetchTransport(options.metricsEndpoint),
+    });
+    return new ActiveMetrics(lease, options.flushTimeoutMilliseconds);
+};
+const makeEffectTransport = (endpoint, client) => {
+    const request = HttpClientRequest.post(endpoint, {
+        headers: { "content-type": "application/json" },
+    });
+    return async (payload, signal) => {
+        const program = client
+            .execute(HttpClientRequest.setBody(request, HttpBody.jsonUnsafe(payload)))
+            .pipe(Effect.flatMap((response) => response.status >= 200 && response.status < 300
+            ? Effect.void
+            : Effect.fail(metricError("EXPORT_FAILED", "export", `OTLP metrics endpoint returned HTTP ${response.status}. Verify the endpoint and retry.`, undefined, true))), Effect.scoped);
+        await Effect.runPromise(program, { signal });
+    };
+};
+const makeMetricsRuntime = Effect.fn("makeMetricsRuntime")(function* (config, options) {
+    const client = yield* HttpClient.HttpClient;
+    const flusher = yield* OtlpExporter.Flusher;
+    const parsed = parseOptions({
+        serviceName: config.serviceName,
+        serviceVersion: config.serviceVersion,
+        environment: config.environment,
+        otlpEndpoint: config.otlpEndpoint.toString(),
+        flushTimeoutMilliseconds: options.shutdownTimeoutMilliseconds,
+    });
+    const lease = acquireRuntime(parsed, {
+        kind: "layer",
+        send: makeEffectTransport(parsed.metricsEndpoint, client),
+    });
+    yield* flusher.register(Effect.tryPromise(() => lease.state.flush(parsed.flushTimeoutMilliseconds)).pipe(Effect.catch(() => Effect.void), Effect.asVoid));
+    yield* Effect.addFinalizer(() => Effect.tryPromise(() => lease.state.closeLease(lease.leaseId, parsed.flushTimeoutMilliseconds)).pipe(Effect.catch(() => Effect.void), Effect.asVoid));
+    return lease.state.registry;
+});
+export const layerMetricsRuntime = (config, options) => Layer.effect(Metric.MetricRegistry, makeMetricsRuntime(config, options)).pipe(Layer.provideMerge(OtlpExporter.layerFlusher));