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

package/dist/cjs/telemetry.js

@@ -0,0 +1,373 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT: ()=>external_runtimeFallbackSignal_js_namespaceObject.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT,
+    DEFAULT_RUNTIME_STATUS_ENDPOINT: ()=>external_runtimeFallbackSignal_js_namespaceObject.DEFAULT_RUNTIME_STATUS_ENDPOINT,
+    TelemetryCanaryOrchestrator: ()=>external_telemetryCore_js_namespaceObject.TelemetryCanaryOrchestrator,
+    TelemetryRegistry: ()=>external_telemetryCore_js_namespaceObject.TelemetryRegistry,
+    TelemetryStartupHealthError: ()=>external_telemetryCore_js_namespaceObject.TelemetryStartupHealthError,
+    createOtlpTelemetryExporter: ()=>external_telemetryCore_js_namespaceObject.createOtlpTelemetryExporter,
+    createRuntimeFallbackSignalRuntimeState: ()=>external_runtimeFallbackSignal_js_namespaceObject.createRuntimeFallbackSignalRuntimeState,
+    createRuntimeSignalError: ()=>external_runtimeFallbackSignal_js_namespaceObject.createRuntimeSignalError,
+    createTelemetryAwareMetrics: ()=>external_telemetryCore_js_namespaceObject.createTelemetryAwareMetrics,
+    createVictoriaMetricsTelemetryExporter: ()=>external_telemetryCore_js_namespaceObject.createVictoriaMetricsTelemetryExporter,
+    enforceRuntimeFallbackSignalAuthToken: ()=>external_runtimeFallbackSignal_js_namespaceObject.enforceRuntimeFallbackSignalAuthToken,
+    enforceRuntimeFallbackSignalTrustPolicy: ()=>external_runtimeFallbackSignal_js_namespaceObject.enforceRuntimeFallbackSignalTrustPolicy,
+    getRuntimeSignalErrorStatusCode: ()=>external_runtimeFallbackSignal_js_namespaceObject.getRuntimeSignalErrorStatusCode,
+    hasEnabledTelemetryExporters: ()=>hasEnabledTelemetryExporters,
+    injectTelemetryPlugin: ()=>injectTelemetryPlugin,
+    normalizeRequiredRuntimeFallbackSignalAuthConfig: ()=>external_runtimeFallbackSignal_js_namespaceObject.normalizeRequiredRuntimeFallbackSignalAuthConfig,
+    normalizeRuntimeFallbackSignalAuthConfig: ()=>external_runtimeFallbackSignal_js_namespaceObject.normalizeRuntimeFallbackSignalAuthConfig,
+    normalizeRuntimeFallbackTrustPolicy: ()=>external_runtimeFallbackSignal_js_namespaceObject.normalizeRuntimeFallbackTrustPolicy,
+    parseRuntimeFallbackSignalPayloadFromRawBody: ()=>external_runtimeFallbackSignal_js_namespaceObject.parseRuntimeFallbackSignalPayloadFromRawBody,
+    resolveRuntimeFallbackSignalEndpoint: ()=>external_runtimeFallbackSignal_js_namespaceObject.resolveRuntimeFallbackSignalEndpoint,
+    resolveTelemetrySloOptions: ()=>resolveTelemetrySloOptions
+});
+const server_namespaceObject = require("@modern-js/create-request/server");
+const utils_namespaceObject = require("@modern-js/utils");
+const external_contractGateAutopilot_js_namespaceObject = require("./contractGateAutopilot.js");
+const external_contractGateSnapshotStore_js_namespaceObject = require("./contractGateSnapshotStore.js");
+const external_env_js_namespaceObject = require("./env.js");
+const external_runtimeFallbackSignal_js_namespaceObject = require("./runtimeFallbackSignal.js");
+const external_telemetryCore_js_namespaceObject = require("./telemetryCore.js");
+function emitCanaryDecisionMetric(registry, decision, action) {
+    try {
+        registry.enqueueMetric({
+            name: `telemetry.canary.${action}`,
+            value: 1,
+            unit: 'count',
+            tags: {
+                action,
+                state: decision.state,
+                failures: String(decision.failures.length)
+            }
+        });
+    } catch (_error) {}
+}
+const hasEnabledTelemetryExporters = (config)=>Boolean(config?.exporters?.otlp?.enabled || config?.exporters?.victoriaMetrics?.enabled);
+const resolveTelemetrySloOptions = (sloConfig, warnSink = (message)=>utils_namespaceObject.logger.warn(message))=>({
+        queueUtilizationWarnThreshold: sloConfig?.queueUtilizationWarnThreshold,
+        queueDroppedWarnThreshold: sloConfig?.queueDroppedWarnThreshold,
+        alertCooldownMs: sloConfig?.alertCooldownMs,
+        onAlert: (alert)=>{
+            warnSink(`[telemetry.slo] ${alert.type} threshold=${alert.threshold} value=${alert.value} depth=${alert.queueDepth}/${alert.queueCapacity} dropped=${alert.totalDropped}`);
+        }
+    });
+const getRequestRemoteAddress = (c)=>{
+    const env = c.env;
+    const remoteAddress = env?.node?.req?.socket?.remoteAddress;
+    return 'string' == typeof remoteAddress && remoteAddress.trim().length > 0 ? remoteAddress.trim() : void 0;
+};
+const activeTelemetryLaneClosers = new Set();
+let telemetryBeforeExitHookInstalled = false;
+const ensureTelemetryBeforeExitHook = ()=>{
+    if (telemetryBeforeExitHookInstalled) return;
+    telemetryBeforeExitHookInstalled = true;
+    process.on('beforeExit', ()=>{
+        for (const close of [
+            ...activeTelemetryLaneClosers
+        ])close();
+    });
+};
+const injectTelemetryPlugin = ()=>({
+        name: '@modern-js/inject-telemetry',
+        setup (api) {
+            const serverConfig = api.getServerConfig();
+            const telemetryConfig = serverConfig?.server?.telemetry;
+            if (!telemetryConfig) return;
+            if (true !== telemetryConfig.enabled && !hasEnabledTelemetryExporters(telemetryConfig)) return;
+            const { middlewares, metaName, appDirectory } = api.getServerContext();
+            const serviceName = telemetryConfig.service || metaName || 'modern-js';
+            const moduleName = telemetryConfig.module || 'server';
+            const environmentName = telemetryConfig.environment || (0, external_env_js_namespaceObject.parseServerRuntimeExtensionsEnv)().environmentName;
+            const registry = new external_telemetryCore_js_namespaceObject.TelemetryRegistry({
+                service: serviceName,
+                module: moduleName,
+                environment: environmentName,
+                samplingRate: telemetryConfig.samplingRate,
+                flushIntervalMs: telemetryConfig.flushIntervalMs,
+                maxBatchSize: telemetryConfig.maxBatchSize,
+                maxQueueSize: telemetryConfig.maxQueueSize,
+                redactionKeys: telemetryConfig.redactionKeys,
+                slo: resolveTelemetrySloOptions(telemetryConfig.slo)
+            });
+            let canaryOrchestrator;
+            let contractGateAutopilot;
+            let runtimeFallbackSignalConfig;
+            let runtimeStatusAuthConfig;
+            let gateSnapshotStorePromise;
+            const canaryConfig = telemetryConfig.canary;
+            if (canaryConfig?.enabled) {
+                const contractGates = canaryConfig.contractGates;
+                canaryOrchestrator = new external_telemetryCore_js_namespaceObject.TelemetryCanaryOrchestrator({
+                    registry,
+                    evaluationIntervalMs: canaryConfig.evaluationIntervalMs,
+                    minConsecutiveHealthyEvaluations: canaryConfig.minConsecutiveHealthyEvaluations,
+                    rollbackConsecutiveFailures: canaryConfig.rollbackConsecutiveFailures,
+                    maxQueueUtilization: canaryConfig.maxQueueUtilization,
+                    maxTotalDropped: canaryConfig.maxTotalDropped,
+                    maxUnhealthyExporters: canaryConfig.maxUnhealthyExporters,
+                    requiredContractGates: Object.keys(contractGates || {}),
+                    onPromote: (decision)=>{
+                        emitCanaryDecisionMetric(registry, decision, 'promote');
+                    },
+                    onRollback: (decision)=>{
+                        emitCanaryDecisionMetric(registry, decision, 'rollback');
+                    }
+                });
+                if (contractGates) canaryOrchestrator.setContractGates(contractGates);
+                const autopilotEnabled = canaryConfig.autopilot?.enabled ?? true;
+                if (autopilotEnabled) {
+                    const gateSnapshotPath = (0, external_contractGateSnapshotStore_js_namespaceObject.resolveContractGateSnapshotPath)(appDirectory, canaryConfig.autopilot?.gateSnapshotPath);
+                    gateSnapshotStorePromise = (0, external_contractGateSnapshotStore_js_namespaceObject.resolveContractGateSnapshotStore)({
+                        appDirectory,
+                        gateSnapshotPath: gateSnapshotPath || external_contractGateSnapshotStore_js_namespaceObject.DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH,
+                        stateStore: canaryConfig.autopilot?.stateStore
+                    });
+                    const runtimeSignalConfig = canaryConfig.autopilot?.runtimeFallbackSignal;
+                    const runtimeSignalEnabled = runtimeSignalConfig?.enabled === true;
+                    if (runtimeSignalEnabled && gateSnapshotStorePromise) runtimeFallbackSignalConfig = {
+                        endpoint: (0, external_runtimeFallbackSignal_js_namespaceObject.resolveRuntimeFallbackSignalEndpoint)(runtimeSignalConfig?.endpoint),
+                        gateName: runtimeSignalConfig?.gateName?.trim() || external_runtimeFallbackSignal_js_namespaceObject.DEFAULT_RUNTIME_FALLBACK_GATE_NAME,
+                        gateSnapshotStore: gateSnapshotStorePromise,
+                        failureHoldMs: Math.max(1000, runtimeSignalConfig?.failureHoldMs ?? external_runtimeFallbackSignal_js_namespaceObject.DEFAULT_RUNTIME_FALLBACK_FAILURE_HOLD_MS),
+                        maxBodyBytes: Math.max(512, runtimeSignalConfig?.maxBodyBytes ?? external_runtimeFallbackSignal_js_namespaceObject.DEFAULT_RUNTIME_FALLBACK_MAX_BODY_BYTES),
+                        auth: (0, external_runtimeFallbackSignal_js_namespaceObject.normalizeRequiredRuntimeFallbackSignalAuthConfig)(runtimeSignalConfig?.auth),
+                        trustPolicy: (0, external_runtimeFallbackSignal_js_namespaceObject.normalizeRuntimeFallbackTrustPolicy)(runtimeSignalConfig?.trustPolicy),
+                        runtimeState: (0, external_runtimeFallbackSignal_js_namespaceObject.createRuntimeFallbackSignalRuntimeState)()
+                    };
+                }
+                runtimeStatusAuthConfig = runtimeFallbackSignalConfig?.auth ?? (0, external_runtimeFallbackSignal_js_namespaceObject.normalizeRuntimeFallbackSignalAuthConfig)(canaryConfig.autopilot?.runtimeFallbackSignal?.auth);
+            }
+            if (runtimeFallbackSignalConfig) {
+                const signalConfig = runtimeFallbackSignalConfig;
+                middlewares.push({
+                    name: 'telemetry-runtime-fallback-signal',
+                    path: signalConfig.endpoint,
+                    method: 'post',
+                    order: 'pre',
+                    handler: async (c)=>{
+                        try {
+                            (0, external_runtimeFallbackSignal_js_namespaceObject.enforceRuntimeFallbackSignalAuth)(c, signalConfig);
+                            const { payload } = await (0, external_runtimeFallbackSignal_js_namespaceObject.parseRuntimeFallbackSignalPayload)(c, signalConfig.maxBodyBytes);
+                            const trustResult = (0, external_runtimeFallbackSignal_js_namespaceObject.enforceRuntimeFallbackSignalTrustPolicy)(payload, signalConfig, {
+                                remoteAddress: getRequestRemoteAddress(c)
+                            });
+                            if (trustResult.deduped) return c.json({
+                                ok: true,
+                                deduped: true
+                            }, 202);
+                            await (0, external_runtimeFallbackSignal_js_namespaceObject.persistRuntimeFallbackContractGate)(payload, signalConfig);
+                            return c.json({
+                                ok: true
+                            }, 202);
+                        } catch (error) {
+                            const signalError = error;
+                            const status = (0, external_runtimeFallbackSignal_js_namespaceObject.getRuntimeSignalErrorStatusCode)(signalError);
+                            return c.json({
+                                ok: false,
+                                error: signalError instanceof Error ? signalError.message : String(signalError)
+                            }, status);
+                        }
+                    }
+                });
+            }
+            middlewares.push({
+                name: 'telemetry-runtime-status',
+                path: external_runtimeFallbackSignal_js_namespaceObject.DEFAULT_RUNTIME_STATUS_ENDPOINT,
+                method: 'get',
+                order: 'pre',
+                handler: async (c)=>{
+                    try {
+                        if (!runtimeStatusAuthConfig?.enabled) return c.json({
+                            ok: true,
+                            timestamp: Date.now()
+                        });
+                        (0, external_runtimeFallbackSignal_js_namespaceObject.enforceRuntimeFallbackSignalAuthToken)(c.req.header(runtimeStatusAuthConfig.headerName), runtimeStatusAuthConfig);
+                        return c.json({
+                            ok: true,
+                            timestamp: Date.now(),
+                            telemetry: {
+                                queueStats: registry.getQueueStats(),
+                                exporterHealth: registry.getExporterHealth()
+                            },
+                            canary: canaryOrchestrator ? {
+                                enabled: true,
+                                ...canaryOrchestrator.getStatusSnapshot()
+                            } : {
+                                enabled: false
+                            },
+                            runtimeFallbackSignal: runtimeFallbackSignalConfig ? {
+                                enabled: true,
+                                endpoint: runtimeFallbackSignalConfig.endpoint,
+                                gateName: runtimeFallbackSignalConfig.gateName,
+                                failureHoldMs: runtimeFallbackSignalConfig.failureHoldMs,
+                                maxBodyBytes: runtimeFallbackSignalConfig.maxBodyBytes,
+                                auth: {
+                                    enabled: runtimeFallbackSignalConfig.auth.enabled,
+                                    headerName: runtimeFallbackSignalConfig.auth.headerName
+                                },
+                                trustPolicy: {
+                                    allowedApps: runtimeFallbackSignalConfig.trustPolicy.allowedApps,
+                                    allowedEntryOrigins: runtimeFallbackSignalConfig.trustPolicy.allowedEntryOrigins,
+                                    enforceRuntimeDigest: runtimeFallbackSignalConfig.trustPolicy.enforceRuntimeDigest,
+                                    expectedRuntimeDigestsCount: Object.keys(runtimeFallbackSignalConfig.trustPolicy.expectedRuntimeDigests).length,
+                                    maxSignalsPerWindow: runtimeFallbackSignalConfig.trustPolicy.maxSignalsPerWindow,
+                                    windowMs: runtimeFallbackSignalConfig.trustPolicy.windowMs,
+                                    dedupeWindowMs: runtimeFallbackSignalConfig.trustPolicy.dedupeWindowMs
+                                }
+                            } : {
+                                enabled: false
+                            }
+                        });
+                    } catch (error) {
+                        const signalError = error;
+                        return c.json({
+                            ok: false,
+                            error: signalError instanceof Error ? signalError.message : String(signalError)
+                        }, (0, external_runtimeFallbackSignal_js_namespaceObject.getRuntimeSignalErrorStatusCode)(signalError));
+                    }
+                }
+            });
+            middlewares.push({
+                name: 'inject-telemetry',
+                handler: async (c, next)=>{
+                    const monitors = c.get('monitors');
+                    if (monitors) {
+                        const traceContext = (0, server_namespaceObject.parseTraceparent)(c.req.header('traceparent'));
+                        const monitor = (event)=>{
+                            registry.enqueue((0, external_telemetryCore_js_namespaceObject.toTelemetryEnvelope)(event, {
+                                service: serviceName,
+                                module: moduleName,
+                                environment: environmentName,
+                                traceId: traceContext?.traceId,
+                                spanId: traceContext?.spanId,
+                                attributes: {
+                                    requestMethod: c.req.method,
+                                    requestPath: c.req.path
+                                }
+                            }));
+                        };
+                        monitors.push(monitor);
+                    }
+                    await next();
+                }
+            });
+            let telemetryLaneClosed = false;
+            const closeTelemetryLane = async ()=>{
+                if (telemetryLaneClosed) return;
+                telemetryLaneClosed = true;
+                activeTelemetryLaneClosers.delete(closeTelemetryLane);
+                contractGateAutopilot?.stop();
+                canaryOrchestrator?.stop();
+                await registry.shutdown();
+            };
+            let prepared = false;
+            api.onPrepare(async ()=>{
+                if (prepared) return;
+                prepared = true;
+                const { nodeServer } = api.getServerContext();
+                if (nodeServer && 'function' == typeof nodeServer.once) nodeServer.once('close', ()=>{
+                    closeTelemetryLane();
+                });
+                activeTelemetryLaneClosers.add(closeTelemetryLane);
+                ensureTelemetryBeforeExitHook();
+                if (telemetryConfig.exporters?.otlp?.enabled) {
+                    (0, external_telemetryCore_js_namespaceObject.maybeWarnLegacyOtlpEndpoint)(telemetryConfig.exporters.otlp.endpoint);
+                    await registry.register((0, external_telemetryCore_js_namespaceObject.createOtlpTelemetryExporter)(telemetryConfig.exporters.otlp));
+                }
+                if (telemetryConfig.exporters?.victoriaMetrics?.enabled) await registry.register((0, external_telemetryCore_js_namespaceObject.createVictoriaMetricsTelemetryExporter)(telemetryConfig.exporters.victoriaMetrics));
+                await registry.startupHealthCheck({
+                    failLoud: telemetryConfig.failLoudStartup ?? true
+                });
+                if (!canaryOrchestrator) return;
+                canaryOrchestrator.start();
+                if (gateSnapshotStorePromise) {
+                    const gateSnapshotStore = await gateSnapshotStorePromise;
+                    contractGateAutopilot = new external_contractGateAutopilot_js_namespaceObject.ContractGateAutopilot({
+                        orchestrator: canaryOrchestrator,
+                        gateSnapshotPath: (0, external_contractGateSnapshotStore_js_namespaceObject.resolveContractGateSnapshotPath)(appDirectory, canaryConfig?.autopilot?.gateSnapshotPath),
+                        gateSnapshotStore,
+                        pollIntervalMs: canaryConfig?.autopilot?.pollIntervalMs,
+                        gateStaleAfterMs: canaryConfig?.autopilot?.gateStaleAfterMs
+                    });
+                }
+                if (contractGateAutopilot) await contractGateAutopilot.start();
+                canaryOrchestrator.evaluate();
+            });
+        }
+    });
+exports.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT = __webpack_exports__.DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT;
+exports.DEFAULT_RUNTIME_STATUS_ENDPOINT = __webpack_exports__.DEFAULT_RUNTIME_STATUS_ENDPOINT;
+exports.TelemetryCanaryOrchestrator = __webpack_exports__.TelemetryCanaryOrchestrator;
+exports.TelemetryRegistry = __webpack_exports__.TelemetryRegistry;
+exports.TelemetryStartupHealthError = __webpack_exports__.TelemetryStartupHealthError;
+exports.createOtlpTelemetryExporter = __webpack_exports__.createOtlpTelemetryExporter;
+exports.createRuntimeFallbackSignalRuntimeState = __webpack_exports__.createRuntimeFallbackSignalRuntimeState;
+exports.createRuntimeSignalError = __webpack_exports__.createRuntimeSignalError;
+exports.createTelemetryAwareMetrics = __webpack_exports__.createTelemetryAwareMetrics;
+exports.createVictoriaMetricsTelemetryExporter = __webpack_exports__.createVictoriaMetricsTelemetryExporter;
+exports.enforceRuntimeFallbackSignalAuthToken = __webpack_exports__.enforceRuntimeFallbackSignalAuthToken;
+exports.enforceRuntimeFallbackSignalTrustPolicy = __webpack_exports__.enforceRuntimeFallbackSignalTrustPolicy;
+exports.getRuntimeSignalErrorStatusCode = __webpack_exports__.getRuntimeSignalErrorStatusCode;
+exports.hasEnabledTelemetryExporters = __webpack_exports__.hasEnabledTelemetryExporters;
+exports.injectTelemetryPlugin = __webpack_exports__.injectTelemetryPlugin;
+exports.normalizeRequiredRuntimeFallbackSignalAuthConfig = __webpack_exports__.normalizeRequiredRuntimeFallbackSignalAuthConfig;
+exports.normalizeRuntimeFallbackSignalAuthConfig = __webpack_exports__.normalizeRuntimeFallbackSignalAuthConfig;
+exports.normalizeRuntimeFallbackTrustPolicy = __webpack_exports__.normalizeRuntimeFallbackTrustPolicy;
+exports.parseRuntimeFallbackSignalPayloadFromRawBody = __webpack_exports__.parseRuntimeFallbackSignalPayloadFromRawBody;
+exports.resolveRuntimeFallbackSignalEndpoint = __webpack_exports__.resolveRuntimeFallbackSignalEndpoint;
+exports.resolveTelemetrySloOptions = __webpack_exports__.resolveTelemetrySloOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT",
+    "DEFAULT_RUNTIME_STATUS_ENDPOINT",
+    "TelemetryCanaryOrchestrator",
+    "TelemetryRegistry",
+    "TelemetryStartupHealthError",
+    "createOtlpTelemetryExporter",
+    "createRuntimeFallbackSignalRuntimeState",
+    "createRuntimeSignalError",
+    "createTelemetryAwareMetrics",
+    "createVictoriaMetricsTelemetryExporter",
+    "enforceRuntimeFallbackSignalAuthToken",
+    "enforceRuntimeFallbackSignalTrustPolicy",
+    "getRuntimeSignalErrorStatusCode",
+    "hasEnabledTelemetryExporters",
+    "injectTelemetryPlugin",
+    "normalizeRequiredRuntimeFallbackSignalAuthConfig",
+    "normalizeRuntimeFallbackSignalAuthConfig",
+    "normalizeRuntimeFallbackTrustPolicy",
+    "parseRuntimeFallbackSignalPayloadFromRawBody",
+    "resolveRuntimeFallbackSignalEndpoint",
+    "resolveTelemetrySloOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});