fix: error filtering of non-errors

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

@@ -0,0 +1,4 @@
+const FAILED_REQUEST_ERR_MSG_PREFIX = 'The request failed';
+const ERROR_MESSAGES_TO_BE_FILTERED = [FAILED_REQUEST_ERR_MSG_PREFIX];
+
+export { FAILED_REQUEST_ERR_MSG_PREFIX, ERROR_MESSAGES_TO_BE_FILTERED };

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

@@ -12,6 +12,7 @@ import {
   getBugsnagErrorEvent,
   getErrorDeliveryPayload,
   getConfigForPayloadCreation,
+  isAllowedToBeNotified,
 } from '../../src/errorReporting/utils';
 
 jest.mock('@rudderstack/analytics-js-common/utilities/uuId', () => ({
@@ -548,4 +549,31 @@ describe('Error Reporting utilities', () => {
       });
     });
   });
+
+  describe('ErrorHandler - isAllowedToBeNotified', () => {
+    it('should return true for Error argument value', () => {
+      const result = isAllowedToBeNotified(new Error('dummy error'));
+      expect(result).toBeTruthy();
+    });
+
+    it('should return true for Error argument value', () => {
+      const result = isAllowedToBeNotified(new Error('The request failed'));
+      expect(result).toBeFalsy();
+    });
+
+    it('should return true for ErrorEvent argument value', () => {
+      const result = isAllowedToBeNotified(new ErrorEvent('dummy error'));
+      expect(result).toBeTruthy();
+    });
+
+    it('should return true for PromiseRejectionEvent argument value', () => {
+      const result = isAllowedToBeNotified(new PromiseRejectionEvent('dummy error'));
+      expect(result).toBeTruthy();
+    });
+
+    it('should return true for PromiseRejectionEvent argument value', () => {
+      const result = isAllowedToBeNotified(new PromiseRejectionEvent('The request failed'));
+      expect(result).toBeFalsy();
+    });
+  });
 });

packages/analytics-js-plugins/src/errorReporting/event/event.ts

@@ -64,71 +64,22 @@ const hasNecessaryFields = (error: any) =>
   (typeof error.name === 'string' || typeof error.errorClass === 'string') &&
   (typeof error.message === 'string' || typeof error.errorMessage === 'string');
 
