feat: error reporting plugin

jest/jest.setup-dom.js

@@ -8,6 +8,9 @@ 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;
+};
 
 // TODO: remove once we use globalThis in analytics v1.1 too
 // Setup mocking for window.navigator

package.json

@@ -85,6 +85,7 @@
     "crypto-es": "2.1.0",
     "crypto-js": "4.2.0",
     "deep-object-diff": "1.1.9",
+    "error-stack-parser": "2.1.4",
     "get-value": "3.0.1",
     "is": "3.3.0",
     "join-component": "1.1.0",

packages/analytics-js-common/src/constants/metrics.ts

@@ -0,0 +1,3 @@
+const METRICS_PAYLOAD_VERSION = '1';
+
+export { METRICS_PAYLOAD_VERSION };

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

@@ -1,3 +1,4 @@
+import type { ErrorState } from '@rudderstack/analytics-js-common/types/ErrorHandler';
 import type { ILogger } from '../../types/Logger';
 
 export interface IExternalSourceLoadConfig {
@@ -18,7 +19,7 @@ export interface IExternalSrcLoader {
       shouldAlwaysThrow?: boolean,
     ): void;
     leaveBreadcrumb(breadcrumb: string): void;
-    notifyError(error: Error): void;
+    notifyError(error: Error, errorState: ErrorState): void;
   };
   logger?: ILogger;
   timeout: number;

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

@@ -119,11 +119,22 @@ export type PluginsState = {
   totalPluginsToLoad: Signal<number>;
 };
 
+export type BreadcrumbMetaData = {
+  [index: string]: any;
+};
+export type BreadcrumbType = 'error' | 'manual';
+export type Breadcrumb = {
+  type: BreadcrumbType;
+  name: string;
+  timestamp: Date;
+  metaData: BreadcrumbMetaData;
+};
+
 export type ReportingState = {
   isErrorReportingEnabled: Signal<boolean>;
   isMetricsReportingEnabled: Signal<boolean>;
-  errorReportingProviderPluginName: Signal<PluginName | undefined>;
   isErrorReportingPluginLoaded: Signal<boolean>;
+  breadcrumbs: Signal<Breadcrumb[]>;
 };
 
 export type SessionState = {

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

@@ -1,15 +1,16 @@
 import type { IPluginEngine } from './PluginEngine';
 import type { ILogger } from './Logger';
-import type { IExternalSrcLoader } from '../services/ExternalSrcLoader/types';
 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 {
   logger?: ILogger;
   pluginEngine?: IPluginEngine;
   errorBuffer: BufferQueue<PreLoadErrorData>;
-  init(externalSrcLoader: IExternalSrcLoader): void;
+  init(httpClient: IHttpClient, externalSrcLoader: IExternalSrcLoader): void;
   onError(
     error: SDKError,
     context?: string,
@@ -18,7 +19,7 @@
     errorType?: string,
   ): void;
   leaveBreadcrumb(breadcrumb: string): void;
-  notifyError(error: Error): void;
+  notifyError(error: Error, errorState: ErrorState): void;
   attachErrorListeners(): void;
 }
 
@@ -37,3 +38,9 @@
   error: SDKError;
   errorState: ErrorState;
 };
+
+export enum ErrorType {
+  HANDLEDEXCEPTION = 'handledException',
+  UNHANDLEDEXCEPTION = 'unhandledException',
+  UNHANDLEDREJECTION = 'unhandledPromiseRejection',
+}

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

