@affogatosoftware/recorder 1.0.8 → 1.1.0

package/dist/index.d.ts

@@ -1 +1,2 @@
-export { Recorder, type RecorderSettings, MaskingLevel } from './recorder/recorder';
+export { Recorder, type RecorderSettings } from './recorder/recorder';
+export { NetworkRecorder, type NetworkRequest } from './recorder/networkRecorder';

package/dist/index.js

@@ -1 +1,2 @@
-export { Recorder, MaskingLevel } from './recorder/recorder';
+export { Recorder } from './recorder/recorder';
+export { NetworkRecorder } from './recorder/networkRecorder';

package/dist/recorder/errorRecorder.d.ts

@@ -0,0 +1,29 @@
+export interface ConsoleError {
+    errorType: "console_error" | "console_warn" | "uncaught_error" | "unhandled_rejection";
+    message: string;
+    stack?: string;
+    timestamp: number;
+    source?: string;
+}
+export declare class ErrorRecorder {
+    private window;
+    private errorsBuffer;
+    private isRunning;
+    private readonly flushIntervalMs;
+    private capturedSessionId;
+    private flushTimerId;
+    private originalConsoleError;
+    private originalConsoleWarn;
+    private enabled;
+    constructor(window: Window, consoleErrorSettings?: {
+        enabled: boolean;
+    });
+    start: () => void;
+    stop: () => void;
+    private captureConsoleError;
+    private handleUncaughtError;
+    private handleUnhandledRejection;
+    private scheduleFlush;
+    private flush;
+    setCapturedSessionId(uuid: string): void;
+}

package/dist/recorder/errorRecorder.js

@@ -0,0 +1,143 @@
+// Captures console errors, warnings, and uncaught errors/promise rejections
+// Buffers error events and flushes to API endpoint periodically similar to EventRecorder
+import { logger } from "../logger";
+import { post } from "../requests";
+export class ErrorRecorder {
+    window;
+    errorsBuffer = [];
+    isRunning = false;
+    flushIntervalMs = 2000;
+    capturedSessionId;
+    flushTimerId = null;
+    originalConsoleError;
+    originalConsoleWarn;
+    enabled;
+    constructor(window, consoleErrorSettings) {
+        this.window = window;
+        this.originalConsoleError = console.error.bind(console);
+        this.originalConsoleWarn = console.warn.bind(console);
+        this.enabled = consoleErrorSettings?.enabled ?? false; // Default enabled for backwards compatibility
+    }
+    start = () => {
+        if (this.isRunning || !this.enabled) {
+            return;
+        }
+        this.isRunning = true;
+        this.errorsBuffer = [];
+        // Intercept console.error
+        console.error = (...args) => {
+            this.captureConsoleError("console_error", args);
+            this.originalConsoleError(...args);
+        };
+        // Intercept console.warn
+        console.warn = (...args) => {
+            this.captureConsoleError("console_warn", args);
+            this.originalConsoleWarn(...args);
+        };
+        // Capture uncaught errors
+        this.window.addEventListener("error", this.handleUncaughtError);
+        // Capture unhandled promise rejections
+        this.window.addEventListener("unhandledrejection", this.handleUnhandledRejection);
+        this.scheduleFlush();
+    };
+    stop = () => {
+        this.isRunning = false;
+        // Restore original console methods
+        console.error = this.originalConsoleError;
+        console.warn = this.originalConsoleWarn;
+        // Remove event listeners
+        this.window.removeEventListener("error", this.handleUncaughtError);
+        this.window.removeEventListener("unhandledrejection", this.handleUnhandledRejection);
+        if (this.flushTimerId) {
+            clearTimeout(this.flushTimerId);
+            this.flushTimerId = null;
+        }
+    };
+    captureConsoleError = (errorType, args) => {
+        if (!this.isRunning) {
+            return;
+        }
+        try {
+            const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
+            const error = {
+                errorType,
+                message,
+                timestamp: Date.now()
+            };
+            // Try to extract stack trace if available
+            if (args.length > 0 && args[0] instanceof Error) {
+                error.stack = args[0].stack;
+            }
+            this.errorsBuffer.push(error);
+        }
+        catch (captureError) {
+            logger.error("Failed to capture console error", captureError);
+        }
+    };
+    handleUncaughtError = (event) => {
+        if (!this.isRunning) {
+            return;
+        }
+        try {
+            const error = {
+                errorType: "uncaught_error",
+                message: event.message,
+                stack: event.error?.stack,
+                timestamp: Date.now(),
+                source: event.filename ? `${event.filename}:${event.lineno}:${event.colno}` : undefined
+            };
+            this.errorsBuffer.push(error);
+        }
+        catch (captureError) {
+            logger.error("Failed to capture uncaught error", captureError);
+        }
+    };
+    handleUnhandledRejection = (event) => {
+        if (!this.isRunning) {
+            return;
+        }
+        try {
+            let message;
+            let stack;
+            if (event.reason instanceof Error) {
+                message = event.reason.message;
+                stack = event.reason.stack;
+            }
+            else {
+                message = String(event.reason);
+            }
+            const error = {
+                errorType: "unhandled_rejection",
+                message,
+                stack,
+                timestamp: Date.now()
+            };
+            this.errorsBuffer.push(error);
+        }
+        catch (captureError) {
+            logger.error("Failed to capture unhandled rejection", captureError);
+        }
+    };
+    scheduleFlush = () => {
+        if (this.flushTimerId) {
+            clearTimeout(this.flushTimerId);
+        }
+        this.flushTimerId = setTimeout(this.flush, this.flushIntervalMs);
+    };
+    flush = async () => {
+        if (this.errorsBuffer.length > 0 && this.capturedSessionId) {
+            try {
+                const response = await post(`/public/captured-sessions/${this.capturedSessionId}/console-errors`, this.errorsBuffer, { withCredentials: false });
+                this.errorsBuffer = [];
+            }
+            catch (error) {
+                logger.error("Failed to flush console errors", error);
+                this.errorsBuffer = [];
+            }
+        }
+        this.scheduleFlush();
+    };
+    setCapturedSessionId(uuid) {
+        this.capturedSessionId = uuid;
+    }
+}

