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

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

@@ -1,4 +1,5 @@
 import { normalizeUnknown } from "./normalize.js";
+import { MAX_NORMALIZATION_DEPTH, MAX_NORMALIZATION_KEYS, MAX_NORMALIZATION_STACK_LENGTH, MAX_NORMALIZATION_STRING_LENGTH, } from "./limits.js";
 export const REDACTED = "[REDACTED]";
 const DEFAULT_KEYS = [
     "authorization",
@@ -9,6 +10,12 @@ const DEFAULT_KEYS = [
     "secret",
     "apiKey",
     "api_key",
+    "xApiKey",
+    "x_api_key",
+    "dbPassword",
+    "db_password",
+    "databasePassword",
+    "database_password",
     "token",
     "accessToken",
     "access_token",
@@ -18,12 +25,16 @@ const DEFAULT_KEYS = [
     "private_key",
     "clientSecret",
     "client_secret",
+    "signature",
+    "session",
+    "webhookSecret",
+    "webhook_secret",
     "cardNumber",
     "cvv",
     "cvc",
     "pin",
 ];
-const normalizeKey = (key) => key.toLowerCase().replace(/[-_]/g, "");
+const normalizeKey = (key) => key.toLowerCase().replace(/[^a-z0-9]/g, "");
 const defaultKeySet = new Set(DEFAULT_KEYS.map(normalizeKey));
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const luhnValid = (digits) => {
@@ -49,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 = "";
@@ -72,20 +84,57 @@ 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",
+    "password",
+    "passwd",
+    "secret",
+    "signature",
+    "token",
+    "accesstoken",
+    "refreshtoken",
+    "apikey",
+    "xapikey",
+    "session",
+]);
+const decodeQueryKey = (value) => {
+    try {
+        return decodeURIComponent(value.replace(/\+/g, " "));
+    }
+    catch {
+        return value;
+    }
+};
+const redactSensitiveQueryValues = (value) => value.replace(/([?&])([^=&#\s]+)=([^&#\s]*)/g, (match, prefix, key) => {
+    if (!SENSITIVE_QUERY_KEYS.has(normalizeKey(decodeQueryKey(key)))) {
+        return match;
+    }
+    return prefix + key + "=" + REDACTED;
+});
+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);
     result = result.replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, `Bearer ${REDACTED}`);
-    result = result.replace(/\b(?:authorization|password|passwd|secret|token|api[-_]?key)\s*[:=]\s*[^\s,;]+/gi, (match) => {
+    result = result.replace(/\bBasic\s+[A-Za-z0-9+/=]+/gi, `Basic ${REDACTED}`);
+    result = result.replace(/\b(?:Cookie|Set-Cookie)\s*:\s*[^\r\n]+/gi, "Cookie: [REDACTED]");
+    result = result.replace(/\b(?:authorization|password|passwd|secret|signature|session|token|x[-_]?api[-_]?key|db[-_]?password|database[-_]?password|api[-_]?key)\s*[:=]\s*[^\s,;]+/gi, (match) => {
         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);
 };
-const normalizedOption = (value, fallback) => Number.isSafeInteger(value) && value !== undefined && value > 0 ? value : fallback;
+const normalizedOption = (value, fallback, maximum) => Number.isSafeInteger(value) && value !== undefined && value > 0 && value <= maximum
+    ? value
+    : fallback;
 const redactNormalized = (value, sensitiveKeys, options, depth, keysVisited) => {
     if (typeof value === "string") {
         return redactString(value, options.maxStringLength);
@@ -123,10 +172,10 @@ const redactNormalized = (value, sensitiveKeys, options, depth, keysVisited) =>
     return result;
 };
 const redactionLimits = (options) => ({
-    maxDepth: normalizedOption(options.maxDepth, 5),
-    maxKeys: normalizedOption(options.maxKeys, 100),
-    maxStringLength: normalizedOption(options.maxStringLength, 500),
-    maxStackLength: normalizedOption(options.maxStackLength, 4_000),
+    maxDepth: normalizedOption(options.maxDepth, 5, MAX_NORMALIZATION_DEPTH),
+    maxKeys: normalizedOption(options.maxKeys, 100, MAX_NORMALIZATION_KEYS),
+    maxStringLength: normalizedOption(options.maxStringLength, 500, MAX_NORMALIZATION_STRING_LENGTH),
+    maxStackLength: normalizedOption(options.maxStackLength, 4_000, MAX_NORMALIZATION_STACK_LENGTH),
 });
 const sensitiveKeySet = (options) => {
     const keys = new Set(defaultKeySet);

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,6 +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 };
+export { consoleNotifier, createWotchi, createWotchiPrometheusExporter, PROMETHEUS_CONTENT_TYPE, registerWotchiProcessMonitor, registerWotchiRuntimeWatcher, telegramNotifier, webhookNotifier, };

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

@@ -3,11 +3,28 @@ import { markExpressErrorCaptured } from "./state.js";
 export function createExpressErrorHandler(client, options) {
     return (error, request, response, next) => {
         markExpressErrorCaptured(request);
-        try {
-            client.captureException(error, getExpressRequestContext(request, response, options));
+        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);
     };

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

@@ -1,5 +1,5 @@
 import { createExpressErrorHandler } from "./error-handler.js";
-export { consoleNotifier, createWotchi, telegramNotifier } from "../../index.js";
+export { consoleNotifier, createWotchi, telegramNotifier, webhookNotifier } from "../../index.js";
 export { wotchiStatusObserver } from "./status-observer.js";
 export function wotchiErrorHandler(client, options) {
     return createExpressErrorHandler(client, options);

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

@@ -39,6 +39,12 @@ const normalizeOptions = (options) => {
         ...(options?.requestIdProperty === undefined
             ? {}
             : { requestIdProperty: options.requestIdProperty }),
+        ...(options?.correlationIdProperty === undefined
+            ? {}
+            : { correlationIdProperty: options.correlationIdProperty }),
+        ...(options?.traceContextProperty === undefined
+            ? {}
+            : { traceContextProperty: options.traceContextProperty }),
         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,27 +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 { 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 {
-            this.client.captureException(exception, getNestRequestContext(host, exception, this.options));
+        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;
+        }
+        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;
+        }
+        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 } from "../../index.js";
+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;