@futurewindai/wotchi 0.1.0-beta.1

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

@@ -0,0 +1,100 @@
+const DEFAULT_FLUSH_TIMEOUT_MS = 5_000;
+export function createNotificationQueue(options) {
+    if (!Number.isSafeInteger(options.maxPendingAlerts) || options.maxPendingAlerts <= 0) {
+        throw new RangeError("maxPendingAlerts must be a positive integer");
+    }
+    if (options.concurrency !== 1) {
+        throw new RangeError("concurrency must be 1");
+    }
+    const pendingJobs = [];
+    let drainPromise;
+    let resolveDrain;
+    let activeJobs = 0;
+    let queued = 0;
+    let dropped = 0;
+    let sent = 0;
+    let failures = 0;
+    const notifyFailure = (error, notifier) => {
+        failures += 1;
+        try {
+            options.onNotifierError?.(error, notifier);
+        }
+        catch {
+            // Diagnostics callbacks cannot be allowed to affect the host application.
+        }
+    };
+    const resolveDrainWaiters = () => {
+        if (activeJobs !== 0 || pendingJobs.length !== 0) {
+            return;
+        }
+        resolveDrain?.();
+        drainPromise = undefined;
+        resolveDrain = undefined;
+    };
+    const processJob = async (job) => {
+        for (const notifier of job.notifiers) {
+            try {
+                await notifier.send(job.alert);
+                sent += 1;
+            }
+            catch (error) {
+                notifyFailure(error, notifier);
+            }
+        }
+    };
+    const pump = () => {
+        while (activeJobs < options.concurrency && pendingJobs.length > 0) {
+            const job = pendingJobs.shift();
+            if (job === undefined) {
+                break;
+            }
+            activeJobs += 1;
+            void processJob(job).finally(() => {
+                activeJobs -= 1;
+                pump();
+                resolveDrainWaiters();
+            });
+        }
+    };
+    const enqueue = (alert, notifiers) => {
+        if (pendingJobs.length >= options.maxPendingAlerts) {
+            dropped += 1;
+            return false;
+        }
+        pendingJobs.push({ alert, notifiers: [...notifiers] });
+        queued += 1;
+        pump();
+        return true;
+    };
+    const flush = (timeoutMs = DEFAULT_FLUSH_TIMEOUT_MS) => {
+        if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) {
+            return Promise.reject(new RangeError("timeoutMs must be a positive integer"));
+        }
+        if (activeJobs === 0 && pendingJobs.length === 0) {
+            return Promise.resolve();
+        }
+        const drain = drainPromise ??
+            new Promise((resolve) => {
+                resolveDrain = resolve;
+            });
+        drainPromise = drain;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`Wotchi notification queue flush timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            void drain.then(() => {
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+    };
+    return {
+        enqueue,
+        flush,
+        pending: () => pendingJobs.length,
+        alertsQueued: () => queued,
+        alertsDropped: () => dropped,
+        alertsSent: () => sent,
+        notifierFailures: () => failures,
+    };
+}

package/dist/esm/core/process-monitor.js

@@ -0,0 +1,27 @@
+export function registerWotchiProcessMonitor(client) {
+    const listener = (error, origin) => {
+        try {
+            client.captureEvent({
+                level: "error",
+                kind: "process-monitor",
+                message: "Uncaught process exception",
+                error,
+                context: { processOrigin: origin },
+            });
+        }
+        catch {
+            // Process monitoring must never alter the host process crash behavior.
+        }
+    };
+    globalThis.process.on("uncaughtExceptionMonitor", listener);
+    let registered = true;
+    return {
+        unregister() {
+            if (!registered) {
+                return;
+            }
+            registered = false;
+            globalThis.process.off("uncaughtExceptionMonitor", listener);
+        },
+    };
+}

package/dist/esm/core/redact.js

@@ -0,0 +1,136 @@
+import { normalizeUnknown } from "./normalize.js";
+export const REDACTED = "[REDACTED]";
+const DEFAULT_KEYS = [
+    "authorization",
+    "cookie",
+    "set-cookie",
+    "password",
+    "passwd",
+    "secret",
+    "apiKey",
+    "api_key",
+    "token",
+    "accessToken",
+    "access_token",
+    "refreshToken",
+    "refresh_token",
+    "privateKey",
+    "private_key",
+    "clientSecret",
+    "client_secret",
+    "cardNumber",
+    "cvv",
+    "cvc",
+    "pin",
+];
+const normalizeKey = (key) => key.toLowerCase().replace(/[-_]/g, "");
+const defaultKeySet = new Set(DEFAULT_KEYS.map(normalizeKey));
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const luhnValid = (digits) => {
+    let sum = 0;
+    let double = false;
+    for (let index = digits.length - 1; index >= 0; index -= 1) {
+        let digit = Number(digits[index]);
+        if (double) {
+            digit *= 2;
+            if (digit > 9) {
+                digit -= 9;
+            }
+        }
+        sum += digit;
+        double = !double;
+    }
+    return sum % 10 === 0;
+};
+const redactCardLikeValues = (value) => value.replace(/\b\d[\d -]{11,25}\d\b/g, (candidate) => {
+    const digits = candidate.replace(/[ -]/g, "");
+    return digits.length >= 13 && digits.length <= 19 && luhnValid(digits) ? REDACTED : candidate;
+});
+const redactString = (value, maxStringLength) => {
+    let result = value;
+    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) => `${match.slice(0, match.search(/[:=]/))}: ${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(?: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 redactNormalized = (value, sensitiveKeys, options, depth, keysVisited) => {
+    if (typeof value === "string") {
+        return redactString(value, options.maxStringLength);
+    }
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    if (depth >= options.maxDepth) {
+        return "[MaxDepth]";
+    }
+    if (Array.isArray(value)) {
+        const result = [];
+        for (const item of value) {
+            if (keysVisited.value >= options.maxKeys) {
+                break;
+            }
+            keysVisited.value += 1;
+            result.push(redactNormalized(item, sensitiveKeys, options, depth + 1, keysVisited));
+        }
+        return result;
+    }
+    const result = {};
+    for (const [key, child] of Object.entries(value)) {
+        if (keysVisited.value >= options.maxKeys) {
+            break;
+        }
+        keysVisited.value += 1;
+        const normalizedKey = normalizeKey(key);
+        result[key] = sensitiveKeys.has(normalizedKey)
+            ? REDACTED
+            : typeof child === "string" && normalizedKey === "stack"
+                ? redactString(child, options.maxStackLength)
+                : redactNormalized(child, sensitiveKeys, options, depth + 1, 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),
+});
+const sensitiveKeySet = (options) => {
+    const keys = new Set(defaultKeySet);
+    for (const key of options.redactKeys ?? []) {
+        if (typeof key === "string" && key.trim().length > 0) {
+            keys.add(normalizeKey(key.trim()));
+        }
+    }
+    return keys;
+};
+export function redactValue(value, options = {}) {
+    const limits = redactionLimits(options);
+    const normalized = normalizeUnknown(value, {
+        maxDepth: limits.maxDepth,
+        maxKeys: limits.maxKeys,
+        maxStringLength: limits.maxStringLength,
+        maxStackLength: limits.maxStackLength,
+    });
+    return redactNormalized(normalized, sensitiveKeySet(options), limits, 0, { value: 0 });
+}
+export function redactError(error, options = {}) {
+    const redacted = redactValue(error, options);
+    if (!isRecord(redacted)) {
+        return { name: "UnknownError", message: REDACTED };
+    }
+    const name = typeof redacted.name === "string" ? redacted.name : "UnknownError";
+    const message = typeof redacted.message === "string" ? redacted.message : REDACTED;
+    const stack = typeof redacted.stack === "string" ? redacted.stack : undefined;
+    const code = typeof redacted.code === "string" ? redacted.code : undefined;
+    return {
+        name,
+        message,
+        ...(stack === undefined ? {} : { stack }),
+        ...(code === undefined ? {} : { code }),
+    };
+}

package/dist/esm/core/rolling-window.js

@@ -0,0 +1,57 @@
+export function createRollingWindow(options) {
+    if (!Number.isSafeInteger(options.maxEvents) || options.maxEvents <= 0) {
+        throw new RangeError("maxEvents must be a positive integer");
+    }
+    if (!Number.isSafeInteger(options.windowMs) || options.windowMs <= 0) {
+        throw new RangeError("windowMs must be a positive integer");
+    }
+    const now = options.now ?? Date.now;
+    const buffer = new Array(options.maxEvents);
+    let head = 0;
+    let length = 0;
+    const readNow = (timestamp) => {
+        const value = timestamp ?? now();
+        return Number.isFinite(value) ? value : now();
+    };
+    const purge = (timestamp) => {
+        while (length > 0) {
+            const oldest = buffer[head];
+            if (oldest === undefined || timestamp - oldest < options.windowMs) {
+                break;
+            }
+            buffer[head] = undefined;
+            head = (head + 1) % options.maxEvents;
+            length -= 1;
+        }
+    };
+    const add = (timestamp) => {
+        const value = readNow(timestamp);
+        purge(value);
+        const index = (head + length) % options.maxEvents;
+        if (length === options.maxEvents) {
+            buffer[head] = undefined;
+            head = (head + 1) % options.maxEvents;
+            length -= 1;
+        }
+        buffer[index] = value;
+        length += 1;
+    };
+    const timestamps = (timestamp) => {
+        const value = readNow(timestamp);
+        purge(value);
+        const result = [];
+        for (let index = 0; index < length; index += 1) {
+            const entry = buffer[(head + index) % options.maxEvents];
+            if (entry !== undefined) {
+                result.push(entry);
+            }
+        }
+        return result;
+    };
+    return {
+        add,
+        count: (timestamp) => timestamps(timestamp).length,
+        size: (timestamp) => timestamps(timestamp).length,
+        timestamps,
+    };
+}

package/dist/esm/core/stack-frame.js

@@ -0,0 +1,29 @@
+const INTERNAL_MARKERS = ["node_modules/", "node:internal/", "internal/"];
+const isInternalFrame = (frame) => {
+    const lower = frame.toLowerCase();
+    return INTERNAL_MARKERS.some((marker) => lower.includes(marker));
+};
+export function normalizeStackFrame(frame) {
+    return frame
+        .trim()
+        .replace(/^at\s+/, "")
+        .replace(/:\d+:\d+(?=\)?$)/, "")
+        .replace(/\s+/g, " ");
+}
+export function selectApplicationFrame(stack) {
+    if (typeof stack !== "string" || stack.length === 0) {
+        return undefined;
+    }
+    for (const line of stack.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || /^\w*Error(?::|$)/.test(trimmed)) {
+            continue;
+        }
+        const frame = normalizeStackFrame(trimmed);
+        if (!frame || isInternalFrame(frame)) {
+            continue;
+        }
+        return frame;
+    }
+    return undefined;
+}

package/dist/esm/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+import { createWotchi } from "./core/client.js";
+import { registerWotchiProcessMonitor } from "./core/process-monitor.js";
+import { consoleNotifier } from "./notifiers/console.js";
+import { telegramNotifier } from "./notifiers/telegram.js";
+export { WotchiConfigurationError } from "./core/errors.js";
+export { consoleNotifier, createWotchi, registerWotchiProcessMonitor, telegramNotifier };

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

@@ -0,0 +1,12 @@
+import { getExpressRequestContext } from "./request-context.js";
+export function createExpressErrorHandler(client, options) {
+    return (error, request, response, next) => {
+        try {
+            client.captureException(error, getExpressRequestContext(request, response, options));
+        }
+        catch {
+            // A capture failure must never change Express error handling.
+        }
+        next(error);
+    };
+}

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

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

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

@@ -0,0 +1,16 @@
+import { buildRequestContext } from "../request-context.js";
+export function getExpressRequestContext(request, response, options) {
+    try {
+        const route = request.route?.path;
+        return buildRequestContext({
+            request,
+            method: request.method,
+            route: route ?? request.path,
+            statusCode: response.statusCode,
+            ...(options === undefined ? {} : { options }),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -0,0 +1,33 @@
+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 __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 { BaseExceptionFilter } from "@nestjs/core";
+import { getNestRequestContext } from "./request-context.js";
+let WotchiNestExceptionFilter = class WotchiNestExceptionFilter extends BaseExceptionFilter {
+    constructor(client, applicationRef, options) {
+        super(applicationRef);
+        this.client = client;
+        this.options = options;
+    }
+    catch(exception, host) {
+        try {
+            this.client.captureException(exception, getNestRequestContext(host, exception, this.options));
+        }
+        catch {
+            // A capture failure must never change NestJS exception handling.
+        }
+        super.catch(exception, host);
+    }
+};
+WotchiNestExceptionFilter = __decorate([
+    Catch(),
+    __metadata("design:paramtypes", [Object, Object, Object])
+], WotchiNestExceptionFilter);
+export { WotchiNestExceptionFilter };

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

@@ -0,0 +1,2 @@
+export { consoleNotifier, createWotchi, telegramNotifier } from "../../index.js";
+export { registerWotchiNest } from "./register.js";

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

@@ -0,0 +1,10 @@
+import { HttpAdapterHost } from "@nestjs/core";
+import { WotchiNestExceptionFilter } from "./exception-filter.js";
+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));
+}

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

@@ -0,0 +1,38 @@
+import { buildRequestContext } from "../request-context.js";
+const isHttpException = (exception) => typeof exception === "object" &&
+    exception !== null &&
+    typeof exception.getStatus === "function";
+const getStatusCode = (exception, response) => {
+    if (isHttpException(exception)) {
+        try {
+            const status = exception.getStatus();
+            return Number.isSafeInteger(status) ? status : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return typeof response.statusCode === "number" &&
+        Number.isSafeInteger(response.statusCode) &&
+        response.statusCode >= 400
+        ? response.statusCode
+        : 500;
+};
+export function getNestRequestContext(host, exception, options) {
+    try {
+        const httpHost = host.switchToHttp();
+        const request = httpHost.getRequest();
+        const response = httpHost.getResponse();
+        const route = request.route?.path ?? request.path ?? request.url;
+        return buildRequestContext({
+            request,
+            method: request.method,
+            route,
+            statusCode: getStatusCode(exception, response),
+            ...(options === undefined ? {} : { options }),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -0,0 +1,72 @@
+const MAX_ROUTE_LENGTH = 500;
+const MAX_REQUEST_ID_LENGTH = 200;
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const HEX_PATTERN = /^[0-9a-f]{8,}$/i;
+const isRecord = (value) => typeof value === "object" && value !== null;
+const dynamicSegment = (segment) => /^\d+$/.test(segment) ||
+    UUID_PATTERN.test(segment) ||
+    HEX_PATTERN.test(segment) ||
+    segment.length >= 24
+    ? ":id"
+    : segment;
+export function normalizeRoutePath(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const path = value.split("?", 1)[0]?.trim();
+    if (path === undefined || path.length === 0) {
+        return undefined;
+    }
+    return path.split("/").map(dynamicSegment).join("/").slice(0, MAX_ROUTE_LENGTH);
+}
+const normalizeRequestIdProperty = (property) => {
+    if (property === undefined) {
+        return undefined;
+    }
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(property)) {
+        throw new TypeError("requestIdProperty must be a simple property name");
+    }
+    return property;
+};
+const readRequestId = (request, property) => {
+    if (property === undefined || !isRecord(request)) {
+        return undefined;
+    }
+    try {
+        if (!Object.prototype.hasOwnProperty.call(request, property)) {
+            return undefined;
+        }
+        const value = request[property];
+        return typeof value === "string" ? value.slice(0, MAX_REQUEST_ID_LENGTH) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export function buildRequestContext(input) {
+    const requestIdProperty = normalizeRequestIdProperty(input.options?.requestIdProperty);
+    let requestId;
+    try {
+        requestId = readRequestId(input.request, requestIdProperty);
+    }
+    catch {
+        requestId = undefined;
+    }
+    const method = typeof input.method === "string" ? input.method.slice(0, 16) : undefined;
+    const route = normalizeRoutePath(input.route);
+    const statusCode = typeof input.statusCode === "number" && Number.isSafeInteger(input.statusCode)
+        ? input.statusCode
+        : undefined;
+    if (method === undefined &&
+        route === undefined &&
+        statusCode === undefined &&
+        requestId === undefined) {
+        return undefined;
+    }
+    return {
+        ...(method === undefined ? {} : { method }),
+        ...(route === undefined ? {} : { route }),
+        ...(statusCode === undefined ? {} : { statusCode }),
+        ...(requestId === undefined ? {} : { requestId }),
+    };
+}

package/dist/esm/notifiers/console.js

@@ -0,0 +1,29 @@
+const MAX_FIELD_LENGTH = 1_000;
+const MAX_ACTIONS = 5;
+const limit = (value, maxLength = MAX_FIELD_LENGTH) => value.slice(0, maxLength);
+export function formatConsoleAlert(alert) {
+    const actions = alert.suggestedActions
+        .slice(0, MAX_ACTIONS)
+        .map((action) => `- ${limit(action, 300)}`)
+        .join("\n");
+    return [
+        limit(alert.title),
+        `Service: ${limit(alert.service, 300)}`,
+        `Environment: ${limit(alert.environment, 300)}`,
+        `Summary: ${limit(alert.summary)}`,
+        `Occurrences: ${alert.occurrences}`,
+        `First seen: ${limit(alert.firstSeenAt, 100)}`,
+        `Last seen: ${limit(alert.lastSeenAt, 100)}`,
+        "Suggested checks:",
+        actions,
+    ].join("\n");
+}
+export function consoleNotifier(options) {
+    const write = options?.write ?? ((line) => console.error(line));
+    return {
+        name: "console",
+        async send(alert) {
+            write(formatConsoleAlert(alert));
+        },
+    };
+}

package/dist/esm/notifiers/telegram-format.js

@@ -0,0 +1,49 @@
+const MAX_MESSAGE_LENGTH = 4_096;
+const MAX_ACTIONS = 5;
+const MAX_TITLE_LENGTH = 300;
+const MAX_SERVICE_LENGTH = 300;
+const MAX_ENVIRONMENT_LENGTH = 300;
+const MAX_SUMMARY_LENGTH = 2_000;
+const MAX_ACTION_LENGTH = 600;
+const escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+const limit = (value, maxLength) => value.slice(0, maxLength);
+const render = (title, service, environment, summary, actions, firstSeenAt, lastSeenAt, occurrences) => {
+    const actionText = actions.length === 0
+        ? "- No suggested checks."
+        : actions.map((action) => `- ${escapeHtml(action)}`).join("\n");
+    return [
+        `<b>${escapeHtml(title)}</b>`,
+        `Service: ${escapeHtml(service)}`,
+        `Environment: ${escapeHtml(environment)}`,
+        `Summary: ${escapeHtml(summary)}`,
+        `Occurrences: ${occurrences}`,
+        `First seen: ${escapeHtml(firstSeenAt)}`,
+        `Last seen: ${escapeHtml(lastSeenAt)}`,
+        "Suggested checks:",
+        actionText,
+    ].join("\n");
+};
+export function formatTelegramAlert(alert) {
+    const title = limit(alert.title, MAX_TITLE_LENGTH);
+    const service = limit(alert.service, MAX_SERVICE_LENGTH);
+    const environment = limit(alert.environment, MAX_ENVIRONMENT_LENGTH);
+    const firstSeenAt = limit(alert.firstSeenAt, 100);
+    const lastSeenAt = limit(alert.lastSeenAt, 100);
+    let summary = limit(alert.summary, MAX_SUMMARY_LENGTH);
+    let actions = alert.suggestedActions
+        .slice(0, MAX_ACTIONS)
+        .map((action) => limit(action, MAX_ACTION_LENGTH));
+    let formatted = render(title, service, environment, summary, actions, firstSeenAt, lastSeenAt, alert.occurrences);
+    while (formatted.length > MAX_MESSAGE_LENGTH && actions.length > 0) {
+        actions = actions.slice(0, -1);
+        formatted = render(title, service, environment, summary, actions, firstSeenAt, lastSeenAt, alert.occurrences);
+    }
+    while (formatted.length > MAX_MESSAGE_LENGTH && summary.length > 0) {
+        summary = summary.slice(0, Math.max(0, summary.length - 200));
+        formatted = render(title, service, environment, summary, actions, firstSeenAt, lastSeenAt, alert.occurrences);
+    }
+    if (formatted.length > MAX_MESSAGE_LENGTH) {
+        formatted = render(limit(title, 100), limit(service, 100), limit(environment, 100), "Incident details were truncated.", [], firstSeenAt, lastSeenAt, alert.occurrences);
+    }
+    return formatted;
+}