@rejourneyco/react-native 1.0.8 → 1.0.10

package/src/sdk/autoTracking.ts

@@ -142,9 +142,11 @@ export interface AutoTrackingConfig {
   trackJSErrors?: boolean;
   trackPromiseRejections?: boolean;
   trackReactNativeErrors?: boolean;
+  trackConsoleLogs?: boolean;
   collectDeviceInfo?: boolean;
   maxSessionDurationMs?: number;
   detectDeadTaps?: boolean;
+  autoTrackExpoRouter?: boolean;
 }
 
 let isInitialized = false;
@@ -183,6 +185,7 @@ let originalOnError: OnErrorEventHandler | null = null;
 let originalOnUnhandledRejection: ((event: PromiseRejectionEvent) => void) | null = null;
 let originalConsoleError: ((...args: any[]) => void) | null = null;
 let _promiseRejectionTrackingDisable: (() => void) | null = null;
+const FATAL_ERROR_FLUSH_DELAY_MS = 1200;
 
 /**
  * Initialize auto tracking features
@@ -205,7 +208,9 @@ export function initAutoTracking(
     trackJSErrors: true,
     trackPromiseRejections: true,
     trackReactNativeErrors: true,
+    trackConsoleLogs: true,
     collectDeviceInfo: true,
+    autoTrackExpoRouter: true,
     maxSessionDurationMs: trackingConfig.maxSessionDurationMs,
     ...trackingConfig,
   };
@@ -221,6 +226,9 @@ export function initAutoTracking(
   onErrorCaptured = callbacks.onError || null;
   onScreenChange = callbacks.onScreen || null;
   setupErrorTracking();
+  if (config.trackConsoleLogs) {
+    setupConsoleTracking();
+  }
   setupNavigationTracking();
   loadAnonymousId().then(id => {
     anonymousId = id;
@@ -236,11 +244,13 @@ export function cleanupAutoTracking(): void {
   if (!isInitialized) return;
 
   restoreErrorHandlers();
+  restoreConsoleHandlers();
   cleanupNavigationTracking();
 
   // Reset state
   tapHead = 0;
   tapCount = 0;
+  consoleLogCount = 0;
   metrics = createEmptyMetrics();
   screensVisited = [];
   currentScreen = '';
@@ -357,7 +367,7 @@ function setupErrorTracking(): void {
 /**
  * Setup React Native ErrorUtils handler
  *
- * CRITICAL FIX: For fatal errors, we delay calling the original handler by 500ms
+ * CRITICAL FIX: For fatal errors, we delay calling the original handler briefly
  * to give the React Native bridge time to flush the logEvent('error') call to the
  * native TelemetryPipeline. Without this delay, the error event is queued on the
  * JS→native bridge but the app crashes (via originalErrorHandler) before the bridge
@@ -384,10 +394,10 @@ function setupReactNativeErrorHandler(): void {
         if (isFatal) {
           // For fatal errors, delay the original handler so the native bridge
           // has time to deliver the error event to TelemetryPipeline before
-          // the app terminates. 500ms is enough for the bridge to flush.
+          // the app terminates.
           setTimeout(() => {
             originalErrorHandler!(error, isFatal);
-          }, 500);
+          }, FATAL_ERROR_FLUSH_DELAY_MS);
         } else {
           originalErrorHandler(error, isFatal);
         }
@@ -450,7 +460,6 @@ function setupPromiseRejectionHandler(): void {
 
   // Strategy 1: RN-specific promise rejection tracking polyfill
   try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
     const tracking = require('promise/setimmediate/rejection-tracking');
     if (tracking && typeof tracking.enable === 'function') {
       tracking.enable({
@@ -565,8 +574,30 @@ function trackError(error: ErrorEvent): void {
   metrics.errorCount++;
   metrics.totalEvents++;
 
+  forwardErrorToNative(error);
+
   if (onErrorCaptured) {
-    onErrorCaptured(error);
+    try {
+      onErrorCaptured(error);
+    } catch {
+      // Ignore callback exceptions so SDK error forwarding keeps working.
+    }
+  }
+}
+
+function forwardErrorToNative(error: ErrorEvent): void {
+  try {
+    const nativeModule = getRejourneyNativeModule();
+    if (!nativeModule || typeof nativeModule.logEvent !== 'function') return;
+
+    nativeModule.logEvent('error', {
+      message: error.message,
+      stack: error.stack,
+      name: error.name || 'Error',
+      timestamp: error.timestamp,
+    }).catch(() => { });
+  } catch {
+    // Ignore native forwarding failures; SDK should never crash app code.
   }
 }
 
@@ -587,11 +618,113 @@ export function captureError(
   });
 }
 
+let originalConsoleLog: ((...args: any[]) => void) | null = null;
+let originalConsoleInfo: ((...args: any[]) => void) | null = null;
+let originalConsoleWarn: ((...args: any[]) => void) | null = null;
+
+// Cap console logs to prevent flooding the event pipeline
+const MAX_CONSOLE_LOGS_PER_SESSION = 1000;
+let consoleLogCount = 0;
+
+/**
+ * Setup console tracking to capture log statements
+ */
+function setupConsoleTracking(): void {
+  if (typeof console === 'undefined') return;
+
+  if (!originalConsoleLog) originalConsoleLog = console.log;
+  if (!originalConsoleInfo) originalConsoleInfo = console.info;
+  if (!originalConsoleWarn) originalConsoleWarn = console.warn;
+
+  const createConsoleInterceptor = (level: 'log' | 'info' | 'warn' | 'error', originalFn: (...args: any[]) => void) => {
+    return (...args: any[]) => {
+      try {
+        const message = args.map(arg => {
+          if (typeof arg === 'string') return arg;
+          if (arg instanceof Error) return `${arg.name}: ${arg.message}${arg.stack ? `\n...` : ''}`;
+          try {
+            return JSON.stringify(arg);
+          } catch {
+            return String(arg);
+          }
+        }).join(' ');
+
+        // Enforce per-session cap and skip React Native unhandled-rejection noise.
+        if (
+          consoleLogCount < MAX_CONSOLE_LOGS_PER_SESSION &&
+          !message.includes('Possible Unhandled Promise Rejection')
+        ) {
+          consoleLogCount++;
+          const nativeModule = getRejourneyNativeModule();
+          if (nativeModule) {
+            const logEvent = {
+              type: 'log',
+              timestamp: Date.now(),
+              level,
+              message: message.length > 2000 ? message.substring(0, 2000) + '...' : message,
+            };
+            nativeModule.logEvent('log', logEvent).catch(() => { });
+          }
+        }
+      } catch {
+        // Ignore any errors during interception
+      }
+
+      if (originalFn) {
+        originalFn.apply(console, args);
+      }
+    };
+  };
+
+  console.log = createConsoleInterceptor('log', originalConsoleLog!);
+  console.info = createConsoleInterceptor('info', originalConsoleInfo!);
+  console.warn = createConsoleInterceptor('warn', originalConsoleWarn!);
+
+  const currentConsoleError = console.error;
+  if (!originalConsoleError) originalConsoleError = currentConsoleError;
+  console.error = createConsoleInterceptor('error', currentConsoleError);
+}
+
+/**
+ * Restore console standard functions
+ */
+function restoreConsoleHandlers(): void {
+  if (originalConsoleLog) {
+    console.log = originalConsoleLog;
+    originalConsoleLog = null;
+  }
+  if (originalConsoleInfo) {
+    console.info = originalConsoleInfo;
+    originalConsoleInfo = null;
+  }
+  if (originalConsoleWarn) {
+    console.warn = originalConsoleWarn;
+    originalConsoleWarn = null;
+  }
+  // Note: console.error is restored in restoreErrorHandlers via originalConsoleError
+}
+
 let navigationPollingInterval: ReturnType<typeof setInterval> | null = null;
