@bleedingdev/modern-js-server-runtime-extensions 0.0.0-trusted-publisher-bootstrap

package/dist/cjs/telemetryCore.js

@@ -0,0 +1,819 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+class TelemetryStartupHealthError extends Error {
+    constructor(failedExporters){
+        super(`Telemetry startup health check failed for exporters: ${failedExporters.map((item)=>item.name).join(', ')}`), this.code = 'TELEMETRY_EXPORTER_STARTUP_HEALTH_FAILED';
+        this.name = 'TelemetryStartupHealthError';
+        this.failedExporters = failedExporters;
+    }
+}
+const DEFAULT_OTLP_ENDPOINT = 'http://127.0.0.1:4318/v1/logs';
+const DEFAULT_VM_ENDPOINT = 'http://127.0.0.1:8428/api/v1/import/prometheus';
+const DEFAULT_TIMEOUT_MS = 5000;
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function redactObject(value, redactionKeys) {
+    if (!isRecord(value)) return;
+    const output = {};
+    for (const [key, nested] of Object.entries(value)){
+        if (redactionKeys.has(key)) {
+            output[key] = '[REDACTED]';
+            continue;
+        }
+        if (Array.isArray(nested)) {
+            output[key] = nested.map((item)=>{
+                if (isRecord(item)) return redactObject(item, redactionKeys);
+                return item;
+            });
+            continue;
+        }
+        if (isRecord(nested)) {
+            output[key] = redactObject(nested, redactionKeys);
+            continue;
+        }
+        output[key] = nested;
+    }
+    return output;
+}
+function normalizeLabels(labels) {
+    if (!labels) return;
+    const normalized = {};
+    for (const [key, value] of Object.entries(labels))if (null != value) normalized[key] = String(value);
+    return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function extractError(args) {
+    for (const arg of args)if (arg instanceof Error) return {
+        name: arg.name,
+        message: arg.message,
+        stack: arg.stack
+    };
+}
+function toTelemetryEnvelope(event, input) {
+    const base = {
+        timestamp: Date.now(),
+        service: input.service,
+        module: input.module,
+        environment: input.environment,
+        ...input.traceId ? {
+            traceId: input.traceId
+        } : {},
+        ...input.spanId ? {
+            spanId: input.spanId
+        } : {},
+        ...input.attributes ? {
+            attributes: input.attributes
+        } : {}
+    };
+    if ('log' === event.type) {
+        const payload = event.payload;
+        const args = payload.args || [];
+        const signalType = 'trace' === payload.level ? 'trace' : 'log';
+        return {
+            ...base,
+            signalType,
+            name: payload.message,
+            level: payload.level,
+            attributes: {
+                ...base.attributes || {},
+                args
+            },
+            error: extractError(args)
+        };
+    }
+    if ('timing' === event.type) return {
+        ...base,
+        signalType: 'metric',
+        name: event.payload.name,
+        value: event.payload.dur,
+        unit: 'ms',
+        tags: normalizeLabels(event.payload.tags),
+        attributes: {
+            ...base.attributes || {},
+            desc: event.payload.desc,
+            args: event.payload.args
+        }
+    };
+    return {
+        ...base,
+        signalType: 'metric',
+        name: event.payload.name,
+        value: 1,
+        unit: 'count',
+        tags: normalizeLabels(event.payload.tags),
+        attributes: {
+            ...base.attributes || {},
+            args: event.payload.args
+        }
+    };
+}
+async function postWithTimeout(options) {
+    const controller = new AbortController();
+    const timer = setTimeout(()=>controller.abort(), options.timeoutMs);
+    if ('function' == typeof timer.unref) timer.unref();
+    try {
+        const response = await fetch(options.endpoint, {
+            method: 'POST',
+            body: options.body,
+            headers: options.headers,
+            signal: controller.signal
+        });
+        if (!response.ok) throw new Error(`Telemetry exporter request failed: ${response.status} ${response.statusText}`);
+    } finally{
+        clearTimeout(timer);
+    }
+}
+function sanitizeMetricName(value) {
+    return value.replace(/[^a-zA-Z0-9_:]/g, '_').replace(/_+/g, '_');
+}
+function escapeLabelValue(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+}
+function toPrometheusLine(envelope, metricPrefix) {
+    const metricName = sanitizeMetricName(`${metricPrefix}_${envelope.signalType}_${envelope.name}`);
+    const labels = {
+        service: envelope.service,
+        module: envelope.module,
+        environment: envelope.environment,
+        ...envelope.level ? {
+            level: envelope.level
+        } : {},
+        ...envelope.traceId ? {
+            trace_id: envelope.traceId
+        } : {},
+        ...envelope.spanId ? {
+            span_id: envelope.spanId
+        } : {},
+        ...envelope.tags || {}
+    };
+    const labelPairs = Object.entries(labels).sort(([a], [b])=>a.localeCompare(b)).map(([key, value])=>`${sanitizeMetricName(key)}="${escapeLabelValue(value)}"`);
+    const labelText = labelPairs.length > 0 ? `{${labelPairs.join(',')}}` : '';
+    const value = 'number' == typeof envelope.value && Number.isFinite(envelope.value) ? envelope.value : 1;
+    const timestampMs = envelope.timestamp;
+    return `${metricName}${labelText} ${value} ${timestampMs}`;
+}
+function createOtlpTelemetryExporter(options = {}) {
+    const endpoint = options.endpoint || DEFAULT_OTLP_ENDPOINT;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const headers = {
+        'content-type': 'application/json',
+        ...options.headers || {}
+    };
+    return {
+        name: 'otlp',
+        async emit (batch) {
+            if (0 === batch.length) return;
+            const body = JSON.stringify({
+                resource: {
+                    service: batch[0]?.service,
+                    module: batch[0]?.module,
+                    environment: batch[0]?.environment
+                },
+                emittedAt: Date.now(),
+                events: batch
+            });
+            await postWithTimeout({
+                endpoint,
+                body,
+                headers,
+                timeoutMs
+            });
+        }
+    };
+}
+function createVictoriaMetricsTelemetryExporter(options = {}) {
+    const endpoint = options.endpoint || DEFAULT_VM_ENDPOINT;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const metricPrefix = sanitizeMetricName(options.metricPrefix || 'modernjs');
+    const headers = {
+        'content-type': 'text/plain; version=0.0.4',
+        ...options.headers || {}
+    };
+    return {
+        name: 'victoria-metrics',
+        async emit (batch) {
+            if (0 === batch.length) return;
+            const lines = batch.map((item)=>toPrometheusLine(item, metricPrefix));
+            await postWithTimeout({
+                endpoint,
+                body: `${lines.join('\n')}\n`,
+                headers,
+                timeoutMs
+            });
+        }
+    };
+}
+class TelemetryRegistry {
+    async register(exporter) {
+        this.exporters.push(exporter);
+        this.exporterHealth.set(exporter.name, {
+            name: exporter.name,
+            healthy: true,
+            failures: 0
+        });
+        if (exporter.init) try {
+            await exporter.init({
+                service: this.service,
+                module: this.module,
+                environment: this.environment
+            });
+            this.markExporterHealthy(exporter.name);
+        } catch (error) {
+            this.markExporterFailure(exporter.name, error);
+            throw error;
+        }
+        else this.markExporterHealthy(exporter.name);
+    }
+    getOrCreateExporterHealth(name) {
+        const existing = this.exporterHealth.get(name);
+        if (existing) return existing;
+        const next = {
+            name,
+            healthy: true,
+            failures: 0
+        };
+        this.exporterHealth.set(name, next);
+        return next;
+    }
+    markExporterHealthy(name) {
+        const status = this.getOrCreateExporterHealth(name);
+        status.healthy = true;
+        status.lastSuccessAt = Date.now();
+        status.lastError = void 0;
+    }
+    markExporterFailure(name, error) {
+        const status = this.getOrCreateExporterHealth(name);
+        status.healthy = false;
+        status.failures += 1;
+        status.lastFailureAt = Date.now();
+        status.lastError = error instanceof Error ? error.message : String(error);
+    }
+    maybeEmitSloAlert(type, value, threshold) {
+        if (!this.onSloAlert || value < threshold) return;
+        const now = Date.now();
+        const lastTimestamp = this.lastSloAlertAt.get(type) ?? 0;
+        if (now - lastTimestamp < this.alertCooldownMs) return;
+        this.lastSloAlertAt.set(type, now);
+        const queueDepth = this.queue.length;
+        try {
+            this.onSloAlert({
+                timestamp: now,
+                service: this.service,
+                module: this.module,
+                environment: this.environment,
+                type,
+                value,
+                threshold,
+                queueDepth,
+                queueCapacity: this.maxQueueSize,
+                queueUtilization: queueDepth / this.maxQueueSize,
+                totalDropped: this.totalDroppedCount
+            });
+        } catch (_error) {}
+    }
+    enqueue(envelope) {
+        if (this.samplingRate < 1 && Math.random() > this.samplingRate) return;
+        const redactedEnvelope = this.redactionKeys.size > 0 ? {
+            ...envelope,
+            attributes: redactObject(envelope.attributes, this.redactionKeys)
+        } : envelope;
+        if (this.queue.length >= this.maxQueueSize) {
+            this.queue.shift();
+            this.droppedCount += 1;
+            this.totalDroppedCount += 1;
+            this.maybeEmitSloAlert('queue.drop', this.totalDroppedCount, this.queueDroppedWarnThreshold);
+        }
+        this.queue.push(redactedEnvelope);
+        this.maybeEmitSloAlert('queue.utilization', this.queue.length / this.maxQueueSize, this.queueUtilizationWarnThreshold);
+        if (this.queue.length >= this.maxBatchSize) this.flush();
+    }
+    enqueueMetric(input) {
+        this.enqueue({
+            timestamp: Date.now(),
+            service: this.service,
+            module: this.module,
+            environment: this.environment,
+            signalType: 'metric',
+            name: input.name,
+            value: input.value,
+            unit: input.unit || 'count',
+            traceId: input.traceId,
+            spanId: input.spanId,
+            parentSpanId: input.parentSpanId,
+            tags: input.tags,
+            attributes: input.attributes
+        });
+    }
+    enqueueLog(input) {
+        this.enqueue({
+            timestamp: Date.now(),
+            service: this.service,
+            module: this.module,
+            environment: this.environment,
+            signalType: 'log',
+            name: input.name,
+            level: input.level,
+            traceId: input.traceId,
+            spanId: input.spanId,
+            parentSpanId: input.parentSpanId,
+            tags: input.tags,
+            attributes: input.attributes,
+            error: input.error
+        });
+    }
+    enqueueTrace(input) {
+        this.enqueue({
+            timestamp: Date.now(),
+            service: this.service,
+            module: this.module,
+            environment: this.environment,
+            signalType: 'trace',
+            name: input.name,
+            traceId: input.traceId,
+            spanId: input.spanId,
+            parentSpanId: input.parentSpanId,
+            tags: input.tags,
+            attributes: input.attributes
+        });
+    }
+    buildDroppedEnvelope(droppedCount) {
+        return {
+            timestamp: Date.now(),
+            service: this.service,
+            module: this.module,
+            environment: this.environment,
+            signalType: 'metric',
+            name: 'telemetry.queue.dropped',
+            value: droppedCount,
+            unit: 'count',
+            tags: {
+                reason: 'queue_backpressure'
+            }
+        };
+    }
+    buildQueueDepthEnvelope(queueDepth) {
+        return {
+            timestamp: Date.now(),
+            service: this.service,
+            module: this.module,
+            environment: this.environment,
+            signalType: 'metric',
+            name: 'telemetry.queue.depth',
+            value: queueDepth,
+            unit: 'count',
+            tags: {
+                capacity: String(this.maxQueueSize)
+            }
+        };
+    }
+    buildQueueUtilizationEnvelope(queueDepth) {
+        return {
+            timestamp: Date.now(),
+            service: this.service,
+            module: this.module,
+            environment: this.environment,
+            signalType: 'metric',
+            name: 'telemetry.queue.utilization',
+            value: queueDepth / this.maxQueueSize,
+            unit: 'ratio',
+            tags: {
+                capacity: String(this.maxQueueSize)
+            }
+        };
+    }
+    async emitBatch(batch) {
+        const results = await Promise.allSettled(this.exporters.map(async (exporter)=>{
+            await exporter.emit(batch);
+            return exporter.name;
+        }));
+        for (const [index, result] of results.entries()){
+            const exporterName = this.exporters[index]?.name || `exporter-${index}`;
+            if ('rejected' === result.status) {
+                this.markExporterFailure(exporterName, result.reason);
+                continue;
+            }
+            this.markExporterHealthy(exporterName);
+        }
+    }
+    buildStartupProbeEnvelope() {
+        return {
+            timestamp: Date.now(),
+            service: this.service,
+            module: this.module,
+            environment: this.environment,
+            signalType: 'log',
+            name: 'telemetry.exporter.startup_probe',
+            level: 'info',
+            tags: {
+                phase: 'startup'
+            },
+            attributes: {
+                source: 'TelemetryRegistry'
+            }
+        };
+    }
+    async startupHealthCheck(options) {
+        if (0 === this.exporters.length) return;
+        const probeBatch = [
+            this.buildStartupProbeEnvelope()
+        ];
+        const failedExporters = [];
+        await Promise.all(this.exporters.map(async (exporter)=>{
+            try {
+                await exporter.emit(probeBatch);
+                this.markExporterHealthy(exporter.name);
+            } catch (error) {
+                this.markExporterFailure(exporter.name, error);
+                const status = this.exporterHealth.get(exporter.name);
+                if (status) failedExporters.push({
+                    ...status
+                });
+            }
+        }));
+        if ((options?.failLoud ?? true) && failedExporters.length > 0) throw new TelemetryStartupHealthError(failedExporters);
+    }
+    getExporterHealth() {
+        return Array.from(this.exporterHealth.values()).map((item)=>({
+                ...item
+            }));
+    }
+    getQueueStats() {
+        return {
+            depth: this.queue.length,
+            capacity: this.maxQueueSize,
+            utilization: this.queue.length / this.maxQueueSize,
+            pendingDropped: this.droppedCount,
+            totalDropped: this.totalDroppedCount
+        };
+    }
+    async flushInternal() {
+        const queueDepthBeforeFlush = this.queue.length;
+        if (queueDepthBeforeFlush > 0) {
+            this.queue.unshift(this.buildQueueUtilizationEnvelope(queueDepthBeforeFlush));
+            this.queue.unshift(this.buildQueueDepthEnvelope(queueDepthBeforeFlush));
+        }
+        if (this.droppedCount > 0) {
+            const droppedCount = this.droppedCount;
+            this.droppedCount = 0;
+            this.queue.unshift(this.buildDroppedEnvelope(droppedCount));
+        }
+        if (0 === this.queue.length) return;
+        if (0 === this.exporters.length) {
+            this.queue.length = 0;
+            return;
+        }
+        while(this.queue.length > 0){
+            const batch = this.queue.splice(0, this.maxBatchSize);
+            await this.emitBatch(batch);
+        }
+        await Promise.allSettled(this.exporters.map(async (exporter)=>{
+            if (exporter.flush) await exporter.flush();
+        }));
+    }
+    flush() {
+        if (this.flushing) return this.flushing;
+        this.flushing = this.flushInternal().finally(()=>{
+            this.flushing = null;
+        });
+        return this.flushing;
+    }
+    async shutdown() {
+        if (this.flushTimer) clearInterval(this.flushTimer);
+        await this.flush();
+        await Promise.allSettled(this.exporters.map(async (exporter)=>{
+            if (exporter.shutdown) await exporter.shutdown();
+        }));
+    }
+    constructor(options){
+        this.exporters = [];
+        this.queue = [];
+        this.droppedCount = 0;
+        this.totalDroppedCount = 0;
+        this.flushing = null;
+        this.exporterHealth = new Map();
+        this.lastSloAlertAt = new Map();
+        this.service = options.service;
+        this.module = options.module;
+        this.environment = options.environment;
+        this.samplingRate = clamp(options.samplingRate ?? 1, 0, 1);
+        this.maxBatchSize = Math.max(1, options.maxBatchSize ?? 50);
+        this.maxQueueSize = Math.max(1, options.maxQueueSize ?? 1000);
+        this.flushIntervalMs = Math.max(50, options.flushIntervalMs ?? 1000);
+        this.redactionKeys = new Set(options.redactionKeys || []);
+        this.queueUtilizationWarnThreshold = clamp(options.slo?.queueUtilizationWarnThreshold ?? 0.8, 0, 1);
+        this.queueDroppedWarnThreshold = Math.max(1, options.slo?.queueDroppedWarnThreshold ?? 1);
+        this.alertCooldownMs = Math.max(0, options.slo?.alertCooldownMs ?? 60000);
+        this.onSloAlert = options.slo?.onAlert;
+        this.flushTimer = setInterval(()=>{
+            this.flush();
+        }, this.flushIntervalMs);
+        if ('function' == typeof this.flushTimer.unref) this.flushTimer.unref();
+    }
+}
+class TelemetryCanaryOrchestrator {
+    setRequiredContractGates(gates) {
+        this.requiredContractGates = Array.from(new Set(gates.map((item)=>item.trim()).filter(Boolean)));
+    }
+    addRequiredContractGate(name) {
+        const normalizedName = name.trim();
+        if (!normalizedName) return;
+        if (!this.requiredContractGates.includes(normalizedName)) this.requiredContractGates.push(normalizedName);
+    }
+    setContractGate(name, passed, reason) {
+        this.contractGates.set(name, {
+            name,
+            passed,
+            reason,
+            updatedAt: Date.now()
+        });
+    }
+    setContractGates(gates) {
+        for (const [name, value] of Object.entries(gates)){
+            if ('boolean' == typeof value) {
+                this.setContractGate(name, value);
+                continue;
+            }
+            this.setContractGate(name, value.passed, value.reason);
+        }
+    }
+    resetToCanary() {
+        this.state = 'canary';
+        this.consecutiveHealthy = 0;
+        this.consecutiveFailures = 0;
+    }
+    collectFailures() {
+        const failures = [];
+        const queueStats = this.registry.getQueueStats();
+        const unhealthyExporterCount = this.registry.getExporterHealth().filter((item)=>!item.healthy).length;
+        if (queueStats.utilization > this.maxQueueUtilization) failures.push({
+            reason: 'queue_utilization',
+            threshold: this.maxQueueUtilization,
+            value: queueStats.utilization
+        });
+        if (queueStats.totalDropped > this.maxTotalDropped) failures.push({
+            reason: 'queue_dropped',
+            threshold: this.maxTotalDropped,
+            value: queueStats.totalDropped
+        });
+        if (unhealthyExporterCount > this.maxUnhealthyExporters) failures.push({
+            reason: 'unhealthy_exporter',
+            threshold: this.maxUnhealthyExporters,
+            value: unhealthyExporterCount
+        });
+        for (const gateName of this.requiredContractGates){
+            const gate = this.contractGates.get(gateName);
+            if (!gate) {
+                failures.push({
+                    reason: 'contract_gate_missing',
+                    gate: gateName,
+                    message: `Contract gate "${gateName}" is missing`
+                });
+                continue;
+            }
+            if (!gate.passed) failures.push({
+                reason: 'contract_gate_failed',
+                gate: gateName,
+                message: gate.reason || `Contract gate "${gateName}" is not passing`
+            });
+        }
+        return {
+            failures,
+            queueStats,
+            unhealthyExporterCount
+        };
+    }
+    evaluate() {
+        const now = Date.now();
+        const { failures, queueStats, unhealthyExporterCount } = this.collectFailures();
+        let action = 'hold';
+        if (failures.length > 0) {
+            this.consecutiveHealthy = 0;
+            this.consecutiveFailures += 1;
+            if ('rolled_back' !== this.state && this.consecutiveFailures >= this.rollbackConsecutiveFailures) {
+                this.state = 'rolled_back';
+                action = 'rollback';
+            }
+        } else {
+            this.consecutiveFailures = 0;
+            this.consecutiveHealthy += 1;
+            if ('canary' === this.state && this.consecutiveHealthy >= this.minConsecutiveHealthyEvaluations) {
+                this.state = 'promoted';
+                action = 'promote';
+            }
+        }
+        const decision = {
+            timestamp: now,
+            action,
+            state: this.state,
+            consecutiveHealthy: this.consecutiveHealthy,
+            consecutiveFailures: this.consecutiveFailures,
+            failures,
+            queueStats,
+            unhealthyExporterCount,
+            contractGates: Array.from(this.contractGates.values()).map((item)=>({
+                    ...item
+                }))
+        };
+        try {
+            this.onEvaluate?.(decision);
+        } catch (_error) {}
+        if ('promote' === action) try {
+            this.onPromote?.(decision);
+        } catch (_error) {}
+        if ('rollback' === action) try {
+            this.onRollback?.(decision);
+        } catch (_error) {}
+        return decision;
+    }
+    getStatusSnapshot() {
+        const now = Date.now();
+        const { failures, queueStats, unhealthyExporterCount } = this.collectFailures();
+        return {
+            timestamp: now,
+            state: this.state,
+            consecutiveHealthy: this.consecutiveHealthy,
+            consecutiveFailures: this.consecutiveFailures,
+            queueStats,
+            unhealthyExporterCount,
+            requiredContractGates: [
+                ...this.requiredContractGates
+            ],
+            contractGates: Array.from(this.contractGates.values()).map((item)=>({
+                    ...item
+                })),
+            failurePreview: failures
+        };
+    }
+    start() {
+        if (this.evaluationTimer) return;
+        this.evaluationTimer = setInterval(()=>{
+            this.evaluate();
+        }, this.evaluationIntervalMs);
+        if ('function' == typeof this.evaluationTimer.unref) this.evaluationTimer.unref();
+    }
+    stop() {
+        if (this.evaluationTimer) {
+            clearInterval(this.evaluationTimer);
+            this.evaluationTimer = void 0;
+        }
+    }
+    constructor(options){
+        this.requiredContractGates = [];
+        this.contractGates = new Map();
+        this.state = 'canary';
+        this.consecutiveHealthy = 0;
+        this.consecutiveFailures = 0;
+        this.registry = options.registry;
+        this.evaluationIntervalMs = Math.max(250, options.evaluationIntervalMs ?? 15000);
+        this.minConsecutiveHealthyEvaluations = Math.max(1, options.minConsecutiveHealthyEvaluations ?? 3);
+        this.rollbackConsecutiveFailures = Math.max(1, options.rollbackConsecutiveFailures ?? 2);
+        this.maxQueueUtilization = clamp(options.maxQueueUtilization ?? 0.8, 0, 1);
+        this.maxTotalDropped = Math.max(0, options.maxTotalDropped ?? 0);
+        this.maxUnhealthyExporters = Math.max(0, options.maxUnhealthyExporters ?? 0);
+        this.setRequiredContractGates(options.requiredContractGates || []);
+        this.onEvaluate = options.onEvaluate;
+        this.onPromote = options.onPromote;
+        this.onRollback = options.onRollback;
+    }
+}
+function normalizeMetricsInput(prefixOrTags, tags) {
+    if ('string' == typeof prefixOrTags) return {
+        prefix: prefixOrTags,
+        tags: tags || {}
+    };
+    if (isRecord(prefixOrTags)) return {
+        prefix: void 0,
+        tags: prefixOrTags
+    };
+    return {
+        prefix: void 0,
+        tags: tags || {}
+    };
+}
+function normalizeMetricName(name, prefix) {
+    return prefix && prefix.length > 0 ? `${prefix}.${name}` : name;
+}
+function toTelemetryMetricTags(tags) {
+    const output = {};
+    for (const [key, value] of Object.entries(tags))if (null != value) output[key] = String(value);
+    return output;
+}
+function getTraceContext(tags) {
+    const traceId = 'string' == typeof tags.trace_id ? tags.trace_id : 'string' == typeof tags.traceId ? tags.traceId : void 0;
+    const spanId = 'string' == typeof tags.span_id ? tags.span_id : 'string' == typeof tags.spanId ? tags.spanId : void 0;
+    const parentSpanId = 'string' == typeof tags.parent_span_id ? tags.parent_span_id : 'string' == typeof tags.parentSpanId ? tags.parentSpanId : void 0;
+    return {
+        traceId,
+        spanId,
+        parentSpanId
+    };
+}
+const createTelemetryAwareMetrics = (baseMetrics, registry)=>{
+    const emitCounter = (name, value, prefixOrTags, tags)=>{
+        const normalized = normalizeMetricsInput(prefixOrTags, tags);
+        baseMetrics.emitCounter(name, value, normalized.prefix, normalized.tags);
+        try {
+            const metricName = normalizeMetricName(name, normalized.prefix);
+            const traceContext = getTraceContext(normalized.tags);
+            registry.enqueueMetric({
+                name: metricName,
+                value,
+                unit: 'count',
+                traceId: traceContext.traceId,
+                spanId: traceContext.spanId,
+                parentSpanId: traceContext.parentSpanId,
+                tags: toTelemetryMetricTags(normalized.tags),
+                attributes: normalized.tags
+            });
+        } catch (_error) {}
+    };
+    const emitTimer = (name, value, prefixOrTags, tags)=>{
+        const normalized = normalizeMetricsInput(prefixOrTags, tags);
+        baseMetrics.emitTimer(name, value, normalized.prefix, normalized.tags);
+        try {
+            const metricName = normalizeMetricName(name, normalized.prefix);
+            const traceContext = getTraceContext(normalized.tags);
+            registry.enqueueMetric({
+                name: metricName,
+                value,
+                unit: 'ms',
+                traceId: traceContext.traceId,
+                spanId: traceContext.spanId,
+                parentSpanId: traceContext.parentSpanId,
+                tags: toTelemetryMetricTags(normalized.tags),
+                attributes: normalized.tags
+            });
+        } catch (_error) {}
+    };
+    return {
+        ...baseMetrics,
+        emitCounter,
+        emitTimer
+    };
+};
+function maybeWarnLegacyOtlpEndpoint(endpoint) {
+    if (!endpoint || !endpoint.includes('/v1/metrics')) return;
+    console.warn(`[telemetry] OTLP endpoint "${endpoint}" looks like a metrics path. UltraModern telemetry exporter expects log-style envelopes (default: ${DEFAULT_OTLP_ENDPOINT}).`);
+}
+__webpack_require__.d(__webpack_exports__, {
+    TelemetryCanaryOrchestrator: ()=>TelemetryCanaryOrchestrator,
+    TelemetryRegistry: ()=>TelemetryRegistry,
+    TelemetryStartupHealthError: ()=>TelemetryStartupHealthError,
+    createOtlpTelemetryExporter: ()=>createOtlpTelemetryExporter,
+    createVictoriaMetricsTelemetryExporter: ()=>createVictoriaMetricsTelemetryExporter,
+    maybeWarnLegacyOtlpEndpoint: ()=>maybeWarnLegacyOtlpEndpoint,
+    toTelemetryEnvelope: ()=>toTelemetryEnvelope
+}, {
+    createTelemetryAwareMetrics: createTelemetryAwareMetrics
+});
+exports.TelemetryCanaryOrchestrator = __webpack_exports__.TelemetryCanaryOrchestrator;
+exports.TelemetryRegistry = __webpack_exports__.TelemetryRegistry;
+exports.TelemetryStartupHealthError = __webpack_exports__.TelemetryStartupHealthError;
+exports.createOtlpTelemetryExporter = __webpack_exports__.createOtlpTelemetryExporter;
+exports.createTelemetryAwareMetrics = __webpack_exports__.createTelemetryAwareMetrics;
+exports.createVictoriaMetricsTelemetryExporter = __webpack_exports__.createVictoriaMetricsTelemetryExporter;
+exports.maybeWarnLegacyOtlpEndpoint = __webpack_exports__.maybeWarnLegacyOtlpEndpoint;
+exports.toTelemetryEnvelope = __webpack_exports__.toTelemetryEnvelope;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "TelemetryCanaryOrchestrator",
+    "TelemetryRegistry",
+    "TelemetryStartupHealthError",
+    "createOtlpTelemetryExporter",
+    "createTelemetryAwareMetrics",
+    "createVictoriaMetricsTelemetryExporter",
+    "maybeWarnLegacyOtlpEndpoint",
+    "toTelemetryEnvelope"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});