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

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

@@ -1,4 +1,5 @@
-export { consoleNotifier, createWotchi, telegramNotifier } from "../../index.js";
-export { registerWotchiNest } from "./register.js";
-export type { ConsoleNotifierOptions, IncidentAlert, IncidentGroup, IncidentSeverity, SafeErrorEvent, TelegramNotifierOptions, WotchiClient, WotchiConfig, WotchiDiagnostics, WotchiEventInput, WotchiNotifier, WotchiRequestContext, } from "../../index.js";
+export { consoleNotifier, createWotchi, telegramNotifier, webhookNotifier } from "../../index.js";
+export { registerWotchiNest, registerWotchiNestStatusObserver } from "./register.js";
+export type { ConsoleNotifierOptions, IncidentAlert, IncidentGroup, IncidentSeverity, SafeErrorEvent, TelegramNotifierOptions, WebhookNotifierOptions, WotchiBeforeSend, WotchiCaptureOptions, WotchiClient, WotchiConfig, WotchiDiagnostics, WotchiEventFilter, WotchiEventInput, WotchiFingerprintCallback, WotchiFingerprintOverride, WotchiIncidentRule, WotchiLinkTemplates, WotchiLinks, WotchiNotifier, WotchiRequestContext, WotchiTags, WotchiTestAlertResult, WotchiTestAlertStatus, WotchiTraceContext, } from "../../index.js";
 export type { NestWotchiApplication, NestWotchiOptions } from "./register.js";
+export type { WotchiStatusClass, WotchiStatusObserverOptions } from "../express/status-observer.js";

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

@@ -1,10 +1,13 @@
 import { HttpAdapterHost } from "@nestjs/core";
 import type { WotchiClient } from "../../core/types.js";
 import type { NestWotchiOptions } from "./request-context.js";
+import type { WotchiStatusObserverOptions } from "../express/status-observer.js";
 export type { NestWotchiOptions } from "./request-context.js";
 export interface NestWotchiApplication {
     get(token: typeof HttpAdapterHost): InstanceType<typeof HttpAdapterHost>;
     getHttpAdapter?: () => unknown;
+    use?: (...middleware: unknown[]) => unknown;
     useGlobalFilters(...filters: unknown[]): unknown;
 }
 export declare function registerWotchiNest(app: unknown, client: WotchiClient, options?: NestWotchiOptions): void;
+export declare function registerWotchiNestStatusObserver(app: unknown, client: WotchiClient, options?: WotchiStatusObserverOptions): void;

package/dist/types/integrations/request-context.d.ts