@@ -0,0 +1,70 @@
+import type { Breadcrumb } from './ApplicationState';
+
+export type MetricServicePayload = {
+  version: string;
+  message_id: string;
+  source: {
+    name: string;
+    sdk_version: string;
+    write_key: string;
+    install_type: string;
+  };
+  errors?: ErrorEventPayload;
+};
+
+export type ErrorEventPayload = {
+  notifier: {
+    name: string;
+    version: string;
+    url: string;
+  };
+  events: ErrorEventType[];
+};
+
+export type ErrorEventType = {
+  payloadVersion: string;
+  exceptions: Exception[];
+  severity: string;
+  unhandled: boolean;
+  severityReason: { type: string };
+  app: {
+    version: string;
+    releaseStage: string;
+  };
+  device: {
+    locale?: string;
+    userAgent?: string;
+    time?: Date;
+  };
+  request: {
+    url: string;
+    clientIp: string;
+  };
+  breadcrumbs: Breadcrumb[] | [];
+  context: string;
+  metaData: {
+    [index: string]: any;
+  };
+  user: {
+    id: string;
+  };
+};
+
+export type GeneratedEventType = {
+  errors: Exception[];
+};
+
+export interface Exception {
+  message: string;
+  errorClass: string;
+  type: string;
+  stacktrace: Stackframe[];
+}
+export interface Stackframe {
+  file: string;
+  method?: string;
+  lineNumber?: number;
+  columnNumber?: number;
+  code?: Record<string, string>;
+  inProject?: boolean;
+}

packages/analytics-js-plugins/.size-limit.mjs

