fix

Author: Dobrunia

src/addons/consoleCatcher.ts

@@ -2,79 +2,96 @@
  * @file Module for intercepting console logs with stack trace capture
  */
 
-import type { ConsoleLogEvent } from '@hawk.so/types/build/src/base/event/addons/javascript';
+import type { ConsoleLogEvent } from '@hawk.so/types';
 
-const MAX_LOGS = 20;
-const consoleOutput: ConsoleLogEvent[] = [];
+const createConsoleCatcher = () => {
+  const MAX_LOGS = 20;
+  const consoleOutput: ConsoleLogEvent[] = [];
+  let isInitialized = false;
 
-let isInitialized = false;
-
-/**
- * Initializes the console catcher by overriding console methods
- * to capture logs with stack traces.
- */
-export function initConsoleCatcher(): void {
-  if (isInitialized) {
-    return;
+  const addToConsoleOutput = (logEvent: ConsoleLogEvent) => {
+    if (consoleOutput.length >= MAX_LOGS) {
+      consoleOutput.shift();
+    }
+    consoleOutput.push(logEvent);
   };
 
-  isInitialized = true;
-  const consoleMethods = ['log', 'warn', 'error', 'info', 'debug'];
+  const createConsoleEventFromError = (
+    event: ErrorEvent | PromiseRejectionEvent
+  ): ConsoleLogEvent => {
+    if (event instanceof ErrorEvent) {
+      return {
+        method: 'error',
+        timestamp: new Date(),
+        type: event.error?.name || 'Error',
+        message: event.error?.message || event.message,
+        stack: event.error?.stack || '',
+        fileLine: event.filename
+          ? `${event.filename}:${event.lineno}:${event.colno}`
+          : '',
+      };
+    }
 
-  consoleMethods.forEach((method) => {
-    if (typeof window.console[method] !== 'function') {
-      return;
+    return {
+      method: 'error',
+      timestamp: new Date(),
+      type: 'UnhandledRejection',
+      message: event.reason?.message || String(event.reason),
+      stack: event.reason?.stack || '',
+      fileLine: '',
     };
+  };
 
-    const oldFunction = window.console[method].bind(window.console);
-
-    window.console[method] = function (...args): void {
-      if (consoleOutput.length >= MAX_LOGS) {
-        consoleOutput.shift();
+  return {
+    initConsoleCatcher(): void {
+      if (isInitialized) {
+        return;
       }
 
-      const stack = new Error().stack?.split('\n').slice(2).join('\n') || '';
+      isInitialized = true;
+      const consoleMethods = ['log', 'warn', 'error', 'info', 'debug'];
 
-      const logEvent: ConsoleLogEvent = {
-        method,
-        timestamp: new Date(),
-        type: method,
-        message: args
-          .map((arg) => (typeof arg === 'string' ? arg : JSON.stringify(arg))).join(' '),
-        stack,
-        fileLine: stack.split('\n')[0]?.trim(),
-      };
+      consoleMethods.forEach((method) => {
+        if (typeof window.console[method] !== 'function') {
+          return;
+        }
 
-      consoleOutput.push(logEvent);
-      oldFunction(...args);
-    };
-  });
+        const oldFunction = window.console[method].bind(window.console);
 
-  window.addEventListener('error', function (event) {
-    if (consoleOutput.length >= MAX_LOGS) {
-      consoleOutput.shift();
-    }
+        window.console[method] = function (...args): void {
+          const stack =
+            new Error().stack?.split('\n').slice(2).join('\n') || '';
 
-    const logEvent: ConsoleLogEvent = {
-      method: 'error',
-      timestamp: new Date(),
-      type: event.error?.name || 'Error',
-      message: event.error?.message || event.message,
-      stack: event.error?.stack || '',
-      fileLine: event.filename
-        ? `${event.filename}:${event.lineno}:${event.colno}`
-        : '',
-    };
+          const logEvent: ConsoleLogEvent = {
+            method,
+            timestamp: new Date(),
+            type: method,
+            message: args
+              .map((arg) =>
+                typeof arg === 'string' ? arg : JSON.stringify(arg)
+              )
+              .join(' '),
+            stack,
+            fileLine: stack.split('\n')[0]?.trim(),
+          };
 
-    consoleOutput.push(logEvent);
-  });
-}
+          addToConsoleOutput(logEvent);
+          oldFunction(...args);
+        };
+      });
+    },
 
-/**
- * Returns the stack of captured console logs.
- *
- * @returns {ConsoleLogEvent[]} Array of logged console events.
- */
-export function getConsoleLogStack(): ConsoleLogEvent[] {
-  return [ ...consoleOutput ];
-}
+    addErrorEvent(event: ErrorEvent | PromiseRejectionEvent): void {
+      const logEvent = createConsoleEventFromError(event);
+      addToConsoleOutput(logEvent);
+    },
+
+    getConsoleLogStack(): ConsoleLogEvent[] {
+      return [...consoleOutput];
+    },
+  };
+};
+
+const consoleCatcher = createConsoleCatcher();
+export const { initConsoleCatcher, getConsoleLogStack, addErrorEvent } =
+  consoleCatcher;

src/catcher.ts

@@ -16,7 +16,7 @@ import type { JavaScriptCatcherIntegrations } from './types/integrations';
 import { EventRejectedError } from './errors';
 import type { HawkJavaScriptEvent } from './types';
 import { isErrorProcessed, markErrorAsProcessed } from './utils/event';
-import { getConsoleLogStack, initConsoleCatcher } from './addons/consoleCatcher';
+import { addErrorEvent, getConsoleLogStack, initConsoleCatcher } from './addons/consoleCatcher';
 
 /**
  * Allow to use global VERSION, that will be overwritten by Webpack
@@ -228,6 +228,12 @@ export default class Catcher {
    * @param {ErrorEvent|PromiseRejectionEvent} event — (!) both for Error and Promise Rejection
    */
   private async handleEvent(event: ErrorEvent | PromiseRejectionEvent): Promise<void> {
+    /**
+     * Add error to console logs
+     */
+
+    addErrorEvent(event);
+
     /**
      * Promise rejection reason is recommended to be an Error, but it can be a string:
      * - Promise.reject(new Error('Reason message')) ——— recommended