@repliqo/sdk-react-native 0.3.7 → 0.4.0

package/src/snapshot/capture.ts

@@ -1,142 +1,154 @@
-import { SnapshotPayload, ScreenshotData } from '../types/snapshot';
-import { captureScreenshot } from './captureScreenshot';
-
-export interface SnapshotCaptureConfig {
-  captureInterval: number;
-  maxSnapshotsPerSession: number;
-}
-
-export type ScreenshotProvider = () => Promise<ScreenshotData | null>;
-
-type LogFn = (...args: any[]) => void;
-
-/**
- * Captures JPEG screenshots of the RN view hierarchy at a fixed interval
- * and forwards them to the host (usually the snapshot BatchQueue).
- */
-export class SnapshotCapture {
-  private timeoutId: ReturnType<typeof setTimeout> | null = null;
-  private sequence: number = 0;
-  private config: SnapshotCaptureConfig;
-  private onSnapshot: (snapshot: SnapshotPayload) => void;
-  private sessionId: string | null = null;
-  private currentScreen: string = 'unknown';
-  private capturing: boolean = false;
-  private running: boolean = false;
-  private provider: ScreenshotProvider;
-  private log: LogFn;
-  private warn: LogFn;
-
-  constructor(
-    config: SnapshotCaptureConfig,
-    onSnapshot: (snapshot: SnapshotPayload) => void,
-    provider: ScreenshotProvider = captureScreenshot,
-    log: LogFn = () => {},
-    warn: LogFn = () => {},
-  ) {
-    this.config = config;
-    this.onSnapshot = onSnapshot;
-    this.provider = provider;
-    this.log = log;
-    this.warn = warn;
-  }
-
-  start(): void {
-    if (this.running) return;
-    this.running = true;
-    this.log('Snapshot capture started (interval:', this.config.captureInterval, 'ms)');
-    this.scheduleNext();
-  }
-
-  stop(): void {
-    this.running = false;
-    if (this.timeoutId !== null) {
-      clearTimeout(this.timeoutId);
-      this.timeoutId = null;
-    }
-    this.log('Snapshot capture stopped');
-  }
-
-  async captureNow(): Promise<void> {
-    await this.tick();
-  }
-
-  private scheduleNext(): void {
-    if (!this.running) return;
-    this.timeoutId = setTimeout(() => {
-      Promise.resolve(this.tick()).finally(() => {
-        if (this.running) {
-          this.scheduleNext();
-        }
-      });
-    }, this.config.captureInterval);
-  }
-
-  private async tick(): Promise<void> {
-    if (!this.sessionId) return;
-    if (this.capturing) return;
-
-    if (this.sequence >= this.config.maxSnapshotsPerSession) {
-      this.log('Max snapshots reached:', this.sequence);
-      this.stop();
-      return;
-    }
-
-    this.capturing = true;
-    let screenshot: ScreenshotData | null = null;
-    try {
-      screenshot = await this.provider();
-    } catch (err) {
-      this.warn('Snapshot capture failed:', err);
-      screenshot = null;
-    } finally {
-      this.capturing = false;
-    }
-
-    if (!screenshot) {
-      this.warn('Snapshot returned null (provider unavailable or failed)');
-      return;
-    }
-
-    // Strip `source` field before sending — the backend DTO only
-    // accepts { image, width, height, format } and rejects unknown props.
-    const { image, width, height, format } = screenshot;
-
-    const payload: SnapshotPayload = {
-      sessionId: this.sessionId,
-      screenName: this.currentScreen,
-      timestamp: new Date().toISOString(),
-      sequence: this.sequence,
-      isDiff: false,
-      data: { image, width, height, format },
-    };
-
-    this.sequence++;
-    this.log(
-      'Snapshot captured: seq=', this.sequence - 1,
-      'screen=', this.currentScreen,
-      'size=', Math.round(screenshot.image.length / 1024), 'KB',
-    );
-    this.onSnapshot(payload);
-  }
-
-  reset(): void {
-    this.sequence = 0;
-  }
-
-  setSessionId(sessionId: string | null): void {
-    this.sessionId = sessionId;
-  }
-
-  setCurrentScreen(screenName: string): void {
-    this.currentScreen = screenName;
-  }
-
-  getSequence(): number {
-    return this.sequence;
-  }
-
-  isRunning(): boolean {
-    return this.running;
-  }
-}
+import { SnapshotPayload, ScreenshotData } from '../types/snapshot';
+import { captureScreenshot } from './captureScreenshot';
+
+export interface SnapshotCaptureConfig {
+  captureInterval: number;
+  maxSnapshotsPerSession: number;
+}
+
+export type ScreenshotProvider = () => Promise<ScreenshotData | null>;
+
+type LogFn = (...args: any[]) => void;
+
+/**
+ * Captures JPEG screenshots of the RN view hierarchy at a fixed interval
+ * and forwards them to the host (usually the snapshot BatchQueue).
+ */
+export class SnapshotCapture {
+  private timeoutId: ReturnType<typeof setTimeout> | null = null;
+  private sequence: number = 0;
+  private config: SnapshotCaptureConfig;
+  private onSnapshot: (snapshot: SnapshotPayload) => void;
+  private sessionId: string | null = null;
+  private currentScreen: string = 'unknown';
+  private capturing: boolean = false;
+  private running: boolean = false;
+  private provider: ScreenshotProvider;
+  private log: LogFn;
+  private warn: LogFn;
+
+  constructor(
+    config: SnapshotCaptureConfig,
+    onSnapshot: (snapshot: SnapshotPayload) => void,
+    provider: ScreenshotProvider = captureScreenshot,
+    log: LogFn = () => {},
+    warn: LogFn = () => {},
+  ) {
+    this.config = config;
+    this.onSnapshot = onSnapshot;
+    this.provider = provider;
+    this.log = log;
+    this.warn = warn;
+  }
+
+  /**
+   * Generation counter. Incremented on every start()/stop() so that timer
+   * chains from a PREVIOUS generation cannot reschedule themselves. Without
+   * it, a fast stop()→start() while a tick's capture is still in flight
+   * leaves two parallel timer chains alive (double capture rate).
+   */
+  private epoch = 0;
+
+  start(): void {
+    if (this.running) return;
+    this.running = true;
+    this.epoch++;
+    this.log('Snapshot capture started (interval:', this.config.captureInterval, 'ms)');
+    this.scheduleNext(this.epoch);
+  }
+
+  stop(): void {
+    this.running = false;
+    this.epoch++;
+    if (this.timeoutId !== null) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+    this.log('Snapshot capture stopped');
+  }
+
+  async captureNow(): Promise<void> {
+    await this.tick();
+  }
+
+  private scheduleNext(epoch: number): void {
+    if (!this.running || epoch !== this.epoch) return;
+    this.timeoutId = setTimeout(() => {
+      // Orphan timer from a previous generation — do nothing.
+      if (epoch !== this.epoch) return;
+      Promise.resolve(this.tick()).finally(() => {
+        if (this.running && epoch === this.epoch) {
+          this.scheduleNext(epoch);
+        }
+      });
+    }, this.config.captureInterval);
+  }
+
+  private async tick(): Promise<void> {
+    if (!this.sessionId) return;
+    if (this.capturing) return;
+
+    if (this.sequence >= this.config.maxSnapshotsPerSession) {
+      this.log('Max snapshots reached:', this.sequence);
+      this.stop();
+      return;
+    }
+
+    this.capturing = true;
+    let screenshot: ScreenshotData | null = null;
+    try {
+      screenshot = await this.provider();
+    } catch (err) {
+      this.warn('Snapshot capture failed:', err);
+      screenshot = null;
+    } finally {
+      this.capturing = false;
+    }
+
+    if (!screenshot) {
+      this.warn('Snapshot returned null (provider unavailable or failed)');
+      return;
+    }
+
+    // Strip `source` field before sending — the backend DTO only
+    // accepts { image, width, height, format } and rejects unknown props.
+    const { image, width, height, format } = screenshot;
+
+    const payload: SnapshotPayload = {
+      sessionId: this.sessionId,
+      screenName: this.currentScreen,
+      timestamp: new Date().toISOString(),
+      sequence: this.sequence,
+      isDiff: false,
+      data: { image, width, height, format },
+    };
+
+    this.sequence++;
+    this.log(
+      'Snapshot captured: seq=', this.sequence - 1,
+      'screen=', this.currentScreen,
+      'size=', Math.round(screenshot.image.length / 1024), 'KB',
+    );
+    this.onSnapshot(payload);
+  }
+
+  reset(): void {
+    this.sequence = 0;
+  }
+
+  setSessionId(sessionId: string | null): void {
+    this.sessionId = sessionId;
+  }
+
+  setCurrentScreen(screenName: string): void {
+    this.currentScreen = screenName;
+  }
+
+  getSequence(): number {
+    return this.sequence;
+  }
+
+  isRunning(): boolean {
+    return this.running;
+  }
+}

