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

package/dist/cjs/core/config.js

@@ -4,17 +4,34 @@ exports.WotchiConfigurationError = void 0;
 exports.validateConfig = validateConfig;
 const errors_js_1 = require("./errors.js");
 Object.defineProperty(exports, "WotchiConfigurationError", { enumerable: true, get: function () { return errors_js_1.WotchiConfigurationError; } });
+const limits_js_1 = require("./limits.js");
 const MAX_REDACT_KEYS = 100;
+const MAX_RULES = 50;
+const MAX_RULE_STRING_LENGTH = 200;
+const MAX_LINK_TEMPLATE_LENGTH = 1_000;
+const ALLOWED_LINK_PLACEHOLDERS = new Set([
+    "service",
+    "environment",
+    "release",
+    "instance",
+    "fingerprint",
+    "requestId",
+    "correlationId",
+    "traceId",
+    "spanId",
+    "route",
+    "statusCode",
+]);
 const isRecord = (value) => typeof value === "object" && value !== null;
 const fail = (field) => {
     throw new errors_js_1.WotchiConfigurationError(`${field} is invalid`);
 };
-const readPositiveInteger = (parent, field, defaultValue) => {
+const readPositiveInteger = (parent, field, defaultValue, maximum) => {
     const value = parent?.[field];
     if (value === undefined) {
         return defaultValue;
     }
-    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0 || value > maximum) {
         return fail(field);
     }
     return value;
@@ -28,6 +45,120 @@ const readOptionalRecord = (value, field) => {
     }
     return value;
 };
