feat: move error reporting functionality to the core module

jest/jest.setup-dom.js

@@ -8,9 +8,23 @@ global.window.innerHeight = 1024;
 global.window.__BUNDLE_ALL_PLUGINS__ = false;
 global.window.__IS_LEGACY_BUILD__ = false;
 global.window.__IS_DYNAMIC_CUSTOM_BUNDLE__ = false;
-global.PromiseRejectionEvent = function (reason) {
-  this.reason = reason;
-};
+
+// Only define the mock if it's not already defined (e.g., in a real browser)
+if (typeof PromiseRejectionEvent === 'undefined') {
+  // Mock class (very minimal)
+  class PromiseRejectionEvent extends Event {
+    constructor(type, eventInitDict) {
+      super(type, eventInitDict);
+      this.promise = eventInitDict?.promise;
+      this.reason = eventInitDict?.reason;
+    }
+  }
+
+  // Attach it to the global object so tests can use it.
+  global.PromiseRejectionEvent = PromiseRejectionEvent;
+  // If you rely on "window" instead:
+  // global.window.PromiseRejectionEvent = PromiseRejectionEvent;
+}
 
 // TODO: remove once we use globalThis in analytics v1.1 too
 // Setup mocking for window.navigator

packages/analytics-js-common/__mocks__/ErrorHandler.ts

@@ -1,14 +1,11 @@
-import type { IErrorHandler, PreLoadErrorData } from '../src/types/ErrorHandler';
-import { BufferQueue } from './BufferQueue';
+import type { IErrorHandler } from '../src/types/ErrorHandler';
+import { defaultHttpClient } from './HttpClient';
 
 // Mock all the methods of the ErrorHandler class
 class ErrorHandler implements IErrorHandler {
   onError = jest.fn();
   leaveBreadcrumb = jest.fn();
-  notifyError = jest.fn();
-  init = jest.fn();
-  attachErrorListeners = jest.fn();
-  errorBuffer = new BufferQueue<PreLoadErrorData>();
+  httpClient = defaultHttpClient;
 }
 
 const defaultErrorHandler = new ErrorHandler();

packages/analytics-js-plugins/__mocks__/HttpClient.ts → packages/analytics-js-common/__mocks__/HttpClient.ts

@@ -10,6 +10,7 @@ class HttpClient implements IHttpClient {
   getAsyncData = jest.fn();
   setAuthHeader = jest.fn();
   resetAuthHeader = jest.fn();
+  init = jest.fn();
 }
 
 const defaultHttpClient = new HttpClient();

packages/analytics-js-common/__tests__/utilities/errors.test.ts

@@ -1,18 +1,90 @@
-import { dispatchErrorEvent } from '../../src/utilities/errors';
+import { dispatchErrorEvent, getStacktrace } from '../../src/utilities/errors';
 
 describe('Errors - utilities', () => {
   describe('dispatchErrorEvent', () => {
+    const dispatchEventMock = jest.fn();
+    const originalDispatchEvent = globalThis.dispatchEvent;
+
+    beforeEach(() => {
+      globalThis.dispatchEvent = dispatchEventMock;
+    });
+
+    afterEach(() => {
+      globalThis.dispatchEvent = originalDispatchEvent;
+    });
+
     it('should dispatch an error event', () => {
-      const dispatchEvent = jest.fn();
-      const originalDispatchEvent = globalThis.dispatchEvent;
+      const error = new Error('Test error');
+
+      dispatchErrorEvent(error);
+
+      expect(dispatchEventMock).toHaveBeenCalledWith(new ErrorEvent('error', { error }));
+      expect((error.stack as string).endsWith('[SDK DISPATCHED ERROR]')).toBeTruthy();
+    });
 
-      globalThis.dispatchEvent = dispatchEvent;
+    it('should decorate stacktrace before dispatching error event', () => {
       const error = new Error('Test error');
+      // @ts-expect-error need to set the value for testing
+      error.stacktrace = error.stack;
+      delete error.stack;
+
       dispatchErrorEvent(error);
-      expect(dispatchEvent).toHaveBeenCalledWith(new ErrorEvent('error', { error }));
 
-      // Cleanup
-      globalThis.dispatchEvent = originalDispatchEvent;
+      // @ts-expect-error need to check the stacktrace property
+      expect((error.stacktrace as string).endsWith('[SDK DISPATCHED ERROR]')).toBeTruthy();
+    });
+
+    it('should decorate opera sourceloc before dispatching error event', () => {
+      const error = new Error('Test error');
+      // @ts-expect-error need to set the value for testing
+      error['opera#sourceloc'] = error.stack;
+      delete error.stack;
+
+      dispatchErrorEvent(error);
+
+      // @ts-expect-error need to check the opera sourceloc property
+      expect((error['opera#sourceloc'] as string).endsWith('[SDK DISPATCHED ERROR]')).toBeTruthy();
+    });
+  });
+
+  describe('getStacktrace', () => {
+    it('should return stack if it is a string', () => {
+      const error = new Error('Test error');
+      expect(getStacktrace(error)).toBe(error.stack);
+    });
+
+    it('should return stacktrace if it is a string', () => {
+      const error = new Error('Test error');
+      // @ts-expect-error need to set the value for testing
+      error.stacktrace = error.stack;
+      delete error.stack;
+
+      // @ts-expect-error need to check the stacktrace property
+      expect(getStacktrace(error)).toBe(error.stacktrace);
+    });
+
+    it('should return opera sourceloc if it is a string', () => {
+      const error = new Error('Test error');
+      // @ts-expect-error need to set the value for testing
+      error['opera#sourceloc'] = error.stack;
+      delete error.stack;
+
+      // @ts-expect-error need to check the opera sourceloc property
+      expect(getStacktrace(error)).toBe(error['opera#sourceloc']);
+    });
+
+    it('should return undefined if none of the properties are strings', () => {
+      const error = new Error('Test error');
+      delete error.stack;
+
+      expect(getStacktrace(error)).toBeUndefined();
+    });
+
+    it('should return undefined if stack is the same as name and message', () => {
+      const error = new Error('Test error');
+      error.stack = `${error.name}: ${error.message}`;
+
+      expect(getStacktrace(error)).toBeUndefined();
     });
   });
 });