package/dist/recorder/eventRecorder.js

@@ -1,6 +1,6 @@
 import { logger } from "../logger";
 import { post } from "../requests";
-import { MaskingLevel } from "./recorder";
+import {} from "./recorder";
 import { assertNever } from "../utils";
 export class EventRecorder {
     window;
@@ -181,18 +181,17 @@ export class EventRecorder {
             text = target.options[target.selectedIndex].text;
         }
         switch (this.recorderSettings.maskingLevel) {
-            case MaskingLevel.None:
+            case "none":
                 break;
-            case MaskingLevel.All:
+            case "all":
                 text = null;
                 break;
-            case null:
-            case MaskingLevel.InputAndTextArea:
+            case "input-and-textarea":
                 break;
-            case MaskingLevel.InputPasswordOrEmailAndTextArea:
+            case "input-password-or-email-and-textarea":
                 break;
             default:
-                assertNever(this.recorderSettings.maskingLevel);
+                text = null;
         }
         return {
             eventType: "change",
@@ -234,18 +233,17 @@ export class EventRecorder {
             text = target.src;
         }
         switch (this.recorderSettings.maskingLevel) {
-            case MaskingLevel.None:
+            case "none":
                 break;
-            case MaskingLevel.All:
+            case "all":
                 text = null;
                 break;
-            case null:
-            case MaskingLevel.InputAndTextArea:
+            case "input-and-textarea":
                 if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {
                     text = null;
                 }
                 break;
-            case MaskingLevel.InputPasswordOrEmailAndTextArea:
+            case "input-password-or-email-and-textarea":
                 if (target instanceof HTMLTextAreaElement) {
                     text = null;
                 }
@@ -256,7 +254,7 @@ export class EventRecorder {
                 }
                 break;
             default:
-                assertNever(this.recorderSettings.maskingLevel);
+                text = null;
         }
         return {
             eventType: "click",
@@ -282,18 +280,17 @@ export class EventRecorder {
             }
         }
         switch (this.recorderSettings.maskingLevel) {
-            case MaskingLevel.None:
+            case "none":
                 break;
-            case MaskingLevel.All:
+            case "all":
                 text = null;
                 break;
-            case null:
-            case MaskingLevel.InputAndTextArea:
+            case "input-and-textarea":
                 if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {
                     text = null;
                 }
                 break;
-            case MaskingLevel.InputPasswordOrEmailAndTextArea:
+            case "input-password-or-email-and-textarea":
                 if (target instanceof HTMLTextAreaElement) {
                     text = null;
                 }
@@ -304,7 +301,7 @@ export class EventRecorder {
                 }
                 break;
             default:
-                assertNever(this.recorderSettings.maskingLevel);
+                text = null;
         }
         return {
             eventType: "keydown",

package/dist/recorder/networkRecorder.d.ts

@@ -0,0 +1,54 @@
+export interface NetworkRequest {
+    requestId: string;
+    type: "xhr" | "fetch";
+    method: string;
+    url: string;
+    requestHeaders?: Record<string, string>;
+    requestBody?: string;
+    responseStatus?: number;
+    responseHeaders?: Record<string, string>;
+    responseBody?: string;
+    timestamp: number;
+    duration?: number;
+    error?: string;
+}
+interface NetworkRecorderSettings {
+    enabled: boolean;
+    maxRequestBodySize: number;
+    maxResponseBodySize: number;
+    excludeDomains: string[];
+    captureHeaders: boolean;
+    captureRequestBodies: boolean;
+    captureResponseBodies: boolean;
+    excludeHeaders: string[];
+    requestBodyMaskingFunction?: (body: string) => string;
+}
+export declare class NetworkRecorder {
+    private window;
+    private requestsBuffer;
+    private pendingRequests;
+    private isRunning;
+    private readonly flushIntervalMs;
+    private capturedSessionId;
+    private flushTimerId;
+    private originalFetch;
+    private originalXHROpen;
+    private originalXHRSend;
+    private queryParamsAllowed;
+    private networkSettings;
+    constructor(window: Window, settings?: Partial<NetworkRecorderSettings>);
+    start: () => void;
+    stop: () => void;
+    setCapturedSessionId(uuid: string): void;
+    private scheduleFlush;
+    private flush;
+    private patchFetch;
+    private patchXHR;
+    private shouldCaptureRequest;
+    private sanitizeUrl;
+    private filterHeaders;
+    private truncateContent;
+    private generateRequestId;
+    private addCompletedRequest;
+}
+export {};