@repliqo/sdk-react-native 0.3.8 → 0.4.1

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
+    }
+  }
+}

package/src/trackers/navigation.tracker.ts

@@ -1,98 +1,107 @@
-import { useRef, useCallback } from 'react';
-import { AppAnalytics } from '../core/client';
-
-interface NavigationState {
-  routes: Array<{ name: string; key: string; state?: NavigationState }>;
-  index: number;
-}
-
-function getActiveRouteName(state: NavigationState | undefined): string | null {
-  if (!state) {
-    return null;
-  }
-
-  const route = state.routes[state.index];
-  if (!route) {
-    return null;
-  }
-
-  // Dive into nested navigators
-  if (route.state) {
-    return getActiveRouteName(route.state as NavigationState);
-  }
-
-  return route.name;
-}
-
-export function useNavigationTracker() {
-  const routeNameRef = useRef<string | null>(null);
-  const navigationRef = useRef<any>(null);
-
-  const onReady = useCallback(() => {
-    if (navigationRef.current) {
-      const state = navigationRef.current.getRootState() as
-        | NavigationState
-        | undefined;
-      const currentRouteName = getActiveRouteName(state);
-      routeNameRef.current = currentRouteName;
-
-      if (currentRouteName) {
-        try {
-          const analytics = AppAnalytics.getInstance();
-          analytics.onScreenEnter(currentRouteName);
-        } catch {
-          // AppAnalytics not initialized, silently ignore
-        }
-      }
-    }
-  }, []);
-
-  const onStateChange = useCallback(() => {
-    if (!navigationRef.current) {
-      return;
-    }
-
-    const state = navigationRef.current.getRootState() as
-      | NavigationState
-      | undefined;
-    const currentRouteName = getActiveRouteName(state);
-    const previousRouteName = routeNameRef.current;
-
-    if (
-      currentRouteName &&
-      previousRouteName &&
-      currentRouteName !== previousRouteName
-    ) {
-      try {
-        const analytics = AppAnalytics.getInstance();
-        analytics.trackNavigation(previousRouteName, currentRouteName);
-        analytics.onScreenExit(previousRouteName);
-        analytics.onScreenEnter(currentRouteName);
-      } catch {
-        // AppAnalytics not initialized, silently ignore
-      }
-    }
-
-    routeNameRef.current = currentRouteName;
-  }, []);
-
-  return {
-    navigationRef,
-    onStateChange,
-    onReady,
-  };
-}
-
-export function trackScreenChange(
-  fromScreen: string,
-  toScreen: string,
-): void {
-  try {
-    const analytics = AppAnalytics.getInstance();
-    analytics.trackNavigation(fromScreen, toScreen);
-    analytics.onScreenExit(fromScreen);
-    analytics.onScreenEnter(toScreen);
-  } catch {
-    // AppAnalytics not initialized, silently ignore
-  }
-}
+import { useRef, useCallback } from 'react';
+import { AppAnalytics } from '../core/client';
+
+interface NavigationState {
+  routes: Array<{ name: string; key: string; state?: NavigationState }>;
+  index: number;
+}
+
+function getActiveRouteName(state: NavigationState | undefined): string | null {
+  if (!state) {
+    return null;
+  }
+
+  const route = state.routes[state.index];
+  if (!route) {
+    return null;
+  }
+
+  // Dive into nested navigators
+  if (route.state) {
+    return getActiveRouteName(route.state as NavigationState);
+  }
+
+  return route.name;
+}
+
+export function useNavigationTracker() {
+  const routeNameRef = useRef<string | null>(null);
+  const navigationRef = useRef<any>(null);
+
+  const onReady = useCallback(() => {
+    if (navigationRef.current) {
+      const state = navigationRef.current.getRootState() as
+        | NavigationState
+        | undefined;
+      const currentRouteName = getActiveRouteName(state);
+      routeNameRef.current = currentRouteName;
+
+      if (currentRouteName) {
+        try {
+          const analytics = AppAnalytics.getInstance();
+          analytics.onScreenEnter(currentRouteName);
+        } catch {
+          // AppAnalytics not initialized, silently ignore
+        }
+      }
+    }
+  }, []);
+
+  const onStateChange = useCallback(() => {
+    if (!navigationRef.current) {
+      return;
+    }
+
+    const state = navigationRef.current.getRootState() as
+      | NavigationState
+      | undefined;
+    const currentRouteName = getActiveRouteName(state);
+    const previousRouteName = routeNameRef.current;
+
+    if (
+      currentRouteName &&
+      previousRouteName &&
+      currentRouteName !== previousRouteName
+    ) {
+      try {
+        const analytics = AppAnalytics.getInstance();
+        analytics.trackNavigation(previousRouteName, currentRouteName);
+        analytics.onScreenExit(previousRouteName);
+        analytics.onScreenEnter(currentRouteName);
+      } catch {
+        // AppAnalytics not initialized, silently ignore
+      }
+    } else if (currentRouteName && !previousRouteName) {
+      // First route seen without onReady having fired (some apps only wire
+      // onStateChange). Without this, currentScreen stays null until the
+      // SECOND navigation and early touches/visits go unattributed.
+      try {
+        AppAnalytics.getInstance().onScreenEnter(currentRouteName);
+      } catch {
+        // AppAnalytics not initialized, silently ignore
+      }
+    }
+
+    routeNameRef.current = currentRouteName;
+  }, []);
+
+  return {
+    navigationRef,
+    onStateChange,
+    onReady,
+  };
+}
+
+export function trackScreenChange(
+  fromScreen: string,
+  toScreen: string,
+): void {
+  try {
+    const analytics = AppAnalytics.getInstance();
+    analytics.trackNavigation(fromScreen, toScreen);
+    analytics.onScreenExit(fromScreen);
+    analytics.onScreenEnter(toScreen);
+  } catch {
+    // AppAnalytics not initialized, silently ignore
+  }
+}