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

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,83 @@ 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 { 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;
     }
     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,14 @@
+import { captureWotchiNestException } from "./capture.js";
+export function withWotchiNestFilter(client, filter, options) {
+    const wrapped = Object.create(filter);
+    Object.defineProperty(wrapped, "catch", {
+        configurable: false,
+        enumerable: false,
+        value: (exception, host) => {
+            captureWotchiNestException(client, exception, host, options);
+            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,27 @@
 import { HttpAdapterHost } from "@nestjs/core";
 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 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, options, getPreviousGlobalFilters(application)));
 }
 export function registerWotchiNestStatusObserver(app, client, options) {
     const application = app;

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>;
 }

package/dist/types/index.d.ts

@@ -1,11 +1,15 @@
 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 type { ProcessMonitorHandle } from "./core/process-monitor.js";
 export type { NormalizedWotchiConfig } from "./core/config.js";
+export type { WotchiPrometheusExporter } from "./core/prometheus.js";
+export type { WotchiRuntimeWatcherHandle, WotchiRuntimeWatcherOptions, } from "./core/runtime-monitor.js";
 export type { ConsoleNotifierOptions, IncidentAlert, IncidentGroup, IncidentSeverity, SafeErrorEvent, TelegramNotifierOptions, WebhookNotifierOptions, WotchiBeforeSend, WotchiCaptureOptions, WotchiClient, WotchiConfig, WotchiDiagnostics, WotchiEventFilter, WotchiEventInput, WotchiEventKind, WotchiFingerprintOverride, WotchiFingerprintCallback, WotchiIncidentRule, WotchiLinkTemplates, WotchiLinks, WotchiNotifier, WotchiRequestContext, WotchiTags, WotchiTestAlertResult, WotchiTestAlertStatus, WotchiTraceContext, } from "./core/types.js";
 export type { WebhookRequestFunction, WebhookRequestOptions, WebhookResponse, } from "./notifiers/webhook-http.js";
-export { consoleNotifier, createWotchi, registerWotchiProcessMonitor, telegramNotifier, webhookNotifier, };
+export { consoleNotifier, createWotchi, createWotchiPrometheusExporter, PROMETHEUS_CONTENT_TYPE, registerWotchiProcessMonitor, registerWotchiRuntimeWatcher, telegramNotifier, webhookNotifier, };

package/dist/types/integrations/nest/capture.d.ts

@@ -0,0 +1,4 @@
+import type { ArgumentsHost } from "@nestjs/common";
+import type { WotchiClient } from "../../core/types.js";
+import { type NestWotchiOptions } from "./request-context.js";
+export declare const captureWotchiNestException: (client: WotchiClient, exception: unknown, host: ArgumentsHost, options?: NestWotchiOptions) => void;

package/dist/types/integrations/nest/exception-filter.d.ts

@@ -1,10 +1,14 @@
 import { type ArgumentsHost, type HttpServer } from "@nestjs/common";
 import { BaseExceptionFilter } from "@nestjs/core";
 import type { WotchiClient } from "../../core/types.js";
-import { type NestWotchiOptions } from "./request-context.js";
+import type { NestExceptionFilterLike } from "./filter-wrapper.js";
+import type { NestWotchiOptions } from "./request-context.js";
 export declare class WotchiNestExceptionFilter extends BaseExceptionFilter<unknown> {
     private readonly client;
     private readonly options?;
-    constructor(client: WotchiClient, applicationRef: HttpServer, options?: NestWotchiOptions | undefined);
+    private readonly previousGlobalFilters;
+    constructor(client: WotchiClient, applicationRef?: HttpServer, options?: NestWotchiOptions | undefined, previousGlobalFilters?: readonly NestExceptionFilterLike[]);
     catch(exception: unknown, host: ArgumentsHost): void;
+    private respondWithoutLoggingRawUnknownException;
+    private respondThroughExpressAdapter;
 }

package/dist/types/integrations/nest/filter-wrapper.d.ts

@@ -0,0 +1,7 @@
+import type { ArgumentsHost } from "@nestjs/common";
+import type { WotchiClient } from "../../core/types.js";
+import type { NestWotchiOptions } from "./request-context.js";
+export interface NestExceptionFilterLike {
+    catch(exception: unknown, host: ArgumentsHost): void;
+}
+export declare function withWotchiNestFilter<TFilter extends NestExceptionFilterLike>(client: WotchiClient, filter: TFilter, options?: NestWotchiOptions): TFilter;

package/dist/types/integrations/nest/index.d.ts

@@ -1,5 +1,9 @@
 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";
 export type { ConsoleNotifierOptions, IncidentAlert, IncidentGroup, IncidentSeverity, SafeErrorEvent, TelegramNotifierOptions, WebhookNotifierOptions, WotchiBeforeSend, WotchiCaptureOptions, WotchiClient, WotchiConfig, WotchiDiagnostics, WotchiEventFilter, WotchiEventInput, WotchiFingerprintCallback, WotchiFingerprintOverride, WotchiIncidentRule, WotchiLinkTemplates, WotchiLinks, WotchiNotifier, WotchiRequestContext, WotchiTags, WotchiTestAlertResult, WotchiTestAlertStatus, WotchiTraceContext, } from "../../index.js";
 export type { NestWotchiApplication, NestWotchiOptions } from "./register.js";
+export type { NestExceptionFilterLike } from "./filter-wrapper.js";
+export type { WotchiNestModuleOptions } from "./module.js";
 export type { WotchiStatusClass, WotchiStatusObserverOptions } from "../express/status-observer.js";

package/dist/types/integrations/nest/module.d.ts

@@ -0,0 +1,9 @@
+import { type DynamicModule } from "@nestjs/common";
+import type { WotchiConfig } from "../../core/types.js";
+export declare const WOTCHI_CLIENT: unique symbol;
+export interface WotchiNestModuleOptions {
+    registerGlobalFilter?: boolean;
+}
+export declare class WotchiModule {
+    static forRoot(config: WotchiConfig, options?: WotchiNestModuleOptions): DynamicModule;
+}

package/dist/types/integrations/nest/register.d.ts

@@ -8,6 +8,9 @@ export interface NestWotchiApplication {
     getHttpAdapter?: () => unknown;
     use?: (...middleware: unknown[]) => unknown;
     useGlobalFilters(...filters: unknown[]): unknown;
+    config?: {
+        getGlobalFilters?: () => unknown[];
+    };
 }
 export declare function registerWotchiNest(app: unknown, client: WotchiClient, options?: NestWotchiOptions): void;
 export declare function registerWotchiNestStatusObserver(app: unknown, client: WotchiClient, options?: WotchiStatusObserverOptions): void;

package/dist/types-cjs/core/admission.d.cts

@@ -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-cjs/core/config.d.cts

@@ -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-cjs/core/diagnostics.d.cts

@@ -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-cjs/core/incident-policy.d.cts

@@ -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-cjs/core/limits.d.cts

@@ -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-cjs/core/notification-queue.d.cts

@@ -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-cjs/core/prometheus.d.cts

@@ -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-cjs/core/runtime-monitor.d.cts

@@ -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-cjs/core/types.d.cts

@@ -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>;
 }