+/** Interval ID from optional expo-router entry; cleared in cleanupNavigationTracking */
+let expoRouterPollingIntervalId: ReturnType<typeof setInterval> | null = null;
 let lastDetectedScreen = '';
 let navigationSetupDone = false;
-let navigationPollingErrors = 0;
-const MAX_POLLING_ERRORS = 10; // Stop polling after 10 consecutive errors
+
+/**
+ * Register the polling interval from the optional expo-router entry so we can clear it on cleanup.
+ * Used by src/expoRouterTracking.ts (only loaded when app imports '@rejourneyco/react-native/expo-router').
+ */
+export function setExpoRouterPollingInterval(id: ReturnType<typeof setInterval> | null): void {
+  expoRouterPollingIntervalId = id;
+}
+
+/**
+ * Check if Expo Router auto-tracking is enabled in the current configuration.
+ * Used by src/expoRouterTracking.ts.
+ */
+export function isExpoRouterTrackingEnabled(): boolean {
+  return config.autoTrackExpoRouter !== false;
+}
 
 /**
  * Track a navigation state change from React Navigation.
@@ -688,101 +821,97 @@ export function useNavigationTracking() {
 }
 
 /**
- * Setup automatic Expo Router tracking
- * 
- * For Expo apps using expo-router - works automatically.
- * For bare React Native apps - use trackNavigationState instead.
+ * Setup automatic navigation tracking.
+ *
+ * Expo Router: not set up here to avoid pulling expo-router into the main bundle
+ * (Metro resolves require() at build time, which causes "Requiring unknown module"
+ * in apps that use Expo + react-navigation without expo-router). If you use
+ * expo-router, add: import '@rejourneyco/react-native/expo-router';
+ *
+ * For React Navigation (non–expo-router), use trackNavigationState() on your
+ * NavigationContainer's onStateChange.
  */
 function setupNavigationTracking(): void {
   if (navigationSetupDone) return;
   navigationSetupDone = true;
 
-  if (__DEV__) {
-    logger.debug('Setting up navigation tracking...');
+  // Auto-detect expo-router and set up screen tracking if available.
+  // This is safe: if expo-router isn't installed, the require fails silently.
+  // We defer slightly so the router has time to initialize after JS bundle load.
+  if (config.autoTrackExpoRouter !== false) {
+    tryAutoSetupExpoRouter();
   }
+}
 
-  let attempts = 0;
-  const maxAttempts = 5;
-
-  const trySetup = () => {
-    attempts++;
-    if (__DEV__) {
-      logger.debug('Navigation setup attempt', attempts, 'of', maxAttempts);
-    }
-
-    const success = trySetupExpoRouter();
+/**
+ * Attempt to auto-detect and set up expo-router screen tracking.
+ * Uses a retry mechanism because the router may not be ready immediately
+ * after JS bundle load.
+ */
+function tryAutoSetupExpoRouter(attempt: number = 0, maxAttempts: number = 5): void {
+  const delay = 200 * (attempt + 1); // 200, 400, 600, 800, 1000ms
 
-    if (success) {
-      if (__DEV__) {
-        logger.debug('Expo Router setup: SUCCESS on attempt', attempts);
-      }
-    } else if (attempts < maxAttempts) {
-      const delay = 200 * attempts;
-      if (__DEV__) {
-        logger.debug('Expo Router not ready, retrying in', delay, 'ms');
+  setTimeout(() => {
+    try {
+      // Dynamic require wrapped in a variable to prevent Metro from statically resolving it
+      const EXPO_ROUTER = 'expo-router';
+      const expoRouter = require(EXPO_ROUTER);
+
+      if (!expoRouter?.router) {
+        // expo-router exists but router not ready yet — retry
+        if (attempt < maxAttempts - 1) {
+          tryAutoSetupExpoRouter(attempt + 1, maxAttempts);
+        }
+        return;
       }
-      setTimeout(trySetup, delay);
-    } else {
-      if (__DEV__) {
-        logger.debug('Expo Router setup: FAILED after', maxAttempts, 'attempts');
-        logger.debug('For manual navigation tracking, use trackNavigationState() on your NavigationContainer');
+
+      // Router is ready — set up the polling-based screen tracker
+      setupExpoRouterPolling(expoRouter.router);
+    } catch {
+      // expo-router not installed — this is fine, just means the app
+      // uses bare React Navigation or no navigation at all.
+      if (__DEV__ && attempt === 0) {
+        logger.debug('Expo Router not detected, skipping auto screen tracking. Use trackNavigationState() for React Navigation.');
       }
     }
-  };
-
-  setTimeout(trySetup, 200);
+  }, delay);
 }
 
 /**
-   * Set up Expo Router auto-tracking by polling the internal router store
-   * 
-   * Supports both expo-router v3 (store.rootState) and v6+ (store.state, store.navigationRef)
-   */
-function trySetupExpoRouter(): boolean {
-  try {
-    const expoRouter = require('expo-router');
-    const router = expoRouter.router;
-
-    if (!router) {
-      if (__DEV__) {
-        logger.debug('Expo Router: router object not found');
-      }
-      return false;
-    }
+ * Poll expo-router state for screen changes.
+ * Inlined from expoRouterTracking.ts so no separate import is needed.
+ */
+function setupExpoRouterPolling(router: any): void {
+  // Guard against double-setup (core auto-detection + legacy expoRouterTracking.ts import)
+  if (expoRouterPollingIntervalId != null) return;
 
-    if (__DEV__) {
-      logger.debug('Expo Router: Setting up navigation tracking');
-    }
+  const MAX_POLLING_ERRORS = 10;
+  let pollingErrors = 0;
 
+  try {
     const { normalizeScreenName, getScreenNameFromPath } = require('./navigation');
 
-    navigationPollingInterval = setInterval(() => {
+    const intervalId = setInterval(() => {
       try {
-        let state = null;
-        let stateSource = '';
+        let state: any = null;
+
         if (typeof router.getState === 'function') {
           state = router.getState();
-          stateSource = 'router.getState()';
-        } else if ((router as any).rootState) {
-          state = (router as any).rootState;
-          stateSource = 'router.rootState';
+        } else if (router.rootState) {
+          state = router.rootState;
         }
 
         if (!state) {
           try {
-            const storeModule = require('expo-router/build/global-state/router-store');
+            const STORE_PATH = 'expo-router/build/global-state/router-store';
+            const storeModule = require(STORE_PATH);
             if (storeModule?.store) {
               state = storeModule.store.state;
-              if (state) stateSource = 'store.state';
-
               if (!state && storeModule.store.navigationRef?.current) {
                 state = storeModule.store.navigationRef.current.getRootState?.();
-                if (state) stateSource = 'navigationRef.getRootState()';
               }
-
               if (!state) {
                 state = storeModule.store.rootState || storeModule.store.initialState;
-                if (state) stateSource = 'store.rootState/initialState';
               }
             }
           } catch {
@@ -792,10 +921,10 @@ function trySetupExpoRouter(): boolean {
 
         if (!state) {
           try {
-            const imperative = require('expo-router/build/imperative-api');
+            const IMPERATIVE_PATH = 'expo-router/build/imperative-api';
+            const imperative = require(IMPERATIVE_PATH);
             if (imperative?.router) {
               state = imperative.router.getState?.();
-              if (state) stateSource = 'imperative-api';
             }
           } catch {
             // Ignore
@@ -803,55 +932,45 @@ function trySetupExpoRouter(): boolean {
         }
 
         if (state) {
-          navigationPollingErrors = 0;
-          navigationPollingErrors = 0;
-          const screenName = extractScreenNameFromRouterState(state, getScreenNameFromPath, normalizeScreenName);
+          pollingErrors = 0;
+          const screenName = extractScreenNameFromRouterState(
+            state,
+            getScreenNameFromPath,
+            normalizeScreenName
+          );
           if (screenName && screenName !== lastDetectedScreen) {
-            if (__DEV__) {
-              logger.debug('Screen changed:', lastDetectedScreen, '->', screenName, `(source: ${stateSource})`);
-            }
             lastDetectedScreen = screenName;
             trackScreen(screenName);
           }
         } else {
-          navigationPollingErrors++;
-          if (__DEV__ && navigationPollingErrors === 1) {
-            logger.debug('Expo Router: Could not get navigation state');
-          }
-          if (navigationPollingErrors >= MAX_POLLING_ERRORS) {
-            cleanupNavigationTracking();
+          pollingErrors++;
+          if (pollingErrors >= MAX_POLLING_ERRORS) {
+            clearInterval(intervalId);
+            expoRouterPollingIntervalId = null;
           }
         }
-      } catch (e) {
-        navigationPollingErrors++;
-        if (__DEV__ && navigationPollingErrors === 1) {
-          logger.debug('Expo Router polling error:', e);
-        }
-        if (navigationPollingErrors >= MAX_POLLING_ERRORS) {
-          cleanupNavigationTracking();
+      } catch {
+        pollingErrors++;
+        if (pollingErrors >= MAX_POLLING_ERRORS) {
+          clearInterval(intervalId);
+          expoRouterPollingIntervalId = null;
         }
       }
     }, 500);
 
-    return true;
-  } catch (e) {
-    if (__DEV__) {
-      logger.debug('Expo Router not available:', e);
-    }
-    return false;
+    expoRouterPollingIntervalId = intervalId;
+  } catch {
+    // navigation module not available — ignore
   }
 }
 
 /**
- * Extract screen name from Expo Router navigation state
- * 
- * Handles complex nested structures like Drawer → Tabs → Stack
- * by recursively accumulating segments from each navigation level.
+ * Extract the active screen name from expo-router navigation state.
  */
 function extractScreenNameFromRouterState(
   state: any,
-  getScreenNameFromPath: (path: string, segments: string[]) => string,
-  normalizeScreenName: (name: string) => string,
+  getScreenNameFromPathFn: (path: string, segments: string[]) => string,
+  normalizeScreenNameFn: (name: string) => string,
   accumulatedSegments: string[] = []
 ): string | null {
   if (!state?.routes) return null;
@@ -864,13 +983,13 @@ function extractScreenNameFromRouterState(
   if (route.state) {
     return extractScreenNameFromRouterState(
       route.state,
-      getScreenNameFromPath,
-      normalizeScreenName,
+      getScreenNameFromPathFn,
+      normalizeScreenNameFn,
       newSegments
     );
   }
 
-  const cleanSegments = newSegments.filter(s => !s.startsWith('(') && !s.endsWith(')'));
+  const cleanSegments = newSegments.filter((s) => !s.startsWith('(') && !s.endsWith(')'));
 
   if (cleanSegments.length === 0) {
     for (let i = newSegments.length - 1; i >= 0; i--) {
@@ -883,7 +1002,7 @@ function extractScreenNameFromRouterState(
   }
 
   const pathname = '/' + cleanSegments.join('/');
-  return getScreenNameFromPath(pathname, newSegments);
+  return getScreenNameFromPathFn(pathname, newSegments);
 }
 
 /**
@@ -894,9 +1013,12 @@ function cleanupNavigationTracking(): void {
     clearInterval(navigationPollingInterval);
     navigationPollingInterval = null;
   }
+  if (expoRouterPollingIntervalId != null) {
+    clearInterval(expoRouterPollingIntervalId);
+    expoRouterPollingIntervalId = null;
+  }
   navigationSetupDone = false;
   lastDetectedScreen = '';
-  navigationPollingErrors = 0;
 }
 
 /**
@@ -1174,7 +1296,27 @@ export async function collectDeviceInfo(): Promise<DeviceInfo> {
 function generateAnonymousId(): string {
   const timestamp = Date.now().toString(36);
   const random = Math.random().toString(36).substring(2, 15);
-  return `anon_${timestamp}_${random}`;
+  const id = `anon_${timestamp}_${random}`;
+  // Persist so the same ID survives app restarts
+  _persistAnonymousId(id);
+  return id;
+}
+
+/**
+ * Best-effort async persist of anonymous ID to native storage
+ */
+function _persistAnonymousId(id: string): void {
+  const nativeModule = getRejourneyNativeModule();
+  if (!nativeModule?.setAnonymousId) return;
+
+  try {
+    const result = nativeModule.setAnonymousId(id);
+    if (result && typeof result.catch === 'function') {
+      result.catch(() => { });
+    }
+  } catch {
+    // Native storage unavailable — ID will still be stable for this session
+  }
 }
 
 /**
@@ -1205,17 +1347,41 @@ export async function ensurePersistentAnonymousId(): Promise<string> {
 
 /**
  * Load anonymous ID from persistent storage
- * Call this at app startup for best results
+ * Checks native anonymous storage first, then falls back to native getUserIdentity,
+ * and finally generates a new ID if nothing is persisted.
  */
 export async function loadAnonymousId(): Promise<string> {
   const nativeModule = getRejourneyNativeModule();
-  if (nativeModule && nativeModule.getUserIdentity) {
+
+  // 1. Try native anonymous ID storage
+  if (nativeModule?.getAnonymousId) {
+    try {
+      const stored = await nativeModule.getAnonymousId();
+      if (stored && typeof stored === 'string') return stored;
+    } catch {
+      // Continue to fallbacks
+    }
+  }
+
+  // 2. Backward compatibility fallback for older native modules
+  if (nativeModule?.getUserIdentity) {
     try {
-      return await nativeModule.getUserIdentity() || generateAnonymousId();
+      const nativeId = await nativeModule.getUserIdentity();
+      if (nativeId && typeof nativeId === 'string') {
+        const normalized = nativeId.trim();
+        // Only migrate legacy anonymous identifiers. Never treat explicit user identities
+        // as anonymous fingerprints, or session correlation becomes unstable.
+        if (normalized.startsWith('anon_')) {
+          _persistAnonymousId(normalized);
+          return normalized;
+        }
+      }
     } catch {
-      return generateAnonymousId();
+      // Continue to fallback
     }
   }
+
+  // 3. Generate and persist new ID
   return generateAnonymousId();
 }
 
@@ -1223,7 +1389,13 @@ export async function loadAnonymousId(): Promise<string> {
  * Set a custom anonymous ID
  */
 export function setAnonymousId(id: string): void {
-  anonymousId = id;
+  const normalized = (id || '').trim();
+  if (!normalized) {
+    anonymousId = generateAnonymousId();
+    return;
+  }
+  anonymousId = normalized;
+  _persistAnonymousId(normalized);
 }
 
 export default {