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

package/dist/cjs/core/prometheus.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMETHEUS_CONTENT_TYPE = void 0;
+exports.createWotchiPrometheusExporter = createWotchiPrometheusExporter;
+exports.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");
+};
+function createWotchiPrometheusExporter(client) {
+    return Object.freeze({
+        contentType: exports.PROMETHEUS_CONTENT_TYPE,
+        render: () => renderMetrics(client.getDiagnostics()),
+    });
+}

package/dist/cjs/core/redact.js

@@ -4,6 +4,7 @@ exports.REDACTED = void 0;
 exports.redactValue = redactValue;
 exports.redactError = redactError;
 const normalize_js_1 = require("./normalize.js");
+const limits_js_1 = require("./limits.js");
 exports.REDACTED = "[REDACTED]";
 const DEFAULT_KEYS = [
     "authorization",
@@ -14,6 +15,12 @@ const DEFAULT_KEYS = [
     "secret",
     "apiKey",
     "api_key",
+    "xApiKey",
+    "x_api_key",
+    "dbPassword",
+    "db_password",
+    "databasePassword",
+    "database_password",
     "token",
     "accessToken",
     "access_token",
@@ -23,12 +30,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) => {
@@ -54,6 +65,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 = "";
@@ -77,20 +89,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, `${exports.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 + "=" + exports.REDACTED;
+});
+const redactWebhookPathSecrets = (value) => value.replace(/(https?:\/\/[^/\s]+\/(?:services|hooks|webhooks?)\/)[^/?#\s]+/gi, (_match, prefix) => prefix + exports.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, exports.REDACTED);
     result = result.replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, `Bearer ${exports.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 ${exports.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 ? exports.REDACTED : `${match.slice(0, separatorIndex + 1)}${exports.REDACTED}`;
     });
-    result = result.replace(/\b[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, exports.REDACTED);
+    result = result.replace(/\b[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, exports.REDACTED);
     result = result.replace(/\b(?:github_pat|ghp|xox[baprs]-|sk|pk|AKIA)[A-Za-z0-9_-]{8,}\b/gi, exports.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);
@@ -128,10 +177,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, limits_js_1.MAX_NORMALIZATION_DEPTH),
+    maxKeys: normalizedOption(options.maxKeys, 100, limits_js_1.MAX_NORMALIZATION_KEYS),
+    maxStringLength: normalizedOption(options.maxStringLength, 500, limits_js_1.MAX_NORMALIZATION_STRING_LENGTH),
+    maxStackLength: normalizedOption(options.maxStackLength, 4_000, limits_js_1.MAX_NORMALIZATION_STACK_LENGTH),
 });
 const sensitiveKeySet = (options) => {
     const keys = new Set(defaultKeySet);

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

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWotchiRuntimeWatcher = registerWotchiRuntimeWatcher;
+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;
+};
+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/cjs/index.js

@@ -1,13 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.telegramNotifier = exports.registerWotchiProcessMonitor = exports.createWotchi = exports.consoleNotifier = exports.WotchiConfigurationError = void 0;
+exports.webhookNotifier = exports.telegramNotifier = exports.registerWotchiRuntimeWatcher = exports.registerWotchiProcessMonitor = exports.PROMETHEUS_CONTENT_TYPE = exports.createWotchiPrometheusExporter = exports.createWotchi = exports.consoleNotifier = exports.WotchiConfigurationError = void 0;
 const client_js_1 = require("./core/client.js");
 Object.defineProperty(exports, "createWotchi", { enumerable: true, get: function () { return client_js_1.createWotchi; } });
 const process_monitor_js_1 = require("./core/process-monitor.js");
 Object.defineProperty(exports, "registerWotchiProcessMonitor", { enumerable: true, get: function () { return process_monitor_js_1.registerWotchiProcessMonitor; } });
+const prometheus_js_1 = require("./core/prometheus.js");
+Object.defineProperty(exports, "createWotchiPrometheusExporter", { enumerable: true, get: function () { return prometheus_js_1.createWotchiPrometheusExporter; } });
+Object.defineProperty(exports, "PROMETHEUS_CONTENT_TYPE", { enumerable: true, get: function () { return prometheus_js_1.PROMETHEUS_CONTENT_TYPE; } });
+const runtime_monitor_js_1 = require("./core/runtime-monitor.js");
+Object.defineProperty(exports, "registerWotchiRuntimeWatcher", { enumerable: true, get: function () { return runtime_monitor_js_1.registerWotchiRuntimeWatcher; } });
 const console_js_1 = require("./notifiers/console.js");
 Object.defineProperty(exports, "consoleNotifier", { enumerable: true, get: function () { return console_js_1.consoleNotifier; } });
 const telegram_js_1 = require("./notifiers/telegram.js");
 Object.defineProperty(exports, "telegramNotifier", { enumerable: true, get: function () { return telegram_js_1.telegramNotifier; } });
+const webhook_js_1 = require("./notifiers/webhook.js");
+Object.defineProperty(exports, "webhookNotifier", { enumerable: true, get: function () { return webhook_js_1.webhookNotifier; } });
 var errors_js_1 = require("./core/errors.js");
 Object.defineProperty(exports, "WotchiConfigurationError", { enumerable: true, get: function () { return errors_js_1.WotchiConfigurationError; } });

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

@@ -6,11 +6,28 @@ const state_js_1 = require("./state.js");
 function createExpressErrorHandler(client, options) {
     return (error, request, response, next) => {
         (0, state_js_1.markExpressErrorCaptured)(request);
-        try {
-            client.captureException(error, (0, request_context_js_1.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 = (0, request_context_js_1.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/cjs/integrations/express/index.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wotchiStatusObserver = exports.telegramNotifier = exports.createWotchi = exports.consoleNotifier = void 0;
+exports.wotchiStatusObserver = exports.webhookNotifier = exports.telegramNotifier = exports.createWotchi = exports.consoleNotifier = void 0;
 exports.wotchiErrorHandler = wotchiErrorHandler;
 const error_handler_js_1 = require("./error-handler.js");
 var index_js_1 = require("../../index.js");
 Object.defineProperty(exports, "consoleNotifier", { enumerable: true, get: function () { return index_js_1.consoleNotifier; } });
 Object.defineProperty(exports, "createWotchi", { enumerable: true, get: function () { return index_js_1.createWotchi; } });
 Object.defineProperty(exports, "telegramNotifier", { enumerable: true, get: function () { return index_js_1.telegramNotifier; } });
+Object.defineProperty(exports, "webhookNotifier", { enumerable: true, get: function () { return index_js_1.webhookNotifier; } });
 var status_observer_js_1 = require("./status-observer.js");
 Object.defineProperty(exports, "wotchiStatusObserver", { enumerable: true, get: function () { return status_observer_js_1.wotchiStatusObserver; } });
 function wotchiErrorHandler(client, options) {

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

@@ -42,6 +42,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/cjs/integrations/nest/capture.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureWotchiNestException = void 0;
+const state_js_1 = require("../express/state.js");
+const request_context_js_1 = require("./request-context.js");
+const captureWotchiNestException = (client, exception, host, options) => {
+    try {
+        (0, state_js_1.markExpressErrorCaptured)(host.switchToHttp().getRequest());
+    }
+    catch {
+        // Non-HTTP NestJS contexts do not expose an Express request to mark.
+    }
+    try {
+        const requestContext = (0, request_context_js_1.getNestRequestContext)(host, exception, options);
+        client.captureException(exception, undefined, requestContext === undefined ? undefined : { request: requestContext });
+    }
+    catch {
+        // A capture failure must never change NestJS exception handling.
+    }
+};
+exports.captureWotchiNestException = captureWotchiNestException;

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

@@ -12,25 +12,81 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WotchiNestExceptionFilter = void 0;
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
-const request_context_js_1 = require("./request-context.js");
+const capture_js_1 = require("./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 core_1.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, (0, request_context_js_1.getNestRequestContext)(host, exception, this.options));
+        (0, capture_js_1.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 common_1.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 common_1.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" });
     }
 };
 exports.WotchiNestExceptionFilter = WotchiNestExceptionFilter;
 exports.WotchiNestExceptionFilter = WotchiNestExceptionFilter = __decorate([
     (0, common_1.Catch)(),
-    __metadata("design:paramtypes", [Object, Object, Object])
+    __metadata("design:paramtypes", [Object, Object, Object, Array])
 ], WotchiNestExceptionFilter);

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withWotchiNestFilter = withWotchiNestFilter;
+const capture_js_1 = require("./capture.js");
+function withWotchiNestFilter(client, filter, options) {
+    const wrapped = Object.create(filter);
+    Object.defineProperty(wrapped, "catch", {
+        configurable: false,
+        enumerable: false,
+        value: (exception, host) => {
+            (0, capture_js_1.captureWotchiNestException)(client, exception, host, options);
+            filter.catch(exception, host);
+        },
+        writable: false,
+    });
+    return wrapped;
+}

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

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerWotchiNestStatusObserver = exports.registerWotchiNest = exports.telegramNotifier = exports.createWotchi = exports.consoleNotifier = void 0;
+exports.registerWotchiNestStatusObserver = exports.registerWotchiNest = exports.WOTCHI_CLIENT = exports.WotchiModule = exports.withWotchiNestFilter = exports.webhookNotifier = exports.telegramNotifier = exports.createWotchi = exports.consoleNotifier = void 0;
 var index_js_1 = require("../../index.js");
 Object.defineProperty(exports, "consoleNotifier", { enumerable: true, get: function () { return index_js_1.consoleNotifier; } });
 Object.defineProperty(exports, "createWotchi", { enumerable: true, get: function () { return index_js_1.createWotchi; } });
 Object.defineProperty(exports, "telegramNotifier", { enumerable: true, get: function () { return index_js_1.telegramNotifier; } });
+Object.defineProperty(exports, "webhookNotifier", { enumerable: true, get: function () { return index_js_1.webhookNotifier; } });
+var filter_wrapper_js_1 = require("./filter-wrapper.js");
+Object.defineProperty(exports, "withWotchiNestFilter", { enumerable: true, get: function () { return filter_wrapper_js_1.withWotchiNestFilter; } });
+var module_js_1 = require("./module.js");
+Object.defineProperty(exports, "WotchiModule", { enumerable: true, get: function () { return module_js_1.WotchiModule; } });
+Object.defineProperty(exports, "WOTCHI_CLIENT", { enumerable: true, get: function () { return module_js_1.WOTCHI_CLIENT; } });
 var register_js_1 = require("./register.js");
 Object.defineProperty(exports, "registerWotchiNest", { enumerable: true, get: function () { return register_js_1.registerWotchiNest; } });
 Object.defineProperty(exports, "registerWotchiNestStatusObserver", { enumerable: true, get: function () { return register_js_1.registerWotchiNestStatusObserver; } });

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

@@ -0,0 +1,44 @@
+"use strict";
+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;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WotchiModule = exports.WOTCHI_CLIENT = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const client_js_1 = require("../../core/client.js");
+const exception_filter_js_1 = require("./exception-filter.js");
+exports.WOTCHI_CLIENT = Symbol("@futurewindai/wotchi/client");
+let WotchiModule = WotchiModule_1 = class WotchiModule {
+    static forRoot(config, options) {
+        const registerGlobalFilter = options?.registerGlobalFilter ?? true;
+        const providers = [
+            {
+                provide: exports.WOTCHI_CLIENT,
+                useFactory: () => (0, client_js_1.createWotchi)(config),
+            },
+        ];
+        if (registerGlobalFilter) {
+            providers.push({
+                provide: core_1.APP_FILTER,
+                useFactory: (client) => new exception_filter_js_1.WotchiNestExceptionFilter(client),
+                inject: [exports.WOTCHI_CLIENT],
+            });
+        }
+        return {
+            module: WotchiModule_1,
+            global: true,
+            providers,
+            exports: [exports.WOTCHI_CLIENT],
+        };
+    }
+};
+exports.WotchiModule = WotchiModule;
+exports.WotchiModule = WotchiModule = WotchiModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], WotchiModule);