package/dist/types-cjs/index.d.cts

@@ -1,11 +1,15 @@
 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 type { ProcessMonitorHandle } from "./core/process-monitor.js";
 export type { NormalizedWotchiConfig } from "./core/config.js";
+export type { WotchiPrometheusExporter } from "./core/prometheus.js";
+export type { WotchiRuntimeWatcherHandle, WotchiRuntimeWatcherOptions, } from "./core/runtime-monitor.js";
 export type { ConsoleNotifierOptions, IncidentAlert, IncidentGroup, IncidentSeverity, SafeErrorEvent, TelegramNotifierOptions, WebhookNotifierOptions, WotchiBeforeSend, WotchiCaptureOptions, WotchiClient, WotchiConfig, WotchiDiagnostics, WotchiEventFilter, WotchiEventInput, WotchiEventKind, WotchiFingerprintOverride, WotchiFingerprintCallback, WotchiIncidentRule, WotchiLinkTemplates, WotchiLinks, WotchiNotifier, WotchiRequestContext, WotchiTags, WotchiTestAlertResult, WotchiTestAlertStatus, WotchiTraceContext, } from "./core/types.js";
 export type { WebhookRequestFunction, WebhookRequestOptions, WebhookResponse, } from "./notifiers/webhook-http.js";
-export { consoleNotifier, createWotchi, registerWotchiProcessMonitor, telegramNotifier, webhookNotifier, };
+export { consoleNotifier, createWotchi, createWotchiPrometheusExporter, PROMETHEUS_CONTENT_TYPE, registerWotchiProcessMonitor, registerWotchiRuntimeWatcher, telegramNotifier, webhookNotifier, };

package/dist/types-cjs/integrations/nest/capture.d.cts

@@ -0,0 +1,4 @@
+import type { ArgumentsHost } from "@nestjs/common";
+import type { WotchiClient } from "../../core/types.js";
+import { type NestWotchiOptions } from "./request-context.js";
+export declare const captureWotchiNestException: (client: WotchiClient, exception: unknown, host: ArgumentsHost, options?: NestWotchiOptions) => void;