@@ -11,7 +11,7 @@ export default [
   {
     name: 'Plugins - Legacy - CDN',
     path: 'dist/cdn/legacy/plugins/rsa-plugins-*.min.js',
-    limit: '15 KiB',
+    limit: '16 KiB',
   },
   {
     name: 'Plugins Module Federation Mapping - Modern - CDN',
@@ -21,6 +21,6 @@ export default [
   {
     name: 'Plugins - Modern - CDN',
     path: 'dist/cdn/modern/plugins/rsa-plugins-*.min.js',
-    limit: '6 KiB',
+    limit: '7.5 KiB',
   },
 ];

packages/analytics-js-plugins/__tests__/errorReporting/index.test.ts

@@ -1,5 +1,6 @@
 import { signal } from '@preact/signals-core';
 import { clone } from 'ramda';
+import type { IHttpClient } from '@rudderstack/analytics-js-common/types/HttpClient';
 import { ErrorReporting } from '../../src/errorReporting';
 
 describe('Plugin - ErrorReporting', () => {
@@ -10,6 +11,15 @@ describe('Plugin - ErrorReporting', () => {
     lifecycle: {
       writeKey: signal('dummy-write-key'),
     },
+    reporting: {
+      isErrorReportingPluginLoaded: signal(false),
+      breadcrumbs: signal([]),
+    },
+    context: {
+      locale: signal('en-GB'),
+      userAgent: signal('sample user agent'),
+      app: signal({ version: 'sample_version', installType: 'sample_installType' }),
+    },
     source: signal({
       id: 'test-source-id',
       config: {},
@@ -18,6 +28,7 @@ describe('Plugin - ErrorReporting', () => {
 
   let state: any;
 
+  // Deprecated code
   const mockPluginEngine = {
     invokeSingle: jest.fn(() => Promise.resolve()),
   };
@@ -31,6 +42,7 @@ describe('Plugin - ErrorReporting', () => {
     notify: jest.fn(),
     leaveBreadcrumb: jest.fn(),
   };
+  // End of deprecated code
 
   beforeEach(() => {
     state = clone(originalState);
@@ -39,64 +51,79 @@ describe('Plugin - ErrorReporting', () => {
   it('should add ErrorReporting plugin in the loaded plugin list', () => {
     ErrorReporting().initialize(state);
     expect(state.plugins.loadedPlugins.value.includes('ErrorReporting')).toBe(true);
+    expect(state.reporting.isErrorReportingPluginLoaded.value).toBe(true);
+    expect(state.reporting.breadcrumbs.value[0].name).toBe('Error Reporting Plugin Loaded');
   });
 
-  it('should reject the promise if source information is not available', async () => {
-    state.source.value = null;
-
-    const pluginInitPromise = ErrorReporting().errorReporting.init(state);
-
-    await expect(pluginInitPromise).rejects.toThrow('Invalid source configuration or source id.');
-  });
-
-  it('should invoke the error reporting provider plugin on init', async () => {
-    const pluginInitPromise = ErrorReporting().errorReporting.init(
+  it('should invoke the error reporting provider plugin on notify', () => {
+    const mockHttpClient = {
+      getAsyncData: jest.fn(),
+      setAuthHeader: jest.fn(),
+    } as unknown as IHttpClient;
+    const newError = new Error();
+    const normalizedError = Object.create(newError, {
+      message: { value: 'ReferenceError: testUndefinedFn is not defined' },
+      stack: {
+        value: `ReferenceError: testUndefinedFn is not defined at Analytics.page (http://localhost:3001/cdn/modern/iife/rsa.js:1610:3) at RudderAnalytics.page (http://localhost:3001/cdn/modern/iife/rsa.js:1666:84)`,
+      },
+    });
+    ErrorReporting().errorReporting.notify(
+      {},
+      undefined,
+      normalizedError,
       state,
-      mockPluginEngine,
-      mockExtSrcLoader,
-      mockLogger,
+      undefined,
+      mockHttpClient,
+      {
+        severity: 'error',
+        unhandled: false,
+        severityReason: { type: 'handledException' },
+      },
     );
 
-    await expect(pluginInitPromise).resolves.toBeUndefined(); // because it's just a mock
-    expect(mockPluginEngine.invokeSingle).toHaveBeenCalledWith(
-      'errorReportingProvider.init',
-      state,
-      mockExtSrcLoader,
-      mockLogger,
-    );
+    expect(mockHttpClient.getAsyncData).toHaveBeenCalled();
   });
 
-  it('should invoke the error reporting provider plugin on notify', () => {
+  it('should not notify if the error is not an SDK error', () => {
+    const mockHttpClient = {
+      getAsyncData: jest.fn(),
+      setAuthHeader: jest.fn(),
+    } as unknown as IHttpClient;
+    const newError = new Error();
+    const normalizedError = Object.create(newError, {
+      message: { value: 'ReferenceError: testUndefinedFn is not defined' },
+      stack: {
+        value: `ReferenceError: testUndefinedFn is not defined at Abcd.page (http://localhost:3001/cdn/modern/iife/abc.js:1610:3) at xyz.page (http://localhost:3001/cdn/modern/iife/abc.js:1666:84)`,
+      },
+    });
     ErrorReporting().errorReporting.notify(
-      mockPluginEngine,
-      mockErrReportingProviderClient,
-      new Error('dummy error'),
+      {},
+      undefined,
+      normalizedError,
       state,
-      mockLogger,
+      undefined,
+      mockHttpClient,
+      {
+        severity: 'error',
+        unhandled: false,
+        severityReason: { type: 'handledException' },
+      },
     );
 
-    expect(mockPluginEngine.invokeSingle).toHaveBeenCalledWith(
-      'errorReportingProvider.notify',
-      mockErrReportingProviderClient,
-      new Error('dummy error'),
-      state,
-      mockLogger,
-    );
+    expect(mockHttpClient.getAsyncData).not.toHaveBeenCalled();
   });
 
-  it('should invoke the error reporting provider plugin on breadcrumb', () => {
-    ErrorReporting().errorReporting.breadcrumb(
-      mockPluginEngine,
-      mockErrReportingProviderClient,
-      'dummy breadcrumb',
-      mockLogger,
-    );
+  it('should add a new breadcrumb', () => {
+    const breadcrumbLength = state.reporting.breadcrumbs.value.length;
+    ErrorReporting().errorReporting.breadcrumb({}, undefined, 'dummy breadcrumb', undefined, state);
 
-    expect(mockPluginEngine.invokeSingle).toHaveBeenCalledWith(
-      'errorReportingProvider.breadcrumb',
-      mockErrReportingProviderClient,
-      'dummy breadcrumb',
-      mockLogger,
-    );
+    expect(state.reporting.breadcrumbs.value.length).toBe(breadcrumbLength + 1);
+  });
+
+  it('should not add a new breadcrumb if the message is missing', () => {
+    const breadcrumbLength = state.reporting.breadcrumbs.value.length;
+    ErrorReporting().errorReporting.breadcrumb({}, undefined, undefined, undefined, state);
+
+    expect(state.reporting.breadcrumbs.value.length).not.toBe(breadcrumbLength + 1);
   });
 });