package/src/trackers/error.tracker.ts

@@ -1,136 +1,211 @@
-import { CrashReport } from '../types/crash';
-
-type CrashCallback = (crash: CrashReport) => void;
-
-export class ErrorTracker {
-  private onCrash: CrashCallback;
-  private sessionId: string | null = null;
-  private currentScreen: string | null = null;
-  private originalHandler:
-    | ((error: Error, isFatal?: boolean) => void)
-    | null = null;
-  private isActive = false;
-
-  constructor(onCrash: CrashCallback) {
-    this.onCrash = onCrash;
-  }
-
-  setSessionId(id: string | null): void {
-    this.sessionId = id;
-  }
-
-  setCurrentScreen(screen: string | null): void {
-    this.currentScreen = screen;
-  }
-
-  start(): void {
-    if (this.isActive) return;
-    this.isActive = true;
-    this.setupGlobalErrorHandler();
-    this.setupUnhandledRejectionHandler();
-  }
-
-  stop(): void {
-    if (!this.isActive) return;
-    this.isActive = false;
-    this.restoreGlobalErrorHandler();
-  }
-
-  /**
-   * Manual error reporting - allows consumers to report caught errors.
-   */
-  reportError(error: Error, metadata?: Record<string, any>): void {
-    try {
-      const crash: CrashReport = {
-        sessionId: this.sessionId || undefined,
-        type: 'js_error',
-        message: error.message,
-        stackTrace: error.stack || undefined,
-        screenName: this.currentScreen || undefined,
-        metadata,
-        timestamp: new Date().toISOString(),
-      };
-      this.onCrash(crash);
-    } catch (_e) {
-      // Never crash the app due to error reporting
-    }
-  }
-
-  private setupGlobalErrorHandler(): void {
-    try {
-      const ErrorUtils = (global as any).ErrorUtils;
-      if (ErrorUtils) {
-        this.originalHandler = ErrorUtils.getGlobalHandler();
-        ErrorUtils.setGlobalHandler(
-          (error: Error, isFatal?: boolean) => {
-            try {
-              const crash: CrashReport = {
-                sessionId: this.sessionId || undefined,
-                type: isFatal ? 'native_crash' : 'js_error',
-                message: error.message,
-                stackTrace: error.stack || undefined,
-                screenName: this.currentScreen || undefined,
-                metadata: { isFatal },
-                timestamp: new Date().toISOString(),
-              };
-              this.onCrash(crash);
-            } catch (_e) {
-              // Never crash the app due to error reporting
-            }
-
-            // Always call original handler so RN can handle the error
-            if (this.originalHandler) {
-              this.originalHandler(error, isFatal);
-            }
-          },
-        );
-      }
-    } catch (_e) {
-      // Never crash the app due to error handler setup
-    }
-  }
-
-  private setupUnhandledRejectionHandler(): void {
-    try {
-      if (typeof global !== 'undefined') {
-        (global as any).__analyticsUnhandledRejection = (
-          _id: number,
-          error: any,
-        ) => {
-          try {
-            const message =
-              error instanceof Error ? error.message : String(error);
-            const stack =
-              error instanceof Error ? error.stack : undefined;
-
-            const crash: CrashReport = {
-              sessionId: this.sessionId || undefined,
-              type: 'unhandled_rejection',
-              message,
-              stackTrace: stack || undefined,
-              screenName: this.currentScreen || undefined,
-              timestamp: new Date().toISOString(),
-            };
-            this.onCrash(crash);
-          } catch (_e) {
-            // Never crash the app due to error reporting
-          }
-        };
-      }
-    } catch (_e) {
-      // Never crash the app due to rejection handler setup
-    }
-  }
-
-  private restoreGlobalErrorHandler(): void {
-    try {
-      const ErrorUtils = (global as any).ErrorUtils;
-      if (ErrorUtils && this.originalHandler) {
-        ErrorUtils.setGlobalHandler(this.originalHandler);
-        this.originalHandler = null;
-      }
-    } catch (_e) {
-      // Never crash the app due to handler restoration
-    }
-  }
-}
+import { CrashReport } from '../types/crash';
+
+type CrashCallback = (crash: CrashReport) => void;
+
+/* Dynamic require for React Native's optional promise internals. */
+declare const require: any;
+
+export class ErrorTracker {
+  private onCrash: CrashCallback;
+  private sessionId: string | null = null;
+  private currentScreen: string | null = null;
+  private originalHandler:
+    | ((error: Error, isFatal?: boolean) => void)
+    | null = null;
+  private wrapperHandler:
+    | ((error: Error, isFatal?: boolean) => void)
+    | null = null;
+  private isActive = false;
+
+  constructor(onCrash: CrashCallback) {
+    this.onCrash = onCrash;
+  }
+
+  setSessionId(id: string | null): void {
+    this.sessionId = id;
+  }
+
+  setCurrentScreen(screen: string | null): void {
+    this.currentScreen = screen;
+  }
+
+  start(): void {
+    if (this.isActive) return;
+    this.isActive = true;
+    this.setupGlobalErrorHandler();
+    this.setupUnhandledRejectionHandler();
+  }
+
+  stop(): void {
+    if (!this.isActive) return;
+    // Flip the flag FIRST — the rejection trackers can't always be
+    // unregistered (Hermes), so their callbacks guard on isActive.
+    this.isActive = false;
+    this.restoreGlobalErrorHandler();
+    this.teardownUnhandledRejectionHandler();
+  }
+
+  /**
+   * Manual error reporting - allows consumers to report caught errors.
+   */
+  reportError(error: Error, metadata?: Record<string, any>): void {
+    try {
+      const crash: CrashReport = {
+        sessionId: this.sessionId || undefined,
+        type: 'js_error',
+        message: error.message,
+        stackTrace: error.stack || undefined,
+        screenName: this.currentScreen || undefined,
+        metadata,
+        timestamp: new Date().toISOString(),
+      };
+      this.onCrash(crash);
+    } catch (_e) {
+      // Never crash the app due to error reporting
+    }
+  }
+
+  private setupGlobalErrorHandler(): void {
+    try {
+      const ErrorUtils = (global as any).ErrorUtils;
+      if (ErrorUtils) {
+        this.originalHandler = ErrorUtils.getGlobalHandler();
+        this.wrapperHandler = (error: Error, isFatal?: boolean) => {
+          if (this.isActive) {
+            try {
+              const crash: CrashReport = {
+                sessionId: this.sessionId || undefined,
+                type: isFatal ? 'native_crash' : 'js_error',
+                message: error.message,
+                stackTrace: error.stack || undefined,
+                screenName: this.currentScreen || undefined,
+                metadata: { isFatal },
+                timestamp: new Date().toISOString(),
+              };
+              this.onCrash(crash);
+            } catch (_e) {
+              // Never crash the app due to error reporting
+            }
+          }
+
+          // Always call original handler so RN can handle the error
+          if (this.originalHandler) {
+            this.originalHandler(error, isFatal);
+          }
+        };
+        ErrorUtils.setGlobalHandler(this.wrapperHandler);
+      }
+    } catch (_e) {
+      // Never crash the app due to error handler setup
+    }
+  }
+
+  /**
+   * Handle an unhandled promise rejection. Guarded on isActive because the
+   * underlying trackers can't always be unregistered.
+   */
+  private handleUnhandledRejection = (_id: number, error: any): void => {
+    if (!this.isActive) return;
+    try {
+      const message = error instanceof Error ? error.message : String(error);
+      const stack = error instanceof Error ? error.stack : undefined;
+
+      const crash: CrashReport = {
+        sessionId: this.sessionId || undefined,
+        type: 'unhandled_rejection',
+        message,
+        stackTrace: stack || undefined,
+        screenName: this.currentScreen || undefined,
+        timestamp: new Date().toISOString(),
+      };
+      this.onCrash(crash);
+    } catch (_e) {
+      // Never crash the app due to error reporting
+    }
+  };
+
+  /**
+   * Register with the mechanisms React Native ACTUALLY uses to surface
+   * unhandled promise rejections:
+   *
+   *  1. Hermes' native promise rejection tracker (Hermes engine).
+   *  2. The `promise` polyfill's rejection-tracking module (JSC and older
+   *     RN versions).
+   *
+   * A bare global callback (the old approach) is never invoked by RN — it
+   * silently captured nothing.
+   *
+   * KNOWN LIMITATION: these trackers hold a single handler — registering
+   * REPLACES whatever was installed before (RN's dev LogBox warning, or
+   * another SDK like Sentry if it initialized first), and there is no
+   * unregister API, so after stop() an inert handler remains installed.
+   * If you run multiple error-tracking SDKs, initialize Repliqo FIRST so
+   * the other SDK's handler wins, or disable enableCrashTracking.
+   */
+  private setupUnhandledRejectionHandler(): void {
+    // Kept for manual invocation / test hooks.
+    try {
+      (global as any).__analyticsUnhandledRejection =
+        this.handleUnhandledRejection;
+    } catch (_e) {
+      /* ignore */
+    }
+
+    // Hermes: native promise rejection tracking.
+    try {
+      const hermes = (global as any).HermesInternal;
+      if (hermes?.hasPromise?.() && hermes?.enablePromiseRejectionTracker) {
+        hermes.enablePromiseRejectionTracker({
+          allRejections: true,
+          onUnhandled: this.handleUnhandledRejection,
+          onHandled: () => {},
+        });
+        return;
+      }
+    } catch (_e) {
+      /* ignore — fall through to the polyfill */
+    }
+
+    // JSC / promise polyfill path.
+    try {
+      const rejectionTracking = require('promise/setimmediate/rejection-tracking');
+      rejectionTracking.enable({
+        allRejections: true,
+        onUnhandled: this.handleUnhandledRejection,
+        onHandled: () => {},
+      });
+    } catch (_e) {
+      // Module unavailable (e.g. jest without the polyfill) — the global
+      // hook above still allows manual reporting.
+    }
+  }
+
+  private teardownUnhandledRejectionHandler(): void {
+    try {
+      delete (global as any).__analyticsUnhandledRejection;
+    } catch (_e) {
+      /* ignore */
+    }
+    // Hermes offers no unregister API and disabling the polyfill tracker
+    // could clobber another library's handler — the isActive guard in
+    // handleUnhandledRejection makes lingering registrations inert.
+  }
+
+  private restoreGlobalErrorHandler(): void {
+    try {
+      const ErrorUtils = (global as any).ErrorUtils;
+      if (ErrorUtils && this.originalHandler) {
+        // Only restore if WE are still the installed handler — another
+        // library may have wrapped us after start(), and restoring would
+        // clobber its handler.
+        if (ErrorUtils.getGlobalHandler() === this.wrapperHandler) {
+          ErrorUtils.setGlobalHandler(this.originalHandler);
+        }
+        this.originalHandler = null;
+        this.wrapperHandler = null;
+      }
+    } catch (_e) {
+      // Never crash the app due to handler restoration
+    }
+  }
+}