+const normalizeRuleString = (value, field) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return fail(field);
+    }
+    return value.trim().slice(0, MAX_RULE_STRING_LENGTH);
+};
+const normalizeSeverity = (value, field) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value !== "low" && value !== "medium" && value !== "high" && value !== "critical") {
+        return fail(field);
+    }
+    return value;
+};
+const freezeHook = (hook) => {
+    try {
+        return Object.freeze(hook);
+    }
+    catch {
+        return hook;
+    }
+};
+const normalizeLinks = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isRecord(value)) {
+        return fail("links");
+    }
+    const normalized = {};
+    for (const key of ["log", "trace"]) {
+        const raw = value[key];
+        if (raw === undefined) {
+            continue;
+        }
+        if (typeof raw !== "string" || raw.length === 0 || raw.length > MAX_LINK_TEMPLATE_LENGTH) {
+            return fail(`links.${key}`);
+        }
+        let parsed;
+        try {
+            parsed = new URL(raw.replace(/\{\{[^{}]+\}\}/g, "placeholder"));
+        }
+        catch {
+            return fail(`links.${key}`);
+        }
+        if (parsed.protocol !== "https:" ||
+            parsed.username !== "" ||
+            parsed.password !== "" ||
+            parsed.hash !== "") {
+            return fail(`links.${key}`);
+        }
+        const placeholders = raw.match(/\{\{([^{}]+)\}\}/g) ?? [];
+        if (/[{}]/.test(raw.replace(/\{\{[^{}]+\}\}/g, ""))) {
+            return fail(`links.${key}`);
+        }
+        for (const placeholder of placeholders) {
+            const name = placeholder.slice(2, -2);
+            if (!ALLOWED_LINK_PLACEHOLDERS.has(name)) {
+                return fail(`links.${key}`);
+            }
+        }
+        normalized[key] = raw;
+    }
+    return Object.freeze(normalized);
+};
+const normalizeRules = (value) => {
+    if (value === undefined) {
+        return Object.freeze([]);
+    }
+    if (!Array.isArray(value) || value.length > MAX_RULES) {
+        return fail("rules");
+    }
+    const rules = value.map((rawRule, index) => {
+        if (!isRecord(rawRule)) {
+            return fail(`rules[${index}]`);
+        }
+        const alertThreshold = rawRule.alertThreshold;
+        if (alertThreshold !== undefined &&
+            (typeof alertThreshold !== "number" ||
+                !Number.isSafeInteger(alertThreshold) ||
+                alertThreshold <= 0 ||
+                alertThreshold > 1_000_000)) {
+            return fail(`rules[${index}].alertThreshold`);
+        }
+        if (rawRule.ignore !== undefined && typeof rawRule.ignore !== "boolean") {
+            return fail(`rules[${index}].ignore`);
+        }
+        const environment = normalizeRuleString(rawRule.environment, `rules[${index}].environment`);
+        const route = normalizeRuleString(rawRule.route, `rules[${index}].route`);
+        const severity = normalizeSeverity(rawRule.severity, `rules[${index}].severity`);
+        const rule = {};
+        if (environment !== undefined) {
+            rule.environment = environment;
+        }
+        if (route !== undefined) {
+            rule.route = route;
+        }
+        if (rawRule.ignore !== undefined) {
+            rule.ignore = rawRule.ignore;
+        }
+        if (alertThreshold !== undefined) {
+            rule.alertThreshold = alertThreshold;
+        }
+        if (severity !== undefined) {
+            rule.severity = severity;
+        }
+        return Object.freeze(rule);
+    });
+    return Object.freeze(rules);
+};
 const normalizeRedactKeys = (privacy) => {
     const value = privacy?.redactKeys;
     if (value === undefined) {
@@ -50,11 +181,19 @@ const normalizeNotifiers = (value) => {
     }
     for (let index = 0; index < value.length; index += 1) {
         const notifier = value[index];
-        if (!isRecord(notifier) ||
-            typeof notifier.name !== "string" ||
-            notifier.name.trim().length === 0 ||
-            typeof notifier.send !== "function") {
-            return fail(`notifiers[${index}]`);
+        const valid = (() => {
+            try {
+                return (isRecord(notifier) &&
+                    typeof notifier.name === "string" &&
+                    notifier.name.trim().length > 0 &&
+                    typeof notifier.send === "function");
+            }
+            catch {
+                return false;
+            }
+        })();
+        if (!valid) {
+            return fail("notifiers[" + index + "]");
         }
     }
     return Object.freeze([...value]);
@@ -75,12 +214,26 @@ function validateConfig(config) {
         (typeof config.release !== "string" || config.release.trim().length === 0)) {
         return fail("release");
     }
+    if (config.instance !== undefined &&
+        (typeof config.instance !== "string" || config.instance.trim().length === 0)) {
+        return fail("instance");
+    }
     if (config.enabled !== undefined && typeof config.enabled !== "boolean") {
         return fail("enabled");
     }
+    if (config.filter !== undefined && typeof config.filter !== "function") {
+        return fail("filter");
+    }
+    if (config.fingerprint !== undefined && typeof config.fingerprint !== "function") {
+        return fail("fingerprint");
+    }
+    if (config.beforeSend !== undefined && typeof config.beforeSend !== "function") {
+        return fail("beforeSend");
+    }
     const grouping = readOptionalRecord(config.grouping, "grouping");
     const queue = readOptionalRecord(config.queue, "queue");
     const privacy = readOptionalRecord(config.privacy, "privacy");
+    const links = normalizeLinks(config.links);
     const concurrency = queue?.concurrency;
     if (concurrency !== undefined && concurrency !== 1) {
         return fail("queue.concurrency");
@@ -88,25 +241,31 @@ function validateConfig(config) {
     const normalized = {
         service: service.trim(),
         environment: environment.trim(),
-        ...(config.release === undefined ? {} : { release: config.release.trim() }),
+        ...(config.instance === undefined ? {} : { instance: config.instance.trim().slice(0, 200) }),
+        ...(config.release === undefined ? {} : { release: config.release.trim().slice(0, 200) }),
         enabled: config.enabled ?? true,
+        ...(config.filter === undefined ? {} : { filter: freezeHook(config.filter) }),
+        ...(config.fingerprint === undefined ? {} : { fingerprint: freezeHook(config.fingerprint) }),
+        ...(config.beforeSend === undefined ? {} : { beforeSend: freezeHook(config.beforeSend) }),
+        ...(links === undefined ? {} : { links }),
+        rules: normalizeRules(config.rules),
         grouping: Object.freeze({
-            windowMs: readPositiveInteger(grouping, "windowMs", 60_000),
-            alertThreshold: readPositiveInteger(grouping, "alertThreshold", 3),
-            cooldownMs: readPositiveInteger(grouping, "cooldownMs", 900_000),
-            maxGroups: readPositiveInteger(grouping, "maxGroups", 200),
-            maxEventsPerWindow: readPositiveInteger(grouping, "maxEventsPerWindow", 100),
+            windowMs: readPositiveInteger(grouping, "windowMs", 60_000, limits_js_1.MAX_WINDOW_MS),
+            alertThreshold: readPositiveInteger(grouping, "alertThreshold", 3, limits_js_1.MAX_ALERT_THRESHOLD),
+            cooldownMs: readPositiveInteger(grouping, "cooldownMs", 900_000, limits_js_1.MAX_COOLDOWN_MS),
+            maxGroups: readPositiveInteger(grouping, "maxGroups", 200, limits_js_1.MAX_GROUPS),
+            maxEventsPerWindow: readPositiveInteger(grouping, "maxEventsPerWindow", 100, limits_js_1.MAX_EVENTS_PER_WINDOW),
         }),
         queue: Object.freeze({
-            maxPendingAlerts: readPositiveInteger(queue, "maxPendingAlerts", 100),
+            maxPendingAlerts: readPositiveInteger(queue, "maxPendingAlerts", 100, limits_js_1.MAX_PENDING_ALERTS),
             concurrency: 1,
         }),
         privacy: Object.freeze({
             redactKeys: normalizeRedactKeys(privacy),
-            maxDepth: readPositiveInteger(privacy, "maxDepth", 5),
-            maxKeys: readPositiveInteger(privacy, "maxKeys", 100),
-            maxStringLength: readPositiveInteger(privacy, "maxStringLength", 500),
-            maxStackLength: readPositiveInteger(privacy, "maxStackLength", 4_000),
+            maxDepth: readPositiveInteger(privacy, "maxDepth", 5, limits_js_1.MAX_NORMALIZATION_DEPTH),
+            maxKeys: readPositiveInteger(privacy, "maxKeys", 100, limits_js_1.MAX_NORMALIZATION_KEYS),
+            maxStringLength: readPositiveInteger(privacy, "maxStringLength", 500, limits_js_1.MAX_NORMALIZATION_STRING_LENGTH),
+            maxStackLength: readPositiveInteger(privacy, "maxStackLength", 4_000, limits_js_1.MAX_NORMALIZATION_STACK_LENGTH),
         }),
         notifiers: normalizeNotifiers(config.notifiers),
     };

package/dist/cjs/core/diagnostics.js

@@ -3,12 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDiagnosticsState = createDiagnosticsState;
 exports.snapshotDiagnostics = snapshotDiagnostics;
 function createDiagnosticsState() {
-    return { capturedEvents: 0, captureFailures: 0 };
+    return {
+        capturedEvents: 0,
+        captureFailures: 0,
+        fingerprintCallbackFailures: 0,
+        filterFailures: 0,
+        beforeSendFailures: 0,
+        eventsSuppressed: 0,
+    };
 }
 function snapshotDiagnostics(state, values) {
     return Object.freeze({
         capturedEvents: state.capturedEvents,
         captureFailures: state.captureFailures,
+        fingerprintCallbackFailures: state.fingerprintCallbackFailures,
+        filterFailures: state.filterFailures,
+        beforeSendFailures: state.beforeSendFailures,
+        eventsSuppressed: state.eventsSuppressed,
         ...values,
     });
 }

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createGroupStore = createGroupStore;
 const normalize_js_1 = require("./normalize.js");
+const limits_js_1 = require("./limits.js");
 const rolling_window_js_1 = require("./rolling-window.js");
 const cloneSafeEvent = (event) => {
     const context = event.context === undefined ? undefined : (0, normalize_js_1.normalizeUnknown)(event.context);
@@ -10,16 +11,29 @@ const cloneSafeEvent = (event) => {
         timestamp: event.timestamp,
         service: event.service,
         environment: event.environment,
+        ...(event.instance === undefined ? {} : { instance: event.instance }),
         ...(event.release === undefined ? {} : { release: event.release }),
+        ...(event.correlationId === undefined ? {} : { correlationId: event.correlationId }),
+        ...(event.operation === undefined ? {} : { operation: event.operation }),
+        ...(event.job === undefined ? {} : { job: event.job }),
+        ...(event.tags === undefined ? {} : { tags: { ...event.tags } }),
         error: { ...event.error },
         ...(event.request === undefined ? {} : { request: { ...event.request } }),
+        ...(event.trace === undefined ? {} : { trace: { ...event.trace } }),
         ...(context === undefined ? {} : { context: context }),
     };
 };
 function createGroupStore(options) {
-    if (!Number.isSafeInteger(options.maxGroups) || options.maxGroups <= 0) {
+    if (!Number.isSafeInteger(options.maxGroups) ||
+        options.maxGroups <= 0 ||
+        options.maxGroups > limits_js_1.MAX_GROUPS) {
         throw new RangeError("maxGroups must be a positive integer");
     }
+    if (!Number.isSafeInteger(options.maxEventsPerWindow) ||
+        options.maxEventsPerWindow <= 0 ||
+        options.maxEventsPerWindow > limits_js_1.MAX_EVENTS_PER_WINDOW) {
+        throw new RangeError("maxEventsPerWindow must be a positive integer");
+    }
     const now = options.now ?? Date.now;
     const groups = new Map();
     let evicted = 0;

package/dist/cjs/core/incident-builder.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildIncidentAlert = buildIncidentAlert;
+const stack_frame_js_1 = require("./stack-frame.js");
 const titleCase = (value) => `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
 const suggestedActions = (group) => {
     const text = `${group.sample.error.name} ${group.sample.error.message}`.toLowerCase();
@@ -30,6 +31,11 @@ const suggestedActions = (group) => {
 function buildIncidentAlert(group, decision) {
     const message = group.sample.error.message;
     const errorName = group.sample.error.name;
+    const applicationFrame = (0, stack_frame_js_1.selectApplicationFrame)(group.sample.error.stack);
+    const error = {
+        ...group.sample.error,
+        ...(applicationFrame === undefined ? {} : { applicationFrame }),
+    };
     return {
         id: `wotchi-${group.fingerprint}-${group.lastSeenAt}`,
         fingerprint: group.fingerprint,
@@ -42,5 +48,17 @@ function buildIncidentAlert(group, decision) {
         occurrences: group.windowCount,
         service: group.sample.service,
         environment: group.sample.environment,
+        ...(group.sample.instance === undefined ? {} : { instance: group.sample.instance }),
+        ...(group.sample.release === undefined ? {} : { release: group.sample.release }),
+        ...(group.sample.correlationId === undefined
+            ? {}
+            : { correlationId: group.sample.correlationId }),
+        ...(group.sample.operation === undefined ? {} : { operation: group.sample.operation }),
+        ...(group.sample.job === undefined ? {} : { job: group.sample.job }),
+        ...(group.sample.tags === undefined ? {} : { tags: group.sample.tags }),
+        error,
+        ...(group.sample.request === undefined ? {} : { request: group.sample.request }),
+        ...(group.sample.trace === undefined ? {} : { trace: group.sample.trace }),
+        ...(group.sample.context === undefined ? {} : { context: group.sample.context }),
     };
 }

package/dist/cjs/core/incident-policy.js

@@ -13,13 +13,8 @@ function evaluateIncidentPolicy(input) {
     const eventKind = input.eventKind ?? "error";
     const isCritical = eventKind === "process-monitor";
     const isHigh = input.group.windowCount >= 20 || hasUnavailableResponse(input.group);
-    const severity = isCritical
-        ? "critical"
-        : isHigh
-            ? "high"
-            : eventKind === "manual"
-                ? (input.manualSeverity ?? "low")
-                : "medium";
+    const severity = input.manualSeverity ??
+        (isCritical ? "critical" : isHigh ? "high" : eventKind === "manual" ? "low" : "medium");
     const eligible = isCritical ||
         isHigh ||
         eventKind === "manual" ||

package/dist/cjs/core/limits.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_NORMALIZATION_STACK_LENGTH = exports.MAX_NORMALIZATION_STRING_LENGTH = exports.MAX_NORMALIZATION_KEYS = exports.MAX_NORMALIZATION_DEPTH = exports.MAX_COOLDOWN_MS = exports.MAX_ALERT_THRESHOLD = exports.MAX_WINDOW_MS = exports.MAX_PENDING_ALERTS = exports.MAX_EVENTS_PER_WINDOW = exports.MAX_GROUPS = void 0;
+exports.MAX_GROUPS = 10_000;
+exports.MAX_EVENTS_PER_WINDOW = 10_000;
+exports.MAX_PENDING_ALERTS = 10_000;
+exports.MAX_WINDOW_MS = 7 * 24 * 60 * 60 * 1_000;
+exports.MAX_ALERT_THRESHOLD = 1_000_000;
+exports.MAX_COOLDOWN_MS = 30 * 24 * 60 * 60 * 1_000;
+exports.MAX_NORMALIZATION_DEPTH = 20;
+exports.MAX_NORMALIZATION_KEYS = 10_000;
+exports.MAX_NORMALIZATION_STRING_LENGTH = 32_768;
+exports.MAX_NORMALIZATION_STACK_LENGTH = 32_768;

package/dist/cjs/core/normalize.js

@@ -6,18 +6,19 @@ const UNREADABLE_VALUE = "[unreadable value]";
 const MAX_DEPTH_VALUE = "[MaxDepth]";
 const CIRCULAR_VALUE = "[Circular]";
 const MAX_KEYS_VALUE = "[MaxKeys]";
+const UNSAFE_OBJECT_KEYS = new Set(["__proto__", "prototype", "constructor"]);
 const defaultLimits = {
     maxDepth: 5,
     maxKeys: 100,
     maxStringLength: 500,
     maxStackLength: 4_000,
 };
-const boundedLimit = (value, fallback) => Number.isSafeInteger(value) && value > 0 ? value : fallback;
+const boundedLimit = (value, fallback, maximum) => Number.isSafeInteger(value) && value > 0 && value <= maximum ? value : fallback;
 const normalizeLimits = (limits) => ({
-    maxDepth: boundedLimit(limits?.maxDepth ?? defaultLimits.maxDepth, defaultLimits.maxDepth),
-    maxKeys: boundedLimit(limits?.maxKeys ?? defaultLimits.maxKeys, defaultLimits.maxKeys),
-    maxStringLength: boundedLimit(limits?.maxStringLength ?? defaultLimits.maxStringLength, defaultLimits.maxStringLength),
-    maxStackLength: boundedLimit(limits?.maxStackLength ?? defaultLimits.maxStackLength, defaultLimits.maxStackLength),
+    maxDepth: boundedLimit(limits?.maxDepth ?? defaultLimits.maxDepth, defaultLimits.maxDepth, limits_js_1.MAX_NORMALIZATION_DEPTH),
+    maxKeys: boundedLimit(limits?.maxKeys ?? defaultLimits.maxKeys, defaultLimits.maxKeys, limits_js_1.MAX_NORMALIZATION_KEYS),
+    maxStringLength: boundedLimit(limits?.maxStringLength ?? defaultLimits.maxStringLength, defaultLimits.maxStringLength, limits_js_1.MAX_NORMALIZATION_STRING_LENGTH),
+    maxStackLength: boundedLimit(limits?.maxStackLength ?? defaultLimits.maxStackLength, defaultLimits.maxStackLength, limits_js_1.MAX_NORMALIZATION_STACK_LENGTH),
 });
 const truncate = (value, limit) => value.slice(0, limit);
 const readProperty = (value, key) => {
@@ -89,6 +90,9 @@ const normalizeValue = (value, depth, state, limits) => {
     }
     const result = {};
     for (const key of keys) {
+        if (UNSAFE_OBJECT_KEYS.has(key)) {
+            continue;
+        }
         if (state.keysVisited >= limits.maxKeys - 1) {
             result["[truncated]"] = MAX_KEYS_VALUE;
             break;
@@ -136,3 +140,4 @@ function normalizeError(error, limits) {
     const message = typeof normalized === "string" ? normalized : UNREADABLE_VALUE;
     return { name: "UnknownError", message };
 }
+const limits_js_1 = require("./limits.js");

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

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNotificationQueue = createNotificationQueue;
+const limits_js_1 = require("./limits.js");
 const DEFAULT_FLUSH_TIMEOUT_MS = 5_000;
 function createNotificationQueue(options) {
-    if (!Number.isSafeInteger(options.maxPendingAlerts) || options.maxPendingAlerts <= 0) {
+    if (!Number.isSafeInteger(options.maxPendingAlerts) ||
+        options.maxPendingAlerts <= 0 ||
+        options.maxPendingAlerts > limits_js_1.MAX_PENDING_ALERTS) {
         throw new RangeError("maxPendingAlerts must be a positive integer");
     }
     if (options.concurrency !== 1) {
@@ -35,15 +38,25 @@ function createNotificationQueue(options) {
         resolveDrain = undefined;
     };
     const processJob = async (job) => {
+        let jobSent = 0;
+        let jobFailures = 0;
         for (const notifier of job.notifiers) {
             try {
                 await notifier.send(job.alert);
                 sent += 1;
+                jobSent += 1;
             }
             catch (error) {
+                jobFailures += 1;
                 notifyFailure(error, notifier);
             }
         }
+        try {
+            job.onComplete?.({ notifierFailures: jobFailures, sent: jobSent });
+        }
+        catch {
+            // Job observers cannot be allowed to affect notification processing.
+        }
     };
     const pump = () => {
         while (activeJobs < options.concurrency && pendingJobs.length > 0) {
@@ -59,12 +72,16 @@ function createNotificationQueue(options) {
             });
         }
     };
-    const enqueue = (alert, notifiers) => {
+    const enqueue = (alert, notifiers, onComplete) => {
         if (pendingJobs.length >= options.maxPendingAlerts) {
             dropped += 1;
             return false;
         }
-        pendingJobs.push({ alert, notifiers: [...notifiers] });
+        pendingJobs.push({
+            alert,
+            notifiers: [...notifiers],
+            ...(onComplete === undefined ? {} : { onComplete }),
+        });
         queued += 1;
         pump();
         return true;

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) => {
@@ -77,11 +88,44 @@ const redactConnectionUrl = (candidate) => {
     return `${core.slice(0, authorityStart)}${redactedAuthority}${remainder}${suffix}`;
 };
 const redactConnectionUrls = (value) => value.replace(CONNECTION_URL_PATTERN, redactConnectionUrl);
+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 = 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}`;
     });
@@ -90,7 +134,9 @@ const redactString = (value, maxStringLength) => {
     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 +174,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/index.js

@@ -1,6 +1,6 @@
 "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.registerWotchiProcessMonitor = 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");
@@ -9,5 +9,7 @@ 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

@@ -7,7 +7,8 @@ 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));
+            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.

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, []),