-const normaliseError = (
-  maybeError: any,
-  tolerateNonErrors: boolean,
-  component: string,
-  logger?: ILogger,
-) => {
+const normaliseError = (maybeError: any, logger?: ILogger) => {
   let error;
   let internalFrames = 0;
 
-  const createAndLogInputError = (reason: string) => {
-    const verb = component === 'error cause' ? 'was' : 'received';
-    if (logger) logger.warn(`${component} ${verb} a non-error: "${reason}"`);
-    const err = new Error(
-      `${component} ${verb} a non-error. See "${component}" tab for more detail.`,
-    );
-    err.name = 'InvalidError';
-    return err;
-  };
-
-  // In some cases:
-  //
-  //  - the promise rejection handler (both in the browser and node)
-  //  - the node uncaughtException handler
-  //
-  // We are really limited in what we can do to get a stacktrace. So we use the
-  // tolerateNonErrors option to ensure that the resulting error communicates as
-  // such.
-  if (!tolerateNonErrors) {
-    if (isError(maybeError)) {
-      error = maybeError;
-    } else {
-      error = createAndLogInputError(typeof maybeError);
-      internalFrames += 2;
-    }
+  if (maybeError !== null && isError(maybeError)) {
+    error = maybeError;
+  } else if (maybeError !== null && hasNecessaryFields(maybeError)) {
+    error = new Error(maybeError.message || maybeError.errorMessage);
+    error.name = maybeError.name || maybeError.errorClass;
+    internalFrames += 1;
   } else {
-    switch (typeof maybeError) {
-      case 'string':
-      case 'number':
-      case 'boolean':
-        error = new Error(String(maybeError));
-        internalFrames += 1;
-        break;
-      case 'function':
-        error = createAndLogInputError('function');
-        internalFrames += 2;
-        break;
-      case 'object':
-        if (maybeError !== null && isError(maybeError)) {
-          error = maybeError;
-        } else if (maybeError !== null && hasNecessaryFields(maybeError)) {
-          error = new Error(maybeError.message || maybeError.errorMessage);
-          error.name = maybeError.name || maybeError.errorClass;
-          internalFrames += 1;
-        } else {
-          error = createAndLogInputError(maybeError === null ? 'null' : 'unsupported object');
-          internalFrames += 2;
-        }
-        break;
-      default:
-        error = createAndLogInputError('nothing');
-        internalFrames += 2;
-    }
+    if (logger) logger.warn(error);
+    error = undefined;
   }
 
-  if (!hasStack(error)) {
+  if (error && !hasStack(error)) {
     // in IE10/11 a new Error() doesn't have a stacktrace until you throw it, so try that here
     try {
       throw error;
@@ -137,7 +88,7 @@ const normaliseError = (
         error = e;
         // if the error only got a stacktrace after we threw it here, we know it
         // will only have one extra internal frame from this function, regardless
-        // of whether it went through createAndLogInputError() or not
+        // of whether it went through logInputError() or not
         internalFrames = 1;
       }
     }
@@ -160,12 +111,10 @@ class ErrorFormat implements IErrorFormat {
     errorFramesToSkip = 0,
     logger?: ILogger,
   ) {
-    const [error, internalFrames] = normaliseError(
-      maybeError,
-      tolerateNonErrors,
-      component,
-      logger,
-    );
+    const [error, internalFrames] = normaliseError(maybeError, logger);
+    if (!error) {
+      return undefined;
+    }
     let event;
     try {
       const stacktrace = getStacktrace(

packages/analytics-js-plugins/src/errorReporting/index.ts

@@ -19,6 +19,7 @@
   isRudderSDKError,
   getBugsnagErrorEvent,
   getErrorDeliveryPayload,
+  isAllowedToBeNotified,
 } from './utils';
 import { REQUEST_TIMEOUT_MS } from './constants';
 import { ErrorFormat } from './event/event';
@@ -73,6 +74,9 @@
         const { component, tolerateNonErrors, errorFramesToSkip, normalizedError } =
           getConfigForPayloadCreation(error, errorState?.severityReason.type as string);
 
+        if (!isAllowedToBeNotified(error)) {
+          return;
+        }
         // Generate the error payload
         const errorPayload = ErrorFormat.create(
           normalizedError,
@@ -84,7 +88,7 @@
         );
 
         // filter errors
-        if (!isRudderSDKError(errorPayload.errors[0])) {
+        if (!errorPayload || !isRudderSDKError(errorPayload.errors[0])) {
           return;
         }
 

packages/analytics-js-plugins/src/errorReporting/utils.ts

@@ -17,6 +17,7 @@ import type {
 import { generateUUID } from '@rudderstack/analytics-js-common/utilities/uuId';
 import { METRICS_PAYLOAD_VERSION } from '@rudderstack/analytics-js-common/constants/metrics';
 import { stringifyWithoutCircular } from '@rudderstack/analytics-js-common/utilities/json';
+import { ERROR_MESSAGES_TO_BE_FILTERED } from '@rudderstack/analytics-js-common/constants/errors';
 import {
   APP_STATE_EXCLUDE_KEYS,
   DEV_HOSTS,
@@ -142,6 +143,26 @@ const getBugsnagErrorEvent = (
   ],
 });
 
+/**
+ * A function to determine whether the error should be promoted to notify or not
+ * @param {Error} error
+ * @returns
+ */
+const isAllowedToBeNotified = (error: SDKError) => {
+  if ((error instanceof Error || error instanceof ErrorEvent) && error.message) {
+    return !ERROR_MESSAGES_TO_BE_FILTERED.some(e => error.message.includes(e));
+  }
+  if (error instanceof PromiseRejectionEvent && typeof error.reason === 'string') {
+    return !ERROR_MESSAGES_TO_BE_FILTERED.some(e => error.reason.includes(e));
+  }
+  return true;
+};
+
+/**
+ * A function to determine if the error is from Rudder SDK
+ * @param {Error} event
+ * @returns
+ */
 const isRudderSDKError = (event: any) => {
   const errorOrigin = event.stacktrace?.[0]?.file;
 
@@ -188,4 +209,5 @@ export {
   isRudderSDKError,
   getErrorDeliveryPayload,
   getErrorContext,
+  isAllowedToBeNotified,
 };

packages/analytics-js/__tests__/components/configManager/commonUtil.test.ts

@@ -110,7 +110,7 @@ describe('Config Manager Common Utilities', () => {
 
       updateReportingState(mockSourceConfig, mockLogger);
 
-      // expect(state.reporting.isErrorReportingEnabled.value).toBe(true); // TODO: uncomment this line when error reporting is enabled
+      expect(state.reporting.isErrorReportingEnabled.value).toBe(true);
       expect(state.reporting.isMetricsReportingEnabled.value).toBe(true);
       expect(mockLogger.warn).not.toHaveBeenCalled();
     });
@@ -133,7 +133,7 @@ describe('Config Manager Common Utilities', () => {
 
       updateReportingState(mockSourceConfig, mockLogger);
 
-      // expect(state.reporting.isErrorReportingEnabled.value).toBe(true); // TODO: uncomment this line when error reporting is enabled
+      expect(state.reporting.isErrorReportingEnabled.value).toBe(true);
       expect(state.reporting.isMetricsReportingEnabled.value).toBe(true);
       expect(mockLogger.warn).not.toHaveBeenCalled();
     });

packages/analytics-js/__tests__/services/ErrorHandler/processError.test.ts

@@ -1,7 +1,6 @@
 import {
   processError,
   getNormalizedErrorForUnhandledError,
-  isAllowedToBeNotified,
 } from '../../../src/services/ErrorHandler/processError';
 
 jest.mock('../../../src/components/utilities/event', () => {
@@ -95,7 +94,7 @@ describe('ErrorHandler - getNormalizedErrorForUnhandledError', () => {
     expect(normalizedError).toBeUndefined();
   });
 
-  it.skip('should return error instance for Event argument value with SDK script target', () => {
+  it('should return error instance for Event argument value with SDK script target', () => {
     const event = new Event('dummyError');
     const targetElement = document.createElement('script');
     targetElement.dataset.loader = 'RS_JS_SDK';
@@ -116,30 +115,3 @@ describe('ErrorHandler - getNormalizedErrorForUnhandledError', () => {
     );
   });
 });
-
-describe('ErrorHandler - isAllowedToBeNotified', () => {
-  it('should return true for Error argument value', () => {
-    const result = isAllowedToBeNotified(new Error('dummy error'));
-    expect(result).toBeTruthy();
-  });
-
-  it('should return true for Error argument value', () => {
-    const result = isAllowedToBeNotified(new Error('The request failed'));
-    expect(result).toBeFalsy();
-  });
-
-  it('should return true for ErrorEvent argument value', () => {
-    const result = isAllowedToBeNotified(new ErrorEvent('dummy error'));
-    expect(result).toBeTruthy();
-  });
-
-  it('should return true for PromiseRejectionEvent argument value', () => {
-    const result = isAllowedToBeNotified(new PromiseRejectionEvent('dummy error'));
-    expect(result).toBeTruthy();
-  });
-
-  it('should return true for PromiseRejectionEvent argument value', () => {
-    const result = isAllowedToBeNotified(new PromiseRejectionEvent('The request failed'));
-    expect(result).toBeFalsy();
-  });
-});

packages/analytics-js/src/components/configManager/util/commonUtil.ts

@@ -73,10 +73,8 @@ const getSDKUrl = (): string | undefined => {
  * @param logger Logger instance
  */
 const updateReportingState = (res: SourceConfigResponse): void => {
-  state.reporting.isErrorReportingEnabled.value = false;
-  // TODO: Enable this once the error reporting is tested properly
-  // state.reporting.isErrorReportingEnabled.value =
-  //   isErrorReportingEnabled(res.source.config) && !isSDKRunningInChromeExtension();
+  state.reporting.isErrorReportingEnabled.value =
+    isErrorReportingEnabled(res.source.config) && !isSDKRunningInChromeExtension();
   state.reporting.isMetricsReportingEnabled.value = isMetricsReportingEnabled(res.source.config);
 };
 

packages/analytics-js/src/services/ErrorHandler/ErrorHandler.ts

@@ -21,11 +21,7 @@ import {
 import { state } from '../../state';
 import { defaultPluginEngine } from '../PluginEngine';
 import { defaultLogger } from '../Logger';
-import {
-  isAllowedToBeNotified,
-  getNormalizedErrorForUnhandledError,
-  processError,
-} from './processError';
+import { getNormalizedErrorForUnhandledError, processError } from './processError';
 
 /**
  * A service to handle errors
@@ -204,7 +200,7 @@ class ErrorHandler implements IErrorHandler {
    * @param {Error} error Error instance from handled error
    */
   notifyError(error: SDKError, errorState: ErrorState) {
-    if (this.pluginEngine && this.httpClient && isAllowedToBeNotified(error)) {
+    if (this.pluginEngine && this.httpClient) {
       try {
         this.pluginEngine.invokeSingle(
           'errorReporting.notify',