packages/analytics-js-common/src/services/ExternalSrcLoader/types.ts

@@ -1,4 +1,4 @@
-import type { ErrorState } from '../../types/ErrorHandler';
+import type { ErrorState, IErrorHandler } from '../../types/ErrorHandler';
 import type { ILogger } from '../../types/Logger';
 
 export interface IExternalSourceLoadConfig {
@@ -11,16 +11,7 @@ export interface IExternalSourceLoadConfig {
 }
 
 export interface IExternalSrcLoader {
-  errorHandler?: {
-    onError(
-      error: unknown,
-      context?: string,
-      customMessage?: string,
-      shouldAlwaysThrow?: boolean,
-    ): void;
-    leaveBreadcrumb(breadcrumb: string): void;
-    notifyError(error: Error, errorState: ErrorState): void;
-  };
+  errorHandler?: IErrorHandler;
   logger?: ILogger;
   timeout: number;
   loadJSFile(config: IExternalSourceLoadConfig): void;

packages/analytics-js-common/src/types/ApplicationState.ts

@@ -145,7 +145,6 @@ export type Breadcrumb = {
 export type ReportingState = {
   isErrorReportingEnabled: Signal<boolean>;
   isMetricsReportingEnabled: Signal<boolean>;
-  isErrorReportingPluginLoaded: Signal<boolean>;
   breadcrumbs: Signal<Breadcrumb[]>;
 };
 

packages/analytics-js-common/src/types/ErrorHandler.ts

@@ -1,26 +1,13 @@
-import type { IPluginEngine } from './PluginEngine';
 import type { ILogger } from './Logger';
-import type { BufferQueue } from '../services/BufferQueue/BufferQueue';
 import type { IHttpClient } from './HttpClient';
-import type { IExternalSrcLoader } from '../services/ExternalSrcLoader/types';
 
 export type SDKError = unknown | Error | ErrorEvent | Event | PromiseRejectionEvent;
 
 export interface IErrorHandler {
+  httpClient: IHttpClient;
   logger?: ILogger;
-  pluginEngine?: IPluginEngine;
-  errorBuffer: BufferQueue<PreLoadErrorData>;
-  init(httpClient: IHttpClient, externalSrcLoader: IExternalSrcLoader): void;
-  onError(
-    error: SDKError,
-    context?: string,
-    customMessage?: string,
-    shouldAlwaysThrow?: boolean,
-    errorType?: string,
-  ): void;
+  onError(error: SDKError, context?: string, customMessage?: string, errorType?: string): void;
   leaveBreadcrumb(breadcrumb: string): void;
-  notifyError(error: Error, errorState: ErrorState): void;
-  attachErrorListeners(): void;
 }
 
 export type ErrorState = {

packages/analytics-js-common/src/types/HttpClient.ts

@@ -65,4 +65,5 @@ export interface IHttpClient {
   getAsyncData<T = any>(config: IAsyncRequestConfig<T>): void;
   setAuthHeader(value: string, noBto?: boolean): void;
   resetAuthHeader(): void;
+  init(errorHandler: IErrorHandler): void;
 }

packages/analytics-js-common/src/types/Metrics.ts

@@ -13,23 +13,24 @@ export type MetricServicePayload = {
 };
 
 export type ErrorEventPayload = {
+  payloadVersion: string;
   notifier: {
     name: string;
     version: string;
     url: string;
   };
-  events: ErrorEventType[];
+  events: ErrorEvent[];
 };
 
-export type ErrorEventType = {
-  payloadVersion: string;
+export type ErrorEvent = {
   exceptions: Exception[];
   severity: string;
   unhandled: boolean;
   severityReason: { type: string };
   app: {
     version: string;
     releaseStage: string;
+    type: string;
   };
   device: {
     locale?: string;
@@ -41,25 +42,19 @@ export type ErrorEventType = {
     clientIp: string;
   };
   breadcrumbs: Breadcrumb[] | [];
-  context: string;
   metaData: {
     [index: string]: any;
   };
   user: {
     id: string;
+    name: string;
   };
 };
 
 export type GeneratedEventType = {
   errors: Exception[];
 };
 
-export interface Exception {
-  message: string;
-  errorClass: string;
-  type: string;
-  stacktrace: Stackframe[];
-}
 export interface Stackframe {
   file: string;
   method?: string;
@@ -68,3 +63,10 @@ export interface Stackframe {
   code?: Record<string, string>;
   inProject?: boolean;
 }
+
+export interface Exception {
+  message: string;
+  errorClass: string;
+  type: string;
+  stacktrace: Stackframe[];
+}

packages/analytics-js-common/src/types/PluginsManager.ts

@@ -13,11 +13,9 @@ export interface IPluginsManager {
 
 export type PluginName =
   | 'BeaconQueue'
-  | 'Bugsnag'
   | 'CustomConsentManager'
   | 'DeviceModeDestinations'
   | 'DeviceModeTransformation'
-  | 'ErrorReporting'
   | 'ExternalAnonymousId'
   | 'GoogleLinker'
   | 'IubendaConsentManager'

packages/analytics-js-common/src/types/Source.ts

@@ -15,5 +15,6 @@ export type SourceConfig = {
 export type Source = {
   id: string;
   config?: SourceConfig;
+  name: string;
   workspaceId: string;
 };

packages/analytics-js-common/src/utilities/checks.ts

@@ -65,11 +65,20 @@ const isDefinedNotNullAndNotEmptyString = (value: any): boolean =>
   isDefinedAndNotNull(value) && value !== '';
 
 /**
- * Determines if the input is an instance of Error
- * @param obj input value
- * @returns true if the input is an instance of Error and false otherwise
+ * Determines if the input is of type error
+ * @param value input value
+ * @returns true if the input is of type error else false
  */
-const isTypeOfError = (obj: any): obj is Error => obj instanceof Error;
+const isTypeOfError = (value: any): boolean => {
+  switch (Object.prototype.toString.call(value)) {
+    case '[object Error]':
+    case '[object Exception]':
+    case '[object DOMException]':
+      return true;
+    default:
+      return value instanceof Error;
+  }
+};
 
 export {
   isFunction,

packages/analytics-js-common/src/utilities/errors.ts

@@ -1,7 +1,19 @@
 import { isTypeOfError } from './checks';
 import { stringifyWithoutCircular } from './json';
 
-const MANUAL_ERROR_IDENTIFIER = '[MANUAL ERROR]';
+const MANUAL_ERROR_IDENTIFIER = '[SDK DISPATCHED ERROR]';
+
+const getStacktrace = (err: any): string | undefined => {
+  const { stack, stacktrace, name, message } = err;
+  const operaSourceloc = err['opera#sourceloc'];
+
+  const stackString = stack ?? stacktrace ?? operaSourceloc;
+
+  if (!!stackString && typeof stackString === 'string' && stack !== `${name}: ${message}`) {
+    return stackString;
+  }
+  return undefined;
+};
 
 /**
  * Get mutated error with issue prepended to error message
@@ -21,9 +33,30 @@ const getMutatedError = (err: any, issue: string): Error => {
 
 const dispatchErrorEvent = (error: any) => {
   if (isTypeOfError(error)) {
-    error.stack = `${error.stack ?? ''}\n${MANUAL_ERROR_IDENTIFIER}`;
+    const errStack = getStacktrace(error);
+    if (errStack) {
+      const { stack, stacktrace } = error;
+      const operaSourceloc = error['opera#sourceloc'];
+
+      switch (errStack) {
+        case stack:
+          // eslint-disable-next-line no-param-reassign
+          error.stack = `${stack}\n${MANUAL_ERROR_IDENTIFIER}`;
+          break;
+        case stacktrace:
+          // eslint-disable-next-line no-param-reassign
+          error.stacktrace = `${stacktrace}\n${MANUAL_ERROR_IDENTIFIER}`;
+          break;
+        case operaSourceloc:
+        default:
+          // eslint-disable-next-line no-param-reassign
+          error['opera#sourceloc'] = `${operaSourceloc}\n${MANUAL_ERROR_IDENTIFIER}`;
+          break;
+      }
+    }
   }
+
   (globalThis as typeof window).dispatchEvent(new ErrorEvent('error', { error }));
 };
 
-export { getMutatedError, dispatchErrorEvent, MANUAL_ERROR_IDENTIFIER };
+export { getMutatedError, dispatchErrorEvent, MANUAL_ERROR_IDENTIFIER, getStacktrace };