feat: Allow to pass errorHandler as record option

packages/rrweb/src/record/errorHandler.ts

@@ -0,0 +1,37 @@
+import type { ErrorHandler } from '../types';
+
+type Callback = (...args: unknown[]) => unknown;
+
+let errorHandler: ErrorHandler | undefined;
+
+export function registerErrorHandler(handler: ErrorHandler | undefined) {
+  errorHandler = handler;
+}
+
+export function unregisterErrorHandler() {
+  errorHandler = undefined;
+}
+
+/**
+ * Wrap callbacks in a wrapper that allows to pass errors to a configured `errorHandler` method.
+ */
+
+export const callbackWrapper = <T extends Callback>(cb: T): T => {
+  if (!errorHandler) {
+    return cb;
+  }
+
+  const rrwebWrapped = (((...rest: unknown[]) => {
+    try {
+      return cb(...rest);
+    } catch (error) {
+      if (errorHandler && errorHandler(error) === true) {
+        return;
+      }
+
+      throw error;
+    }
+  }) as unknown) as T;
+
+  return rrwebWrapped;
+};

packages/rrweb/src/record/index.ts

@@ -36,6 +36,7 @@ import { IframeManager } from './iframe-manager';
 import { ShadowDomManager } from './shadow-dom-manager';
 import { CanvasManager } from './observers/canvas/canvas-manager';
 import { StylesheetManager } from './stylesheet-manager';
+import { callbackWrapper, registerErrorHandler, unregisterErrorHandler } from './errorHandler';
 
 function wrapEvent(e: event): eventWithTime {
   return {
@@ -82,8 +83,11 @@ function record<T = eventWithTime>(
     plugins,
     keepIframeSrcFn = () => false,
     ignoreCSSAttributes = new Set([]),
+    errorHandler,
   } = options;
 
+  registerErrorHandler(errorHandler);
+
   const inEmittingFrame = recordCrossOriginIframes
     ? window.parent === window
     : true;
@@ -420,7 +424,7 @@ function record<T = eventWithTime>(
     );
 
     const observe = (doc: Document) => {
-      return initObservers(
+      return callbackWrapper(initObservers)(
         {
           mutationCb: wrappedMutationEmit,
           mousemoveCb: (positions, source) =>
@@ -602,6 +606,7 @@ function record<T = eventWithTime>(
     return () => {
       handlers.forEach((h) => h());
       recording = false;
+      unregisterErrorHandler();
     };
   } catch (error) {
     // TODO: handle internal error