@futurewindai/wotchi 0.1.0-beta.5 → 0.1.0-beta.6

package/dist/esm/core/client.js

@@ -1,4 +1,5 @@
 import { validateConfig } from "./config.js";
+import { createCaptureAdmission } from "./admission.js";
 import { createDiagnosticsState, snapshotDiagnostics } from "./diagnostics.js";
 import { fingerprintSafeErrorEvent } from "./fingerprint.js";
 import { createGroupStore } from "./group-store.js";
@@ -279,9 +280,19 @@ export function createWotchi(config) {
     const queue = createNotificationQueue({
         maxPendingAlerts: normalized.queue.maxPendingAlerts,
         concurrency: normalized.queue.concurrency,
+        notifierTimeoutMs: normalized.queue.notifierTimeoutMs,
+        notifierCircuitBreaker: normalized.queue.notifierCircuitBreaker,
     });
+    const admission = normalized.overload === undefined
+        ? undefined
+        : createCaptureAdmission({
+            maxEventsPerSecond: normalized.overload.maxEventsPerSecond,
+            burst: normalized.overload.burst,
+            now,
+        });
     const privacy = normalized.privacy;
     let eventSequence = 0;
+    let overloadLastAlertAt = 0;
     const matchingRule = (event) => normalized.rules.find((rule) => (rule.environment === undefined || rule.environment === event.environment) &&
         (rule.route === undefined || rule.route === event.request?.route));
     const captureSafeEvent = (error, metadata, context, request, eventKind = "error", alertThreshold = normalized.grouping.alertThreshold, fingerprintOverride, severityOverride, trace, correlationId, operation, job, tags) => {
@@ -402,11 +413,28 @@ export function createWotchi(config) {
         }
         diagnostics.capturedEvents += 1;
     };
+    const emitOverloadSignal = (timestamp) => {
+        const cooldownMs = normalized.overload?.alertCooldownMs ?? 0;
+        if (cooldownMs > 0 && timestamp - overloadLastAlertAt < cooldownMs) {
+            return;
+        }
+        overloadLastAlertAt = timestamp;
+        captureSafeEvent(new Error("Wotchi capture overload: admission limit reached"), undefined, { droppedEvents: diagnostics.eventsDroppedOverload }, undefined, "runtime-monitor", 1, "wotchi.capture.overload", "high", undefined, undefined, "wotchi.overload", undefined, undefined);
+    };
     const captureException = (error, context, options) => {
         if (!normalized.enabled) {
             return;
         }
+        if (queue.isClosed()) {
+            diagnostics.capturesAfterShutdown += 1;
+            return;
+        }
         try {
+            if (admission !== undefined && !admission.tryAcquire()) {
+                diagnostics.eventsDroppedOverload += 1;
+                emitOverloadSignal(now());
+                return;
+            }
             captureSafeEvent(error, undefined, context, options?.request, "error", normalizeEventAlertThreshold(options?.alertThreshold) ?? normalized.grouping.alertThreshold, options?.fingerprint, options?.severity, options?.trace, options?.correlationId, options?.operation, options?.job, options?.tags);
         }
         catch {
@@ -417,6 +445,10 @@ export function createWotchi(config) {
         if (!normalized.enabled) {
             return;
         }
+        if (queue.isClosed()) {
+            diagnostics.capturesAfterShutdown += 1;
+            return;
+        }
         try {
             if (event === null || typeof event !== "object" || event.level !== "error") {
                 throw new TypeError("event.level must be error");
@@ -425,6 +457,14 @@ export function createWotchi(config) {
                 throw new TypeError("event.message must be a string");
             }
             const alertThreshold = normalizeEventAlertThreshold(event.alertThreshold);
+            if (admission !== undefined &&
+                event.kind !== "process-monitor" &&
+                event.kind !== "runtime-monitor" &&
+                !admission.tryAcquire()) {
+                diagnostics.eventsDroppedOverload += 1;
+                emitOverloadSignal(now());
+                return;
+            }
             captureSafeEvent(event.error ?? safeMessage(event.message, privacy), event.metadata, event.context, event.request, event.kind ?? "error", alertThreshold ?? normalized.grouping.alertThreshold, event.fingerprint, event.severity, event.trace, event.correlationId, event.operation, event.job, event.tags);
         }
         catch {
@@ -437,6 +477,8 @@ export function createWotchi(config) {
         alertsDropped: queue.alertsDropped(),
         alertsSent: queue.alertsSent(),
         notifierFailures: queue.notifierFailures(),
+        notifierTimeouts: queue.notifierTimeouts(),
+        notifierCircuitOpenSkips: queue.notifierCircuitOpenSkips(),
         activeGroups: groupStore.size(),
         pendingAlerts: queue.pending(),
     });
@@ -500,11 +542,15 @@ export function createWotchi(config) {
             ...(status === "notifier-failed" ? { error: "One or more notifiers failed." } : {}),
         };
     };
+    const shutdown = async (timeoutMs) => {
+        await queue.close(timeoutMs);
+    };
     return {
         captureException,
         captureEvent,
         testAlert,
         flush: (timeoutMs) => queue.flush(timeoutMs),
+        shutdown,
         getDiagnostics: readDiagnostics,
     };
 }

package/dist/esm/core/config.js

@@ -1,5 +1,5 @@
 import { WotchiConfigurationError } from "./errors.js";
-import { MAX_ALERT_THRESHOLD, MAX_COOLDOWN_MS, MAX_EVENTS_PER_WINDOW, MAX_GROUPS, MAX_NORMALIZATION_DEPTH, MAX_NORMALIZATION_KEYS, MAX_NORMALIZATION_STACK_LENGTH, MAX_NORMALIZATION_STRING_LENGTH, MAX_PENDING_ALERTS, MAX_WINDOW_MS, } from "./limits.js";
+import { MAX_ALERT_THRESHOLD, MAX_CAPTURE_RATE, MAX_CIRCUIT_BREAKER_COOLDOWN_MS, MAX_CIRCUIT_BREAKER_FAILURES, MAX_COOLDOWN_MS, MAX_EVENTS_PER_WINDOW, MAX_GROUPS, MAX_NORMALIZATION_DEPTH, MAX_NORMALIZATION_KEYS, MAX_NORMALIZATION_STACK_LENGTH, MAX_NORMALIZATION_STRING_LENGTH, MAX_PENDING_ALERTS, MAX_NOTIFIER_TIMEOUT_MS, MAX_WINDOW_MS, } from "./limits.js";
 export { WotchiConfigurationError };
 const MAX_REDACT_KEYS = 100;
 const MAX_RULES = 50;
@@ -228,7 +228,9 @@ export function validateConfig(config) {
     }
     const grouping = readOptionalRecord(config.grouping, "grouping");
     const queue = readOptionalRecord(config.queue, "queue");
+    const notifierCircuitBreaker = readOptionalRecord(queue?.notifierCircuitBreaker, "queue.notifierCircuitBreaker");
     const privacy = readOptionalRecord(config.privacy, "privacy");
+    const overload = readOptionalRecord(config.overload, "overload");
     const links = normalizeLinks(config.links);
     const concurrency = queue?.concurrency;
     if (concurrency !== undefined && concurrency !== 1) {
@@ -255,7 +257,21 @@ export function validateConfig(config) {
         queue: Object.freeze({
             maxPendingAlerts: readPositiveInteger(queue, "maxPendingAlerts", 100, MAX_PENDING_ALERTS),
             concurrency: 1,
+            notifierTimeoutMs: readPositiveInteger(queue, "notifierTimeoutMs", 5_000, MAX_NOTIFIER_TIMEOUT_MS),
+            notifierCircuitBreaker: Object.freeze({
+                failureThreshold: readPositiveInteger(notifierCircuitBreaker, "failureThreshold", 3, MAX_CIRCUIT_BREAKER_FAILURES),
+                cooldownMs: readPositiveInteger(notifierCircuitBreaker, "cooldownMs", 30_000, MAX_CIRCUIT_BREAKER_COOLDOWN_MS),
+            }),
         }),
+        ...(overload === undefined
+            ? {}
+            : {
+                overload: Object.freeze({
+                    maxEventsPerSecond: readPositiveInteger(overload, "maxEventsPerSecond", 1_000, MAX_CAPTURE_RATE),
+                    burst: readPositiveInteger(overload, "burst", readPositiveInteger(overload, "maxEventsPerSecond", 1_000, MAX_CAPTURE_RATE), MAX_CAPTURE_RATE),
+                    alertCooldownMs: readPositiveInteger(overload, "alertCooldownMs", 60_000, MAX_COOLDOWN_MS),
+                }),
+            }),
         privacy: Object.freeze({
             redactKeys: normalizeRedactKeys(privacy),
             maxDepth: readPositiveInteger(privacy, "maxDepth", 5, MAX_NORMALIZATION_DEPTH),

package/dist/esm/core/diagnostics.js

@@ -6,6 +6,8 @@ export function createDiagnosticsState() {
         filterFailures: 0,
         beforeSendFailures: 0,
         eventsSuppressed: 0,
+        eventsDroppedOverload: 0,
+        capturesAfterShutdown: 0,
     };
 }
 export function snapshotDiagnostics(state, values) {
@@ -16,6 +18,8 @@ export function snapshotDiagnostics(state, values) {
         filterFailures: state.filterFailures,
         beforeSendFailures: state.beforeSendFailures,
         eventsSuppressed: state.eventsSuppressed,
+        eventsDroppedOverload: state.eventsDroppedOverload,
+        capturesAfterShutdown: state.capturesAfterShutdown,
         ...values,
     });
 }

package/dist/esm/core/group-store.js

@@ -47,14 +47,9 @@ export function createGroupStore(options) {
         severity: group.severity,
     });
     const evictLeastRecent = () => {
-        let candidate;
-        for (const group of groups.values()) {
-            if (candidate === undefined || group.lastSeenMs < candidate.lastSeenMs) {
-                candidate = group;
-            }
-        }
-        if (candidate !== undefined) {
-            groups.delete(candidate.fingerprint);
+        const oldestFingerprint = groups.keys().next().value;
+        if (typeof oldestFingerprint === "string") {
+            groups.delete(oldestFingerprint);
             evicted += 1;
         }
     };
@@ -80,6 +75,10 @@ export function createGroupStore(options) {
             };
             groups.set(fingerprint, group);
         }
+        else {
+            groups.delete(fingerprint);
+            groups.set(fingerprint, group);
+        }
         group.lastSeenMs = timestamp;
         group.totalCount += 1;
         group.severity = severity;

package/dist/esm/core/limits.js

@@ -4,6 +4,10 @@ export const MAX_PENDING_ALERTS = 10_000;
 export const MAX_WINDOW_MS = 7 * 24 * 60 * 60 * 1_000;
 export const MAX_ALERT_THRESHOLD = 1_000_000;
 export const MAX_COOLDOWN_MS = 30 * 24 * 60 * 60 * 1_000;
+export const MAX_CAPTURE_RATE = 1_000_000;
+export const MAX_NOTIFIER_TIMEOUT_MS = 60_000;
+export const MAX_CIRCUIT_BREAKER_COOLDOWN_MS = 24 * 60 * 60 * 1_000;
+export const MAX_CIRCUIT_BREAKER_FAILURES = 100;
 export const MAX_NORMALIZATION_DEPTH = 20;
 export const MAX_NORMALIZATION_KEYS = 10_000;
 export const MAX_NORMALIZATION_STRING_LENGTH = 32_768;

package/dist/esm/core/normalize.js

@@ -94,7 +94,12 @@ const normalizeValue = (value, depth, state, limits) => {
             break;
         }
         state.keysVisited += 1;
-        result[truncate(key, limits.maxStringLength)] = normalizeValue(readProperty(value, key), depth + 1, state, limits);
+        const child = readProperty(value, key);
+        const normalizedKey = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+        result[truncate(key, limits.maxStringLength)] =
+            normalizedKey === "stack" && typeof child === "string"
+                ? truncate(child, limits.maxStackLength)
+                : normalizeValue(child, depth + 1, state, limits);
     }
     return result;
 };

package/dist/esm/core/notification-queue.js

@@ -1,5 +1,8 @@
-import { MAX_PENDING_ALERTS } from "./limits.js";
+import { MAX_CIRCUIT_BREAKER_COOLDOWN_MS, MAX_CIRCUIT_BREAKER_FAILURES, MAX_NOTIFIER_TIMEOUT_MS, MAX_PENDING_ALERTS, } from "./limits.js";
 const DEFAULT_FLUSH_TIMEOUT_MS = 5_000;
+const DEFAULT_NOTIFIER_TIMEOUT_MS = 5_000;
+const DEFAULT_CIRCUIT_FAILURE_THRESHOLD = 3;
+const DEFAULT_CIRCUIT_COOLDOWN_MS = 30_000;
 export function createNotificationQueue(options) {
     if (!Number.isSafeInteger(options.maxPendingAlerts) ||
         options.maxPendingAlerts <= 0 ||
@@ -9,6 +12,23 @@ export function createNotificationQueue(options) {
     if (options.concurrency !== 1) {
         throw new RangeError("concurrency must be 1");
     }
+    if (options.notifierTimeoutMs !== undefined &&
+        (!Number.isSafeInteger(options.notifierTimeoutMs) ||
+            options.notifierTimeoutMs <= 0 ||
+            options.notifierTimeoutMs > MAX_NOTIFIER_TIMEOUT_MS)) {
+        throw new RangeError("notifierTimeoutMs must be a positive integer");
+    }
+    if (options.notifierCircuitBreaker !== undefined) {
+        const { failureThreshold, cooldownMs } = options.notifierCircuitBreaker;
+        if (!Number.isSafeInteger(failureThreshold) ||
+            failureThreshold <= 0 ||
+            failureThreshold > MAX_CIRCUIT_BREAKER_FAILURES ||
+            !Number.isSafeInteger(cooldownMs) ||
+            cooldownMs <= 0 ||
+            cooldownMs > MAX_CIRCUIT_BREAKER_COOLDOWN_MS) {
+            throw new RangeError("notifierCircuitBreaker limits are invalid");
+        }
+    }
     const pendingJobs = [];
     let drainPromise;
     let resolveDrain;
@@ -17,6 +37,15 @@ export function createNotificationQueue(options) {
     let dropped = 0;
     let sent = 0;
     let failures = 0;
+    let timeouts = 0;
+    let circuitOpenSkips = 0;
+    let closed = false;
+    const notifierStates = new Map();
+    const notifierTimeoutMs = options.notifierTimeoutMs ?? DEFAULT_NOTIFIER_TIMEOUT_MS;
+    const circuit = options.notifierCircuitBreaker ?? {
+        failureThreshold: DEFAULT_CIRCUIT_FAILURE_THRESHOLD,
+        cooldownMs: DEFAULT_CIRCUIT_COOLDOWN_MS,
+    };
     const notifyFailure = (error, notifier) => {
         failures += 1;
         try {
@@ -35,19 +64,51 @@ export function createNotificationQueue(options) {
         resolveDrain = undefined;
     };
     const processJob = async (job) => {
-        let jobSent = 0;
-        let jobFailures = 0;
-        for (const notifier of job.notifiers) {
+        const results = await Promise.all(job.notifiers.map(async (notifier) => {
+            const state = notifierStates.get(notifier) ?? { failures: 0, openUntil: 0 };
+            const timestamp = Date.now();
+            if (state.openUntil > timestamp) {
+                circuitOpenSkips += 1;
+                notifyFailure(new Error(`Notifier circuit is open: ${notifier.name}`), notifier);
+                return { sent: 0, failed: 1 };
+            }
+            if (state.openUntil !== 0) {
+                state.openUntil = 0;
+                state.failures = 0;
+            }
+            let timer;
             try {
-                await notifier.send(job.alert);
+                const timeout = new Promise((_, reject) => {
+                    timer = setTimeout(() => {
+                        timeouts += 1;
+                        reject(new Error(`Notifier timed out after ${notifierTimeoutMs}ms: ${notifier.name}`));
+                    }, notifierTimeoutMs);
+                    timer.unref?.();
+                });
+                await Promise.race([notifier.send(job.alert), timeout]);
+                if (timer !== undefined) {
+                    clearTimeout(timer);
+                }
+                state.failures = 0;
+                notifierStates.set(notifier, state);
                 sent += 1;
-                jobSent += 1;
+                return { sent: 1, failed: 0 };
             }
             catch (error) {
-                jobFailures += 1;
+                if (timer !== undefined) {
+                    clearTimeout(timer);
+                }
+                state.failures += 1;
+                if (state.failures >= circuit.failureThreshold) {
+                    state.openUntil = Date.now() + circuit.cooldownMs;
+                }
+                notifierStates.set(notifier, state);
                 notifyFailure(error, notifier);
+                return { sent: 0, failed: 1 };
             }
-        }
+        }));
+        const jobSent = results.reduce((total, result) => total + result.sent, 0);
+        const jobFailures = results.reduce((total, result) => total + result.failed, 0);
         try {
             job.onComplete?.({ notifierFailures: jobFailures, sent: jobSent });
         }
@@ -70,7 +131,7 @@ export function createNotificationQueue(options) {
         }
     };
     const enqueue = (alert, notifiers, onComplete) => {
-        if (pendingJobs.length >= options.maxPendingAlerts) {
+        if (closed || pendingJobs.length >= options.maxPendingAlerts) {
             dropped += 1;
             return false;
         }
@@ -83,6 +144,10 @@ export function createNotificationQueue(options) {
         pump();
         return true;
     };
+    const close = (timeoutMs = DEFAULT_FLUSH_TIMEOUT_MS) => {
+        closed = true;
+        return flush(timeoutMs);
+    };
     const flush = (timeoutMs = DEFAULT_FLUSH_TIMEOUT_MS) => {
         if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) {
             return Promise.reject(new RangeError("timeoutMs must be a positive integer"));
@@ -108,10 +173,14 @@ export function createNotificationQueue(options) {
     return {
         enqueue,
         flush,
+        close,
+        isClosed: () => closed,
         pending: () => pendingJobs.length,
         alertsQueued: () => queued,
         alertsDropped: () => dropped,
         alertsSent: () => sent,
         notifierFailures: () => failures,
+        notifierTimeouts: () => timeouts,
+        notifierCircuitOpenSkips: () => circuitOpenSkips,
     };
 }

package/dist/esm/core/prometheus.js

@@ -0,0 +1,125 @@
+export const PROMETHEUS_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
+const METRICS = [
+    {
+        name: "captured_events_total",
+        help: "Total events accepted by Wotchi.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.capturedEvents,
+    },
+    {
+        name: "capture_failures_total",
+        help: "Capture failures contained by Wotchi.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.captureFailures,
+    },
+    {
+        name: "groups_evicted_total",
+        help: "Groups evicted from bounded memory.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.groupsEvicted,
+    },
+    {
+        name: "alerts_queued_total",
+        help: "Alerts admitted to the notification queue.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.alertsQueued,
+    },
+    {
+        name: "alerts_dropped_total",
+        help: "Alerts dropped because the notification queue was full.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.alertsDropped,
+    },
+    {
+        name: "alerts_sent_total",
+        help: "Alerts delivered successfully to notifiers.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.alertsSent,
+    },
+    {
+        name: "notifier_failures_total",
+        help: "Notifier delivery failures contained by Wotchi.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.notifierFailures,
+    },
+    {
+        name: "fingerprint_callback_failures_total",
+        help: "Fingerprint callback failures contained by Wotchi.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.fingerprintCallbackFailures,
+    },
+    {
+        name: "filter_failures_total",
+        help: "Event filter failures contained by Wotchi.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.filterFailures,
+    },
+    {
+        name: "before_send_failures_total",
+        help: "Before-send callback failures contained by Wotchi.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.beforeSendFailures,
+    },
+    {
+        name: "events_suppressed_total",
+        help: "Events suppressed by filtering, thresholds, or cooldowns.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.eventsSuppressed,
+    },
+    {
+        name: "events_dropped_overload_total",
+        help: "Events dropped before normalization by the optional overload admission limit.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.eventsDroppedOverload,
+    },
+    {
+        name: "captures_after_shutdown_total",
+        help: "Capture calls ignored after client shutdown.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.capturesAfterShutdown,
+    },
+    {
+        name: "notifier_timeouts_total",
+        help: "Notifier deliveries that exceeded the configured timeout.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.notifierTimeouts,
+    },
+    {
+        name: "notifier_circuit_open_skips_total",
+        help: "Notifier deliveries skipped while the notifier circuit was open.",
+        type: "counter",
+        value: (diagnostics) => diagnostics.notifierCircuitOpenSkips,
+    },
+    {
+        name: "active_groups",
+        help: "Current in-memory incident groups.",
+        type: "gauge",
+        value: (diagnostics) => diagnostics.activeGroups,
+    },
+    {
+        name: "pending_alerts",
+        help: "Current alerts waiting for notifier delivery.",
+        type: "gauge",
+        value: (diagnostics) => diagnostics.pendingAlerts,
+    },
+];
+const safeMetricValue = (value) => {
+    if (!Number.isFinite(value) || value <= 0) {
+        return 0;
+    }
+    return Math.min(Math.floor(value), Number.MAX_SAFE_INTEGER);
+};
+const renderMetrics = (diagnostics) => {
+    const lines = [];
+    for (const metric of METRICS) {
+        lines.push(`# HELP wotchi_${metric.name} ${metric.help}`, `# TYPE wotchi_${metric.name} ${metric.type}`, `wotchi_${metric.name} ${safeMetricValue(metric.value(diagnostics))}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+};
+export function createWotchiPrometheusExporter(client) {
+    return Object.freeze({
+        contentType: PROMETHEUS_CONTENT_TYPE,
+        render: () => renderMetrics(client.getDiagnostics()),
+    });
+}

package/dist/esm/core/redact.js

@@ -60,6 +60,7 @@ const redactCardLikeValues = (value) => value.replace(/\b\d[\d -]{11,25}\d\b/g,
 const CONNECTION_URL_PATTERN = /\b(?:postgres(?:ql)?|rediss?|mongodb(?:\+srv)?):\/\/[^\s"'<>]+/gi;
 const CONNECTION_QUERY_SECRET_PATTERN = /([?&](?:password|passwd|pass|secret|token|api[-_]?key|access[-_]?token|refresh[-_]?token|sslpassword)=)[^&#\s]*/gi;
 const URL_TRAILING_PUNCTUATION = /[),.;!?]+$/;
+const AUTHORITY_USERINFO_PATTERN = /\b[^:\s/@]+:[^\s/@]+@(?=(?:[a-z0-9-]+(?:\.[a-z0-9-]+)*|\[[0-9a-f:.]+\])(?::\d+)?(?:[/?#\s,;.)]|$))/gi;
 const redactConnectionUrl = (candidate) => {
     let core = candidate;
     let suffix = "";
@@ -83,6 +84,7 @@ const redactConnectionUrl = (candidate) => {
     return `${core.slice(0, authorityStart)}${redactedAuthority}${remainder}${suffix}`;
 };
 const redactConnectionUrls = (value) => value.replace(CONNECTION_URL_PATTERN, redactConnectionUrl);
+const redactAuthorityUserinfo = (value) => value.replace(AUTHORITY_USERINFO_PATTERN, `${REDACTED}@`);
 const SENSITIVE_QUERY_KEYS = new Set([
     "authorization",
     "cookie",
@@ -114,6 +116,7 @@ const redactSensitiveQueryValues = (value) => value.replace(/([?&])([^=&#\s]+)=(
 const redactWebhookPathSecrets = (value) => value.replace(/(https?:\/\/[^/\s]+\/(?:services|hooks|webhooks?)\/)[^/?#\s]+/gi, (_match, prefix) => prefix + REDACTED);
 const redactString = (value, maxStringLength) => {
     let result = redactConnectionUrls(value);
+    result = redactAuthorityUserinfo(result);
     result = redactWebhookPathSecrets(result);
     result = redactSensitiveQueryValues(result);
     result = result.replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/gi, REDACTED);
@@ -124,7 +127,7 @@ const redactString = (value, maxStringLength) => {
         const separatorIndex = match.search(/[:=]/);
         return separatorIndex < 0 ? REDACTED : `${match.slice(0, separatorIndex + 1)}${REDACTED}`;
     });
-    result = result.replace(/\b[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, REDACTED);
+    result = result.replace(/\b[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, REDACTED);
     result = result.replace(/\b(?:github_pat|ghp|xox[baprs]-|sk|pk|AKIA)[A-Za-z0-9_-]{8,}\b/gi, REDACTED);
     result = redactCardLikeValues(result);
     return result.slice(0, maxStringLength);

package/dist/esm/core/runtime-monitor.js

@@ -0,0 +1,106 @@
+const DEFAULT_INTERVAL_MS = 5_000;
+const MIN_INTERVAL_MS = 100;
+const MAX_INTERVAL_MS = 60_000;
+const MAX_THRESHOLD = Number.MAX_SAFE_INTEGER;
+const positiveNumber = (value, fallback, field) => {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (!Number.isFinite(value) || value <= 0 || value > MAX_THRESHOLD) {
+        throw new RangeError(`${field} must be a positive finite number`);
+    }
+    return value;
+};
+export function registerWotchiRuntimeWatcher(client, options = {}) {
+    const intervalMs = positiveNumber(options.intervalMs, DEFAULT_INTERVAL_MS, "intervalMs");
+    if (!Number.isSafeInteger(intervalMs) ||
+        intervalMs < MIN_INTERVAL_MS ||
+        intervalMs > MAX_INTERVAL_MS) {
+        throw new RangeError(`intervalMs must be an integer from ${MIN_INTERVAL_MS} to ${MAX_INTERVAL_MS}`);
+    }
+    const thresholds = {
+        cpuPercent: options.cpuPercent,
+        rssBytes: options.rssBytes,
+        heapUsedBytes: options.heapUsedBytes,
+        eventLoopDelayMs: options.eventLoopDelayMs,
+        pendingAlerts: options.pendingAlerts,
+        notifierFailures: options.notifierFailures,
+    };
+    for (const [field, value] of Object.entries(thresholds)) {
+        if (value !== undefined) {
+            positiveNumber(value, 1, field);
+        }
+    }
+    const alertThreshold = options.alertThreshold ?? 3;
+    if (!Number.isSafeInteger(alertThreshold) || alertThreshold <= 0 || alertThreshold > 1_000_000) {
+        throw new RangeError("alertThreshold must be a positive integer no greater than 1000000");
+    }
+    let previousCpu = process.cpuUsage();
+    let previousTime = process.hrtime.bigint();
+    let previousNotifierFailures = client.getDiagnostics().notifierFailures;
+    let expectedAt = Date.now() + intervalMs;
+    let registered = true;
+    const sample = () => {
+        if (!registered) {
+            return;
+        }
+        const timestamp = Date.now();
+        const elapsedMicros = Math.max(1, Number(process.hrtime.bigint() - previousTime) / 1_000);
+        const cpu = process.cpuUsage(previousCpu);
+        previousCpu = process.cpuUsage();
+        previousTime = process.hrtime.bigint();
+        const memory = process.memoryUsage();
+        const eventLoopDelayMs = Math.max(0, timestamp - expectedAt);
+        expectedAt = timestamp + intervalMs;
+        const cpuPercent = ((cpu.user + cpu.system) / elapsedMicros) * 100;
+        const diagnostics = client.getDiagnostics();
+        const notifierFailures = Math.max(0, diagnostics.notifierFailures - previousNotifierFailures);
+        previousNotifierFailures = diagnostics.notifierFailures;
+        const readings = [
+            { metric: "cpu-percent", value: cpuPercent, threshold: thresholds.cpuPercent },
+            { metric: "rss-bytes", value: memory.rss, threshold: thresholds.rssBytes },
+            { metric: "heap-used-bytes", value: memory.heapUsed, threshold: thresholds.heapUsedBytes },
+            {
+                metric: "event-loop-delay-ms",
+                value: eventLoopDelayMs,
+                threshold: thresholds.eventLoopDelayMs,
+            },
+            { metric: "pending-alerts", value: 0, threshold: thresholds.pendingAlerts },
+            {
+                metric: "notifier-failures",
+                value: notifierFailures,
+                threshold: thresholds.notifierFailures,
+            },
+        ];
+        for (const reading of readings) {
+            const value = reading.metric === "pending-alerts" ? diagnostics.pendingAlerts : reading.value;
+            if (reading.threshold === undefined || value < reading.threshold) {
+                continue;
+            }
+            client.captureEvent({
+                level: "error",
+                kind: "runtime-monitor",
+                message: `Wotchi runtime pressure: ${reading.metric}`,
+                fingerprint: `wotchi.runtime.${reading.metric}`,
+                severity: "high",
+                alertThreshold,
+                context: {
+                    metric: reading.metric,
+                    value: Math.round(value * 100) / 100,
+                    threshold: reading.threshold,
+                },
+            });
+        }
+    };
+    const timer = setInterval(sample, intervalMs);
+    timer.unref?.();
+    return {
+        unregister: () => {
+            if (!registered) {
+                return;
+            }
+            registered = false;
+            clearInterval(timer);
+        },
+    };
+}

package/dist/esm/index.js

@@ -1,7 +1,9 @@
 import { createWotchi } from "./core/client.js";
 import { registerWotchiProcessMonitor } from "./core/process-monitor.js";
+import { createWotchiPrometheusExporter, PROMETHEUS_CONTENT_TYPE } from "./core/prometheus.js";
+import { registerWotchiRuntimeWatcher } from "./core/runtime-monitor.js";
 import { consoleNotifier } from "./notifiers/console.js";
 import { telegramNotifier } from "./notifiers/telegram.js";
 import { webhookNotifier } from "./notifiers/webhook.js";
 export { WotchiConfigurationError } from "./core/errors.js";
-export { consoleNotifier, createWotchi, registerWotchiProcessMonitor, telegramNotifier, webhookNotifier, };
+export { consoleNotifier, createWotchi, createWotchiPrometheusExporter, PROMETHEUS_CONTENT_TYPE, registerWotchiProcessMonitor, registerWotchiRuntimeWatcher, telegramNotifier, webhookNotifier, };

package/dist/esm/integrations/express/error-handler.js

@@ -3,12 +3,28 @@ import { markExpressErrorCaptured } from "./state.js";
 export function createExpressErrorHandler(client, options) {
     return (error, request, response, next) => {
         markExpressErrorCaptured(request);
-        try {
-            const requestContext = getExpressRequestContext(request, response, options);
-            client.captureException(error, undefined, requestContext === undefined ? undefined : { request: requestContext });
+        let captured = false;
+        const captureAfterResponse = () => {
+            if (captured) {
+                return;
+            }
+            captured = true;
+            response.off("finish", captureAfterResponse);
+            response.off("close", captureAfterResponse);
+            try {
+                const requestContext = getExpressRequestContext(request, response, options);
+                client.captureException(error, undefined, requestContext === undefined ? undefined : { request: requestContext });
+            }
+            catch {
+                // A capture failure must never change Express error handling.
+            }
+        };
+        if (response.writableEnded || response.finished) {
+            captureAfterResponse();
         }
-        catch {
-            // A capture failure must never change Express error handling.
+        else {
+            response.once("finish", captureAfterResponse);
+            response.once("close", captureAfterResponse);
         }
         next(error);
     };