@futurewindai/wotchi 0.1.0-beta.5 → 1.0.0-rc.1

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

@@ -1,14 +1,32 @@
+import { normalizeRequestContextOptions } from "../request-context.js";
 import { getExpressRequestContext } from "./request-context.js";
 import { markExpressErrorCaptured } from "./state.js";
 export function createExpressErrorHandler(client, options) {
+    const normalizedOptions = normalizeRequestContextOptions(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, normalizedOptions);
+                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);
     };

package/dist/esm/integrations/express/state.js

@@ -1,26 +1,13 @@
-const WOTCHI_ERROR_CAPTURED = Symbol("wotchi.errorCaptured");
-const asMarkedRequest = (request) => typeof request === "object" && request !== null ? request : undefined;
+const capturedRequests = new WeakSet();
+const asRequestObject = (request) => typeof request === "object" && request !== null ? request : undefined;
 export function markExpressErrorCaptured(request) {
-    const markedRequest = asMarkedRequest(request);
-    if (markedRequest === undefined) {
+    const requestObject = asRequestObject(request);
+    if (requestObject === undefined) {
         return;
     }
-    try {
-        markedRequest[WOTCHI_ERROR_CAPTURED] = true;
-    }
-    catch {
-        // A request object can be frozen by host middleware; the observer remains best-effort.
-    }
+    capturedRequests.add(requestObject);
 }
 export function wasExpressErrorCaptured(request) {
-    const markedRequest = asMarkedRequest(request);
-    if (markedRequest === undefined) {
-        return false;
-    }
-    try {
-        return markedRequest[WOTCHI_ERROR_CAPTURED] === true;
-    }
-    catch {
-        return false;
-    }
+    const requestObject = asRequestObject(request);
+    return requestObject === undefined ? false : capturedRequests.has(requestObject);
 }

package/dist/esm/integrations/express/status-observer.js

@@ -1,4 +1,5 @@
 import { getExpressRequestContext } from "./request-context.js";
+import { normalizeRequestContextOptions } from "../request-context.js";
 import { wasExpressErrorCaptured } from "./state.js";
 const DEFAULT_STATUS_CODES = [401, 403, 429];
 const DEFAULT_STATUS_CLASSES = ["5xx"];
@@ -35,16 +36,9 @@ const normalizeAlertThreshold = (value) => {
 };
 const normalizeOptions = (options) => {
     const alertThreshold = normalizeAlertThreshold(options?.alertThreshold);
+    const requestContextOptions = normalizeRequestContextOptions(options);
     return {
-        ...(options?.requestIdProperty === undefined
-            ? {}
-            : { requestIdProperty: options.requestIdProperty }),
-        ...(options?.correlationIdProperty === undefined
-            ? {}
-            : { correlationIdProperty: options.correlationIdProperty }),
-        ...(options?.traceContextProperty === undefined
-            ? {}
-            : { traceContextProperty: options.traceContextProperty }),
+        ...requestContextOptions,
         statusCodes: normalizeStatuses(options?.statusCodes, DEFAULT_STATUS_CODES),
         statusClasses: normalizeStatusClasses(options?.statusClasses),
         ignoreStatusCodes: normalizeStatuses(options?.ignoreStatusCodes, []),

package/dist/esm/integrations/nest/capture.js

@@ -0,0 +1,17 @@
+import { markExpressErrorCaptured } from "../express/state.js";
+import { getNestRequestContext } from "./request-context.js";
+export const captureWotchiNestException = (client, exception, host, options) => {
+    try {
+        markExpressErrorCaptured(host.switchToHttp().getRequest());
+    }
+    catch {
+        // Non-HTTP NestJS contexts do not expose an Express request to mark.
+    }
+    try {
+        const requestContext = getNestRequestContext(host, exception, options);
+        client.captureException(exception, undefined, requestContext === undefined ? undefined : { request: requestContext });
+    }
+    catch {
+        // A capture failure must never change NestJS exception handling.
+    }
+};

package/dist/esm/integrations/nest/exception-filter.js

@@ -7,35 +7,84 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Catch } from "@nestjs/common";
+import { Catch, HttpException } from "@nestjs/common";
 import { BaseExceptionFilter } from "@nestjs/core";
-import { markExpressErrorCaptured } from "../express/state.js";
-import { getNestRequestContext } from "./request-context.js";
+import { normalizeRequestContextOptions } from "../request-context.js";
+import { captureWotchiNestException } from "./capture.js";
+const FILTER_CATCH_EXCEPTIONS = "__filterCatchExceptions__";
+const matchesException = (filter, exception) => {
+    const reflection = Reflect;
+    const exceptionTypes = reflection.getMetadata?.(FILTER_CATCH_EXCEPTIONS, filter.constructor);
+    if (!Array.isArray(exceptionTypes) || exceptionTypes.length === 0) {
+        return true;
+    }
+    return exceptionTypes.some((exceptionType) => typeof exceptionType === "function" &&
+        exception instanceof exceptionType);
+};
 let WotchiNestExceptionFilter = class WotchiNestExceptionFilter extends BaseExceptionFilter {
-    constructor(client, applicationRef, options) {
+    constructor(client, applicationRef, options, previousGlobalFilters = []) {
         super(applicationRef);
         this.client = client;
-        this.options = options;
+        this.previousGlobalFilters = previousGlobalFilters;
+        this.options = normalizeRequestContextOptions(options);
     }
     catch(exception, host) {
-        try {
-            markExpressErrorCaptured(host.switchToHttp().getRequest());
+        captureWotchiNestException(this.client, exception, host, this.options);
+        const existingFilter = this.previousGlobalFilters.find((filter) => matchesException(filter, exception));
+        if (existingFilter !== undefined) {
+            existingFilter.catch(exception, host);
+            return;
+        }
+        this.respondWithoutLoggingRawUnknownException(exception, host);
+    }
+    respondWithoutLoggingRawUnknownException(exception, host) {
+        if (this.applicationRef === undefined) {
+            this.respondThroughExpressAdapter(exception, host);
+            return;
         }
-        catch {
-            // Non-HTTP NestJS contexts do not expose an Express request to mark.
+        if (exception instanceof HttpException) {
+            super.catch(exception, host);
+            return;
+        }
+        const response = host.getArgByIndex(1);
+        if (this.applicationRef.isHeadersSent(response)) {
+            this.applicationRef.end(response);
+            return;
+        }
+        if (this.isHttpError(exception)) {
+            this.applicationRef.reply(response, { statusCode: exception.statusCode, message: exception.message }, exception.statusCode);
+            return;
+        }
+        this.applicationRef.reply(response, { statusCode: 500, message: "Internal server error" }, 500);
+    }
+    respondThroughExpressAdapter(exception, host) {
+        const response = host.switchToHttp().getResponse();
+        if (response.headersSent) {
+            response.end();
+            return;
         }
-        try {
-            const requestContext = getNestRequestContext(host, exception, this.options);
-            this.client.captureException(exception, undefined, requestContext === undefined ? undefined : { request: requestContext });
+        if (exception instanceof HttpException) {
+            const statusCode = exception.getStatus();
+            const exceptionResponse = exception.getResponse();
+            response
+                .status(statusCode)
+                .json(typeof exceptionResponse === "object" && exceptionResponse !== null
+                ? exceptionResponse
+                : { statusCode, message: exceptionResponse });
+            return;
         }
-        catch {
-            // A capture failure must never change NestJS exception handling.
+        if (this.isHttpError(exception)) {
+            response.status(exception.statusCode).json({
+                statusCode: exception.statusCode,
+                message: exception.message,
+            });
+            return;
         }
-        super.catch(exception, host);
+        response.status(500).json({ statusCode: 500, message: "Internal server error" });
     }
 };
 WotchiNestExceptionFilter = __decorate([
     Catch(),
-    __metadata("design:paramtypes", [Object, Object, Object])
+    __metadata("design:paramtypes", [Object, Object, Object, Array])
 ], WotchiNestExceptionFilter);
 export { WotchiNestExceptionFilter };

package/dist/esm/integrations/nest/filter-wrapper.js

@@ -0,0 +1,16 @@
+import { normalizeRequestContextOptions } from "../request-context.js";
+import { captureWotchiNestException } from "./capture.js";
+export function withWotchiNestFilter(client, filter, options) {
+    const normalizedOptions = normalizeRequestContextOptions(options);
+    const wrapped = Object.create(filter);
+    Object.defineProperty(wrapped, "catch", {
+        configurable: false,
+        enumerable: false,
+        value: (exception, host) => {
+            captureWotchiNestException(client, exception, host, normalizedOptions);
+            filter.catch(exception, host);
+        },
+        writable: false,
+    });
+    return wrapped;
+}

package/dist/esm/integrations/nest/index.js

@@ -1,2 +1,4 @@
 export { consoleNotifier, createWotchi, telegramNotifier, webhookNotifier } from "../../index.js";
+export { withWotchiNestFilter } from "./filter-wrapper.js";
+export { WotchiModule, WOTCHI_CLIENT } from "./module.js";
 export { registerWotchiNest, registerWotchiNestStatusObserver } from "./register.js";

package/dist/esm/integrations/nest/module.js

@@ -0,0 +1,41 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var WotchiModule_1;
+import { Global, Module } from "@nestjs/common";
+import { APP_FILTER } from "@nestjs/core";
+import { createWotchi } from "../../core/client.js";
+import { WotchiNestExceptionFilter } from "./exception-filter.js";
+export const WOTCHI_CLIENT = Symbol("@futurewindai/wotchi/client");
+let WotchiModule = WotchiModule_1 = class WotchiModule {
+    static forRoot(config, options) {
+        const registerGlobalFilter = options?.registerGlobalFilter ?? true;
+        const providers = [
+            {
+                provide: WOTCHI_CLIENT,
+                useFactory: () => createWotchi(config),
+            },
+        ];
+        if (registerGlobalFilter) {
+            providers.push({
+                provide: APP_FILTER,
+                useFactory: (client) => new WotchiNestExceptionFilter(client),
+                inject: [WOTCHI_CLIENT],
+            });
+        }
+        return {
+            module: WotchiModule_1,
+            global: true,
+            providers,
+            exports: [WOTCHI_CLIENT],
+        };
+    }
+};
+WotchiModule = WotchiModule_1 = __decorate([
+    Global(),
+    Module({})
+], WotchiModule);
+export { WotchiModule };

package/dist/esm/integrations/nest/register.js

@@ -1,13 +1,29 @@
 import { HttpAdapterHost } from "@nestjs/core";
+import { normalizeRequestContextOptions } from "../request-context.js";
 import { WotchiNestExceptionFilter } from "./exception-filter.js";
 import { wotchiStatusObserver } from "../express/status-observer.js";
+const isNestExceptionFilter = (value) => typeof value === "object" &&
+    value !== null &&
+    "catch" in value &&
+    typeof value.catch === "function";
+const getPreviousGlobalFilters = (application) => {
+    const configuredFilters = application.config?.getGlobalFilters?.();
+    if (!Array.isArray(configuredFilters)) {
+        return [];
+    }
+    return configuredFilters
+        .filter(isNestExceptionFilter)
+        .filter((filter) => !(filter instanceof WotchiNestExceptionFilter))
+        .reverse();
+};
 export function registerWotchiNest(app, client, options) {
+    const normalizedOptions = normalizeRequestContextOptions(options);
     const application = app;
     const directAdapter = application.getHttpAdapter?.();
     const httpAdapter = directAdapter === undefined
         ? application.get(HttpAdapterHost).httpAdapter
         : directAdapter;
-    application.useGlobalFilters(new WotchiNestExceptionFilter(client, httpAdapter, options));
+    application.useGlobalFilters(new WotchiNestExceptionFilter(client, httpAdapter, normalizedOptions, getPreviousGlobalFilters(application)));
 }
 export function registerWotchiNestStatusObserver(app, client, options) {
     const application = app;

package/dist/esm/integrations/request-context.js

@@ -20,33 +20,25 @@ export function normalizeRoutePath(value) {
     }
     return path.split("/").map(dynamicSegment).join("/").slice(0, MAX_ROUTE_LENGTH);
 }
-const normalizeRequestIdProperty = (property) => {
+const normalizePropertyName = (property, optionName) => {
     if (property === undefined) {
         return undefined;
     }
     if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(property)) {
-        throw new TypeError("requestIdProperty must be a simple property name");
-    }
-    return property;
-};
-const normalizeTraceContextProperty = (property) => {
-    if (property === undefined) {
-        return undefined;
-    }
-    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(property)) {
-        throw new TypeError("traceContextProperty must be a simple property name");
-    }
-    return property;
-};
-const normalizeCorrelationIdProperty = (property) => {
-    if (property === undefined) {
-        return undefined;
-    }
-    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(property)) {
-        throw new TypeError("correlationIdProperty must be a simple property name");
+        throw new TypeError(`${optionName} must be a simple property name`);
     }
     return property;
 };
+export function normalizeRequestContextOptions(options) {
+    const requestIdProperty = normalizePropertyName(options?.requestIdProperty, "requestIdProperty");
+    const correlationIdProperty = normalizePropertyName(options?.correlationIdProperty, "correlationIdProperty");
+    const traceContextProperty = normalizePropertyName(options?.traceContextProperty, "traceContextProperty");
+    return Object.freeze({
+        ...(requestIdProperty === undefined ? {} : { requestIdProperty }),
+        ...(correlationIdProperty === undefined ? {} : { correlationIdProperty }),
+        ...(traceContextProperty === undefined ? {} : { traceContextProperty }),
+    });
+}
 const readRequestId = (request, property) => {
     if (property === undefined || !isRecord(request)) {
         return undefined;
@@ -104,9 +96,8 @@ const readCorrelationId = (request, property) => {
     }
 };
 export function buildRequestContext(input) {
-    const requestIdProperty = normalizeRequestIdProperty(input.options?.requestIdProperty);
-    const correlationIdProperty = normalizeCorrelationIdProperty(input.options?.correlationIdProperty);
-    const traceContextProperty = normalizeTraceContextProperty(input.options?.traceContextProperty);
+    const options = normalizeRequestContextOptions(input.options);
+    const { requestIdProperty, correlationIdProperty, traceContextProperty } = options;
     let requestId;
     try {
         requestId = readRequestId(input.request, requestIdProperty);

package/dist/types/core/admission.d.ts

@@ -0,0 +1,10 @@
+export interface CaptureAdmissionOptions {
+    maxEventsPerSecond: number;
+    burst: number;
+    now?: () => number;
+}
+export interface CaptureAdmission {
+    tryAcquire(): boolean;
+}
+/** A small token bucket used before normalization to bound overload work. */
+export declare function createCaptureAdmission(options: CaptureAdmissionOptions): CaptureAdmission;

package/dist/types/core/config.d.ts

@@ -22,6 +22,16 @@ export interface NormalizedWotchiConfig {
     readonly queue: {
         readonly maxPendingAlerts: number;
         readonly concurrency: 1;
+        readonly notifierTimeoutMs: number;
+        readonly notifierCircuitBreaker: {
+            readonly failureThreshold: number;
+            readonly cooldownMs: number;
+        };
+    };
+    readonly overload?: {
+        readonly maxEventsPerSecond: number;
+        readonly burst: number;
+        readonly alertCooldownMs: number;
     };
     readonly privacy: {
         readonly redactKeys: readonly string[];

package/dist/types/core/diagnostics.d.ts

@@ -6,6 +6,8 @@ export interface DiagnosticsState {
     filterFailures: number;
     beforeSendFailures: number;
     eventsSuppressed: number;
+    eventsDroppedOverload: number;
+    capturesAfterShutdown: number;
 }
 export declare function createDiagnosticsState(): DiagnosticsState;
-export declare function snapshotDiagnostics(state: DiagnosticsState, values: Omit<WotchiDiagnostics, "capturedEvents" | "captureFailures" | "fingerprintCallbackFailures" | "filterFailures" | "beforeSendFailures" | "eventsSuppressed">): Readonly<WotchiDiagnostics>;
+export declare function snapshotDiagnostics(state: DiagnosticsState, values: Omit<WotchiDiagnostics, "capturedEvents" | "captureFailures" | "fingerprintCallbackFailures" | "filterFailures" | "beforeSendFailures" | "eventsSuppressed" | "eventsDroppedOverload" | "capturesAfterShutdown">): Readonly<WotchiDiagnostics>;

package/dist/types/core/incident-policy.d.ts

@@ -1,5 +1,5 @@
 import type { IncidentGroup, IncidentSeverity } from "./types.js";
-export type IncidentEventKind = "error" | "manual" | "process-monitor";
+export type IncidentEventKind = "error" | "manual" | "process-monitor" | "runtime-monitor";
 export interface IncidentPolicyInput {
     group: IncidentGroup;
     now: number;

package/dist/types/core/limits.d.ts

@@ -4,6 +4,10 @@ export declare const MAX_PENDING_ALERTS = 10000;
 export declare const MAX_WINDOW_MS: number;
 export declare const MAX_ALERT_THRESHOLD = 1000000;
 export declare const MAX_COOLDOWN_MS: number;
+export declare const MAX_CAPTURE_RATE = 1000000;
+export declare const MAX_NOTIFIER_TIMEOUT_MS = 60000;
+export declare const MAX_CIRCUIT_BREAKER_COOLDOWN_MS: number;
+export declare const MAX_CIRCUIT_BREAKER_FAILURES = 100;
 export declare const MAX_NORMALIZATION_DEPTH = 20;
 export declare const MAX_NORMALIZATION_KEYS = 10000;
 export declare const MAX_NORMALIZATION_STRING_LENGTH = 32768;

package/dist/types/core/notification-queue.d.ts

@@ -2,6 +2,11 @@ import type { IncidentAlert, WotchiNotifier } from "./types.js";
 export interface NotificationQueueOptions {
     maxPendingAlerts: number;
     concurrency: 1;
+    notifierTimeoutMs?: number;
+    notifierCircuitBreaker?: {
+        failureThreshold: number;
+        cooldownMs: number;
+    };
     onNotifierError?: (error: unknown, notifier: WotchiNotifier) => void;
 }
 export interface NotificationJobResult {
@@ -11,10 +16,14 @@ export interface NotificationJobResult {
 export interface NotificationQueue {
     enqueue(alert: IncidentAlert, notifiers: readonly WotchiNotifier[], onComplete?: (result: NotificationJobResult) => void): boolean;
     flush(timeoutMs?: number): Promise<void>;
+    close(timeoutMs?: number): Promise<void>;
+    isClosed(): boolean;
     pending(): number;
     alertsQueued(): number;
     alertsDropped(): number;
     alertsSent(): number;
     notifierFailures(): number;
+    notifierTimeouts(): number;
+    notifierCircuitOpenSkips(): number;
 }
 export declare function createNotificationQueue(options: NotificationQueueOptions): NotificationQueue;

package/dist/types/core/prometheus.d.ts

@@ -0,0 +1,7 @@
+import type { WotchiClient } from "./types.js";
+export declare const PROMETHEUS_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
+export interface WotchiPrometheusExporter {
+    readonly contentType: typeof PROMETHEUS_CONTENT_TYPE;
+    render(): string;
+}
+export declare function createWotchiPrometheusExporter(client: Pick<WotchiClient, "getDiagnostics">): WotchiPrometheusExporter;

package/dist/types/core/runtime-monitor.d.ts

@@ -0,0 +1,15 @@
+import type { WotchiClient } from "./types.js";
+export interface WotchiRuntimeWatcherOptions {
+    intervalMs?: number;
+    cpuPercent?: number;
+    rssBytes?: number;
+    heapUsedBytes?: number;
+    eventLoopDelayMs?: number;
+    pendingAlerts?: number;
+    notifierFailures?: number;
+    alertThreshold?: number;
+}
+export interface WotchiRuntimeWatcherHandle {
+    unregister(): void;
+}
+export declare function registerWotchiRuntimeWatcher(client: Pick<WotchiClient, "captureEvent" | "getDiagnostics">, options?: WotchiRuntimeWatcherOptions): WotchiRuntimeWatcherHandle;

package/dist/types/core/types.d.ts

@@ -1,5 +1,5 @@
 export type IncidentSeverity = "low" | "medium" | "high" | "critical";
-export type WotchiEventKind = "error" | "manual" | "process-monitor";
+export type WotchiEventKind = "error" | "manual" | "process-monitor" | "runtime-monitor";
 export interface WotchiTraceContext {
     traceId?: string;
     spanId?: string;
@@ -160,6 +160,16 @@ export interface WotchiConfig {
     queue?: {
         maxPendingAlerts?: number;
         concurrency?: 1;
+        notifierTimeoutMs?: number;
+        notifierCircuitBreaker?: {
+            failureThreshold?: number;
+            cooldownMs?: number;
+        };
+    };
+    overload?: {
+        maxEventsPerSecond?: number;
+        burst?: number;
+        alertCooldownMs?: number;
     };
     privacy?: {
         redactKeys?: string[];
@@ -182,8 +192,12 @@ export interface WotchiDiagnostics {
     filterFailures: number;
     beforeSendFailures: number;
     eventsSuppressed: number;
+    eventsDroppedOverload: number;
+    capturesAfterShutdown: number;
     activeGroups: number;
     pendingAlerts: number;
+    notifierTimeouts: number;
+    notifierCircuitOpenSkips: number;
 }
 export type WotchiTestAlertStatus = "sent" | "queue-full" | "timeout" | "notifier-failed";
 export interface WotchiTestAlertResult {
@@ -201,5 +215,6 @@ export interface WotchiClient {
     captureEvent(event: WotchiEventInput): void;
     testAlert(): Promise<WotchiTestAlertResult>;
     flush(timeoutMs?: number): Promise<void>;
+    shutdown(timeoutMs?: number): Promise<void>;
     getDiagnostics(): Readonly<WotchiDiagnostics>;
 }