@@ -1,6 +1,8 @@
 import type { WotchiRequestContext } from "../core/types.js";
 export interface RequestContextOptions {
     requestIdProperty?: string;
+    correlationIdProperty?: string;
+    traceContextProperty?: string;
 }
 export declare function normalizeRoutePath(value: unknown): string | undefined;
 export interface RequestContextInput {
@@ -8,6 +10,7 @@ export interface RequestContextInput {
     method?: unknown;
     route?: unknown;
     statusCode?: unknown;
+    trace?: unknown;
     options?: RequestContextOptions;
 }
 export declare function buildRequestContext(input: RequestContextInput): WotchiRequestContext | undefined;

package/dist/types/notifiers/alert-payload.d.ts

@@ -0,0 +1,5 @@
+import type { SafeNormalizedValue } from "../core/normalize.js";
+import type { IncidentAlert } from "../core/types.js";
+export type BoundedAlertPayload = Record<string, SafeNormalizedValue>;
+export declare function toBoundedPayload(value: unknown): BoundedAlertPayload;
+export declare function toBoundedAlertPayload(alert: IncidentAlert): BoundedAlertPayload;

package/dist/types/notifiers/console.d.ts

@@ -1,3 +1,3 @@
 import type { ConsoleNotifierOptions, IncidentAlert, WotchiNotifier } from "../core/types.js";
-export declare function formatConsoleAlert(alert: IncidentAlert): string;
+export declare function formatConsoleAlert(alert: IncidentAlert, format?: "text" | "json"): string;
 export declare function consoleNotifier(options?: ConsoleNotifierOptions): WotchiNotifier;

package/dist/types/notifiers/webhook-http.d.ts

@@ -0,0 +1,37 @@
+import type { IncidentAlert, WebhookNotifierOptions } from "../core/types.js";
+export interface WebhookRequestOptions {
+    protocol: "http:" | "https:";
+    hostname: string;
+    port?: string;
+    method: "POST";
+    path: string;
+    headers: Record<string, string | number>;
+    allowPrivateDestinations?: boolean;
+    signal?: AbortSignal;
+}
+export interface WebhookResponse {
+    statusCode: number;
+    headers: Record<string, string | string[] | undefined>;
+    body: string;
+}
+export type WebhookRequestFunction = (options: WebhookRequestOptions, body: string, timeoutMs: number) => Promise<WebhookResponse>;
+export interface WebhookSendOptions {
+    url: string;
+    alert: IncidentAlert;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    maxRetries?: number;
+    allowHttpLoopback?: boolean;
+    allowPrivateDestinations?: boolean;
+    payloadBuilder?: (alert: Readonly<IncidentAlert>) => unknown;
+}
+export declare function normalizeWebhookOptions(options: WebhookNotifierOptions): {
+    url: URL;
+    headers?: Record<string, string>;
+    timeoutMs: number;
+    maxRetries: number;
+    allowHttpLoopback: boolean;
+    allowPrivateDestinations: boolean;
+    payloadBuilder?: WebhookNotifierOptions["payloadBuilder"];
+};
+export declare function sendWebhookAlert(options: WebhookSendOptions, request?: WebhookRequestFunction): Promise<void>;

package/dist/types/notifiers/webhook.d.ts

@@ -0,0 +1,4 @@
+import type { WebhookNotifierOptions, WotchiNotifier } from "../core/types.js";
+import { type WebhookRequestFunction } from "./webhook-http.js";
+export declare function createWebhookNotifier(options: WebhookNotifierOptions, request?: WebhookRequestFunction): WotchiNotifier;
+export declare function webhookNotifier(options: WebhookNotifierOptions): WotchiNotifier;

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

@@ -0,0 +1,2 @@
+import type { WotchiClient, WotchiConfig } from "./types.js";
+export declare function createWotchi(config: WotchiConfig): WotchiClient;

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

@@ -0,0 +1,35 @@
+import type { WotchiConfig, WotchiIncidentRule, WotchiLinkTemplates, WotchiNotifier } from "./types.js";
+import { WotchiConfigurationError } from "./errors.js";
+export { WotchiConfigurationError };
+export interface NormalizedWotchiConfig {
+    readonly service: string;
+    readonly environment: string;
+    readonly instance?: string;
+    readonly release?: string;
+    readonly enabled: boolean;
+    readonly filter?: WotchiConfig["filter"];
+    readonly fingerprint?: WotchiConfig["fingerprint"];
+    readonly beforeSend?: WotchiConfig["beforeSend"];
+    readonly links?: Readonly<WotchiLinkTemplates>;
+    readonly rules: readonly WotchiIncidentRule[];
+    readonly grouping: {
+        readonly windowMs: number;
+        readonly alertThreshold: number;
+        readonly cooldownMs: number;
+        readonly maxGroups: number;
+        readonly maxEventsPerWindow: number;
+    };
+    readonly queue: {
+        readonly maxPendingAlerts: number;
+        readonly concurrency: 1;
+    };
+    readonly privacy: {
+        readonly redactKeys: readonly string[];
+        readonly maxDepth: number;
+        readonly maxKeys: number;
+        readonly maxStringLength: number;
+        readonly maxStackLength: number;
+    };
+    readonly notifiers: readonly WotchiNotifier[];
+}
+export declare function validateConfig(config: WotchiConfig): Readonly<NormalizedWotchiConfig>;

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

@@ -0,0 +1,11 @@
+import type { WotchiDiagnostics } from "./types.js";
+export interface DiagnosticsState {
+    capturedEvents: number;
+    captureFailures: number;
+    fingerprintCallbackFailures: number;
+    filterFailures: number;
+    beforeSendFailures: number;
+    eventsSuppressed: number;
+}
+export declare function createDiagnosticsState(): DiagnosticsState;
+export declare function snapshotDiagnostics(state: DiagnosticsState, values: Omit<WotchiDiagnostics, "capturedEvents" | "captureFailures" | "fingerprintCallbackFailures" | "filterFailures" | "beforeSendFailures" | "eventsSuppressed">): Readonly<WotchiDiagnostics>;

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

@@ -0,0 +1,3 @@
+export declare class WotchiConfigurationError extends Error {
+    constructor(message: string);
+}

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

@@ -0,0 +1,3 @@
+import type { SafeErrorEvent } from "./types.js";
+export declare function normalizeDynamicSegments(value: string): string;
+export declare function fingerprintSafeErrorEvent(event: SafeErrorEvent): string;

package/dist/types-cjs/core/group-store.d.cts

@@ -0,0 +1,15 @@
+import type { IncidentGroup, IncidentSeverity, SafeErrorEvent } from "./types.js";
+export interface GroupStoreOptions {
+    maxGroups: number;
+    maxEventsPerWindow: number;
+    windowMs: number;
+    now?: () => number;
+}
+export interface GroupStore {
+    record(fingerprint: string, event: SafeErrorEvent, severity?: IncidentSeverity): IncidentGroup;
+    get(fingerprint: string): IncidentGroup | undefined;
+    markAlerted(fingerprint: string, timestamp?: number): IncidentGroup | undefined;
+    size(): number;
+    groupsEvicted(): number;
+}
+export declare function createGroupStore(options: GroupStoreOptions): GroupStore;

package/dist/types-cjs/core/incident-builder.d.cts

@@ -0,0 +1,3 @@
+import type { IncidentAlert, IncidentGroup } from "./types.js";
+import type { IncidentPolicyDecision } from "./incident-policy.js";
+export declare function buildIncidentAlert(group: IncidentGroup, decision: IncidentPolicyDecision): IncidentAlert;

package/dist/types-cjs/core/incident-policy.d.cts

@@ -0,0 +1,15 @@
+import type { IncidentGroup, IncidentSeverity } from "./types.js";
+export type IncidentEventKind = "error" | "manual" | "process-monitor";
+export interface IncidentPolicyInput {
+    group: IncidentGroup;
+    now: number;
+    alertThreshold: number;
+    cooldownMs: number;
+    eventKind?: IncidentEventKind;
+    manualSeverity?: IncidentSeverity;
+}
+export interface IncidentPolicyDecision {
+    shouldAlert: boolean;
+    severity: IncidentSeverity;
+}
+export declare function evaluateIncidentPolicy(input: IncidentPolicyInput): IncidentPolicyDecision;

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

@@ -0,0 +1,10 @@
+export declare const MAX_GROUPS = 10000;
+export declare const MAX_EVENTS_PER_WINDOW = 10000;
+export declare const MAX_PENDING_ALERTS = 10000;
+export declare const MAX_WINDOW_MS: number;
+export declare const MAX_ALERT_THRESHOLD = 1000000;
+export declare const MAX_COOLDOWN_MS: number;
+export declare const MAX_NORMALIZATION_DEPTH = 20;
+export declare const MAX_NORMALIZATION_KEYS = 10000;
+export declare const MAX_NORMALIZATION_STRING_LENGTH = 32768;
+export declare const MAX_NORMALIZATION_STACK_LENGTH = 32768;

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

@@ -0,0 +1,17 @@
+export interface NormalizationLimits {
+    maxDepth: number;
+    maxKeys: number;
+    maxStringLength: number;
+    maxStackLength: number;
+}
+export type SafeNormalizedValue = null | boolean | number | string | SafeNormalizedValue[] | {
+    [key: string]: SafeNormalizedValue;
+};
+export interface NormalizedError {
+    name: string;
+    message: string;
+    stack?: string;
+    code?: string;
+}
+export declare function normalizeUnknown(value: unknown, limits?: Partial<NormalizationLimits>): SafeNormalizedValue;
+export declare function normalizeError(error: unknown, limits?: Partial<NormalizationLimits>): NormalizedError;

package/dist/types-cjs/core/notification-queue.d.cts

@@ -0,0 +1,20 @@
+import type { IncidentAlert, WotchiNotifier } from "./types.js";
+export interface NotificationQueueOptions {
+    maxPendingAlerts: number;
+    concurrency: 1;
+    onNotifierError?: (error: unknown, notifier: WotchiNotifier) => void;
+}
+export interface NotificationJobResult {
+    notifierFailures: number;
+    sent: number;
+}
+export interface NotificationQueue {
+    enqueue(alert: IncidentAlert, notifiers: readonly WotchiNotifier[], onComplete?: (result: NotificationJobResult) => void): boolean;
+    flush(timeoutMs?: number): Promise<void>;
+    pending(): number;
+    alertsQueued(): number;
+    alertsDropped(): number;
+    alertsSent(): number;
+    notifierFailures(): number;
+}
+export declare function createNotificationQueue(options: NotificationQueueOptions): NotificationQueue;

package/dist/types-cjs/core/process-monitor.d.cts

@@ -0,0 +1,5 @@
+import type { WotchiClient } from "./types.js";
+export interface ProcessMonitorHandle {
+    unregister(): void;
+}
+export declare function registerWotchiProcessMonitor(client: WotchiClient): ProcessMonitorHandle;

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

@@ -0,0 +1,11 @@
+import type { NormalizedError, SafeNormalizedValue } from "./normalize.js";
+export declare const REDACTED = "[REDACTED]";
+export interface RedactionOptions {
+    redactKeys?: readonly string[];
+    maxDepth?: number;
+    maxKeys?: number;
+    maxStringLength?: number;
+    maxStackLength?: number;
+}
+export declare function redactValue(value: unknown, options?: RedactionOptions): SafeNormalizedValue;
+export declare function redactError(error: NormalizedError, options?: RedactionOptions): NormalizedError;

package/dist/types-cjs/core/rolling-window.d.cts

@@ -0,0 +1,12 @@
+export interface RollingWindowOptions {
+    maxEvents: number;
+    windowMs: number;
+    now?: () => number;
+}
+export interface RollingWindow {
+    add(timestamp?: number): void;
+    count(timestamp?: number): number;
+    size(timestamp?: number): number;
+    timestamps(timestamp?: number): readonly number[];
+}
+export declare function createRollingWindow(options: RollingWindowOptions): RollingWindow;

package/dist/types-cjs/core/stack-frame.d.cts

@@ -0,0 +1,2 @@
+export declare function normalizeStackFrame(frame: string): string;
+export declare function selectApplicationFrame(stack?: string): string | undefined;

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

@@ -0,0 +1,205 @@
+export type IncidentSeverity = "low" | "medium" | "high" | "critical";
+export type WotchiEventKind = "error" | "manual" | "process-monitor";
+export interface WotchiTraceContext {
+    traceId?: string;
+    spanId?: string;
+}
+export interface WotchiRequestContext extends Record<string, unknown> {
+    method?: string;
+    route?: string;
+    statusCode?: number;
+    requestId?: string;
+    correlationId?: string;
+    trace?: WotchiTraceContext;
+}
+export type WotchiTags = Readonly<Record<string, string>>;
+export interface WotchiLinkTemplates {
+    log?: string;
+    trace?: string;
+}
+export interface WotchiLinks {
+    log?: string;
+    trace?: string;
+}
+export type WotchiFingerprintCallback = (event: Readonly<SafeErrorEvent>) => string | undefined;
+export type WotchiFingerprintOverride = string | WotchiFingerprintCallback;
+export type WotchiEventFilter = (event: Readonly<SafeErrorEvent>) => boolean;
+export type WotchiBeforeSend = (alert: Readonly<IncidentAlert>) => IncidentAlert | null | undefined;
+export interface WotchiCaptureOptions {
+    fingerprint?: WotchiFingerprintOverride;
+    severity?: IncidentSeverity;
+    alertThreshold?: number;
+    request?: WotchiRequestContext;
+    trace?: WotchiTraceContext;
+    correlationId?: string;
+    operation?: string;
+    job?: string;
+    tags?: Record<string, unknown>;
+}
+export interface WotchiEventInput {
+    level: "error";
+    kind?: WotchiEventKind;
+    message: string;
+    error?: unknown;
+    alertThreshold?: number;
+    severity?: IncidentSeverity;
+    fingerprint?: WotchiFingerprintOverride;
+    metadata?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+    request?: WotchiRequestContext;
+    trace?: WotchiTraceContext;
+    correlationId?: string;
+    operation?: string;
+    job?: string;
+    tags?: Record<string, unknown>;
+}
+export interface SafeErrorEvent {
+    id: string;
+    timestamp: string;
+    service: string;
+    environment: string;
+    instance?: string;
+    release?: string;
+    correlationId?: string;
+    operation?: string;
+    job?: string;
+    tags?: WotchiTags;
+    error: {
+        name: string;
+        message: string;
+        stack?: string;
+        code?: string;
+    };
+    request?: WotchiRequestContext;
+    trace?: WotchiTraceContext;
+    context?: Record<string, unknown>;
+}
+export interface IncidentGroup {
+    fingerprint: string;
+    firstSeenAt: string;
+    lastSeenAt: string;
+    totalCount: number;
+    windowCount: number;
+    sample: SafeErrorEvent;
+    lastAlertedAt?: string;
+    severity: IncidentSeverity;
+}
+export interface IncidentAlert {
+    id: string;
+    fingerprint: string;
+    title: string;
+    severity: IncidentSeverity;
+    summary: string;
+    suggestedActions: string[];
+    firstSeenAt: string;
+    lastSeenAt: string;
+    occurrences: number;
+    service: string;
+    environment: string;
+    instance?: string;
+    release?: string;
+    correlationId?: string;
+    operation?: string;
+    job?: string;
+    tags?: WotchiTags;
+    error?: SafeErrorEvent["error"] & {
+        applicationFrame?: string;
+    };
+    request?: WotchiRequestContext;
+    trace?: WotchiTraceContext;
+    context?: Record<string, unknown>;
+    links?: WotchiLinks;
+}
+export interface WotchiNotifier {
+    readonly name: string;
+    send(alert: IncidentAlert): Promise<void>;
+}
+export interface ConsoleNotifierOptions {
+    write?: (line: string) => void;
+    format?: "text" | "json";
+}
+export interface TelegramNotifierOptions {
+    botToken: string;
+    chatId: string;
+    timeoutMs?: number;
+}
+export interface WebhookNotifierOptions {
+    url: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    maxRetries?: number;
+    allowHttpLoopback?: boolean;
+    allowPrivateDestinations?: boolean;
+    payloadBuilder?: (alert: Readonly<IncidentAlert>) => unknown;
+}
+export interface WotchiIncidentRule {
+    environment?: string;
+    route?: string;
+    ignore?: boolean;
+    alertThreshold?: number;
+    severity?: IncidentSeverity;
+}
+export interface WotchiConfig {
+    service: string;
+    environment: string;
+    instance?: string;
+    release?: string;
+    enabled?: boolean;
+    filter?: WotchiEventFilter;
+    fingerprint?: WotchiFingerprintCallback;
+    beforeSend?: WotchiBeforeSend;
+    links?: WotchiLinkTemplates;
+    rules?: readonly WotchiIncidentRule[];
+    grouping?: {
+        windowMs?: number;
+        alertThreshold?: number;
+        cooldownMs?: number;
+        maxGroups?: number;
+        maxEventsPerWindow?: number;
+    };
+    queue?: {
+        maxPendingAlerts?: number;
+        concurrency?: 1;
+    };
+    privacy?: {
+        redactKeys?: string[];
+        maxDepth?: number;
+        maxKeys?: number;
+        maxStringLength?: number;
+        maxStackLength?: number;
+    };
+    notifiers: WotchiNotifier[];
+}
+export interface WotchiDiagnostics {
+    capturedEvents: number;
+    captureFailures: number;
+    groupsEvicted: number;
+    alertsQueued: number;
+    alertsDropped: number;
+    alertsSent: number;
+    notifierFailures: number;
+    fingerprintCallbackFailures: number;
+    filterFailures: number;
+    beforeSendFailures: number;
+    eventsSuppressed: number;
+    activeGroups: number;
+    pendingAlerts: number;
+}
+export type WotchiTestAlertStatus = "sent" | "queue-full" | "timeout" | "notifier-failed";
+export interface WotchiTestAlertResult {
+    status: WotchiTestAlertStatus;
+    configurationAccepted: true;
+    queued: boolean;
+    flushed: boolean;
+    delivered: boolean;
+    notifierFailures: number;
+    diagnostics: Readonly<WotchiDiagnostics>;
+    error?: string;
+}
+export interface WotchiClient {
+    captureException(error: unknown, context?: Record<string, unknown>, options?: WotchiCaptureOptions): void;
+    captureEvent(event: WotchiEventInput): void;
+    testAlert(): Promise<WotchiTestAlertResult>;
+    flush(timeoutMs?: number): Promise<void>;
+    getDiagnostics(): Readonly<WotchiDiagnostics>;
+}

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

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

package/dist/types-cjs/integrations/express/error-handler.d.cts

@@ -0,0 +1,4 @@
+import type { ErrorRequestHandler } from "express";
+import type { WotchiClient } from "../../core/types.js";
+import { type ExpressWotchiOptions } from "./request-context.js";
+export declare function createExpressErrorHandler(client: WotchiClient, options?: ExpressWotchiOptions): ErrorRequestHandler;

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

@@ -0,0 +1,9 @@
+import type { WotchiClient } from "../../core/types.js";
+import { createExpressErrorHandler } from "./error-handler.js";
+import type { ExpressWotchiOptions } from "./request-context.js";
+export { consoleNotifier, createWotchi, telegramNotifier, webhookNotifier } from "../../index.js";
+export type { ConsoleNotifierOptions, IncidentAlert, IncidentGroup, IncidentSeverity, SafeErrorEvent, TelegramNotifierOptions, WebhookNotifierOptions, WotchiBeforeSend, WotchiCaptureOptions, WotchiClient, WotchiConfig, WotchiDiagnostics, WotchiEventFilter, WotchiEventInput, WotchiFingerprintCallback, WotchiFingerprintOverride, WotchiIncidentRule, WotchiLinkTemplates, WotchiLinks, WotchiNotifier, WotchiRequestContext, WotchiTags, WotchiTestAlertResult, WotchiTestAlertStatus, WotchiTraceContext, } from "../../index.js";
+export type { ExpressWotchiOptions } from "./request-context.js";
+export type { WotchiStatusClass, WotchiStatusObserverOptions } from "./status-observer.js";
+export { wotchiStatusObserver } from "./status-observer.js";
+export declare function wotchiErrorHandler(client: WotchiClient, options?: ExpressWotchiOptions): ReturnType<typeof createExpressErrorHandler>;

package/dist/types-cjs/integrations/express/request-context.d.cts

@@ -0,0 +1,5 @@
+import type { Request, Response } from "express";
+import { type RequestContextOptions } from "../request-context.js";
+import type { WotchiRequestContext } from "../../core/types.js";
+export type ExpressWotchiOptions = RequestContextOptions;
+export declare function getExpressRequestContext(request: Request, response: Response, options?: ExpressWotchiOptions): WotchiRequestContext | undefined;

package/dist/types-cjs/integrations/express/state.d.cts

@@ -0,0 +1,2 @@
+export declare function markExpressErrorCaptured(request: unknown): void;
+export declare function wasExpressErrorCaptured(request: unknown): boolean;

package/dist/types-cjs/integrations/express/status-observer.d.cts

@@ -0,0 +1,11 @@
+import type { RequestHandler } from "express";
+import type { WotchiClient } from "../../core/types.js";
+import type { RequestContextOptions } from "../request-context.js";
+export type WotchiStatusClass = "4xx" | "5xx";
+export interface WotchiStatusObserverOptions extends RequestContextOptions {
+    statusCodes?: readonly number[];
+    statusClasses?: readonly WotchiStatusClass[];
+    ignoreStatusCodes?: readonly number[];
+    alertThreshold?: number;
+}
+export declare function wotchiStatusObserver(client: WotchiClient, options?: WotchiStatusObserverOptions): RequestHandler;

package/dist/types-cjs/integrations/nest/exception-filter.d.cts

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

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

@@ -0,0 +1,5 @@
+export { consoleNotifier, createWotchi, telegramNotifier, webhookNotifier } from "../../index.js";
+export { registerWotchiNest, registerWotchiNestStatusObserver } from "./register.js";
+export type { ConsoleNotifierOptions, IncidentAlert, IncidentGroup, IncidentSeverity, SafeErrorEvent, TelegramNotifierOptions, WebhookNotifierOptions, WotchiBeforeSend, WotchiCaptureOptions, WotchiClient, WotchiConfig, WotchiDiagnostics, WotchiEventFilter, WotchiEventInput, WotchiFingerprintCallback, WotchiFingerprintOverride, WotchiIncidentRule, WotchiLinkTemplates, WotchiLinks, WotchiNotifier, WotchiRequestContext, WotchiTags, WotchiTestAlertResult, WotchiTestAlertStatus, WotchiTraceContext, } from "../../index.js";
+export type { NestWotchiApplication, NestWotchiOptions } from "./register.js";
+export type { WotchiStatusClass, WotchiStatusObserverOptions } from "../express/status-observer.js";

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

@@ -0,0 +1,13 @@
+import { HttpAdapterHost } from "@nestjs/core";
+import type { WotchiClient } from "../../core/types.js";
+import type { NestWotchiOptions } from "./request-context.js";
+import type { WotchiStatusObserverOptions } from "../express/status-observer.js";
+export type { NestWotchiOptions } from "./request-context.js";
+export interface NestWotchiApplication {
+    get(token: typeof HttpAdapterHost): InstanceType<typeof HttpAdapterHost>;
+    getHttpAdapter?: () => unknown;
+    use?: (...middleware: unknown[]) => unknown;
+    useGlobalFilters(...filters: unknown[]): unknown;
+}
+export declare function registerWotchiNest(app: unknown, client: WotchiClient, options?: NestWotchiOptions): void;
+export declare function registerWotchiNestStatusObserver(app: unknown, client: WotchiClient, options?: WotchiStatusObserverOptions): void;

package/dist/types-cjs/integrations/nest/request-context.d.cts

@@ -0,0 +1,5 @@
+import type { ArgumentsHost } from "@nestjs/common";
+import { type RequestContextOptions } from "../request-context.js";
+import type { WotchiRequestContext } from "../../core/types.js";
+export type NestWotchiOptions = RequestContextOptions;
+export declare function getNestRequestContext(host: ArgumentsHost, exception: unknown, options?: NestWotchiOptions): WotchiRequestContext | undefined;

package/dist/types-cjs/integrations/request-context.d.cts

@@ -0,0 +1,16 @@
+import type { WotchiRequestContext } from "../core/types.js";
+export interface RequestContextOptions {
+    requestIdProperty?: string;
+    correlationIdProperty?: string;
+    traceContextProperty?: string;
+}
+export declare function normalizeRoutePath(value: unknown): string | undefined;
+export interface RequestContextInput {
+    request?: unknown;
+    method?: unknown;
+    route?: unknown;
+    statusCode?: unknown;
+    trace?: unknown;
+    options?: RequestContextOptions;
+}
+export declare function buildRequestContext(input: RequestContextInput): WotchiRequestContext | undefined;

package/dist/types-cjs/notifiers/alert-payload.d.cts

@@ -0,0 +1,5 @@
+import type { SafeNormalizedValue } from "../core/normalize.js";
+import type { IncidentAlert } from "../core/types.js";
+export type BoundedAlertPayload = Record<string, SafeNormalizedValue>;
+export declare function toBoundedPayload(value: unknown): BoundedAlertPayload;
+export declare function toBoundedAlertPayload(alert: IncidentAlert): BoundedAlertPayload;

package/dist/types-cjs/notifiers/console.d.cts

@@ -0,0 +1,3 @@
+import type { ConsoleNotifierOptions, IncidentAlert, WotchiNotifier } from "../core/types.js";
+export declare function formatConsoleAlert(alert: IncidentAlert, format?: "text" | "json"): string;
+export declare function consoleNotifier(options?: ConsoleNotifierOptions): WotchiNotifier;

package/dist/types-cjs/notifiers/telegram-format.d.cts

@@ -0,0 +1,2 @@
+import type { IncidentAlert } from "../core/types.js";
+export declare function formatTelegramAlert(alert: IncidentAlert): string;

package/dist/types-cjs/notifiers/telegram-http.d.cts

@@ -0,0 +1,21 @@
+import type { RequestOptions } from "node:https";
+export interface TelegramHttpRequestOptions extends RequestOptions {
+    protocol: "https:";
+    hostname: "api.telegram.org";
+    method: "POST";
+    path: string;
+    headers: Record<string, string | number>;
+}
+export interface TelegramHttpResponse {
+    statusCode: number;
+    headers: Record<string, string | string[] | undefined>;
+    body: string;
+}
+export type TelegramRequestFunction = (options: TelegramHttpRequestOptions, body: string, timeoutMs: number) => Promise<TelegramHttpResponse>;
+export interface TelegramSendOptions {
+    botToken: string;
+    chatId: string;
+    text: string;
+    timeoutMs?: number;
+}
+export declare function sendTelegramMessage(options: TelegramSendOptions, request?: TelegramRequestFunction): Promise<void>;