@rejourneyco/react-native 1.0.8 → 1.0.10

package/lib/commonjs/sdk/networkInterceptor.js

@@ -61,6 +61,73 @@ const config = {
   captureSizes: false
 };
 const SENSITIVE_KEYS = ['token', 'key', 'secret', 'password', 'auth', 'access_token', 'api_key'];
+function getUtf8Size(text) {
+  if (!text) return 0;
+  if (typeof TextEncoder !== 'undefined') {
+    return new TextEncoder().encode(text).length;
+  }
+  return text.length;
+}
+function getBodySize(body) {
+  if (body == null) return 0;
+  if (typeof body === 'string') return getUtf8Size(body);
+  if (typeof ArrayBuffer !== 'undefined' && body instanceof ArrayBuffer) {
+    return body.byteLength;
+  }
+  if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView(body)) {
+    return body.byteLength;
+  }
+  if (typeof Blob !== 'undefined' && body instanceof Blob) {
+    return body.size;
+  }
+  if (typeof URLSearchParams !== 'undefined' && body instanceof URLSearchParams) {
+    return getUtf8Size(body.toString());
+  }
+  return 0;
+}
+async function getFetchResponseSize(response) {
+  const contentLength = response.headers?.get?.('content-length');
+  if (contentLength) {
+    const parsed = parseInt(contentLength, 10);
+    if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  }
+  try {
+    const cloned = response.clone();
+    const buffer = await cloned.arrayBuffer();
+    return buffer.byteLength;
+  } catch {
+    return 0;
+  }
+}
+function getXhrResponseSize(xhr) {
+  try {
+    const contentLength = xhr.getResponseHeader('content-length');
+    if (contentLength) {
+      const parsed = parseInt(contentLength, 10);
+      if (Number.isFinite(parsed) && parsed > 0) return parsed;
+    }
+  } catch {
+    // Ignore header access errors and fall through to body inspection.
+  }
+  const responseType = xhr.responseType;
+  if (responseType === '' || responseType === 'text') {
+    return getUtf8Size(xhr.responseText || '');
+  }
+  if (responseType === 'arraybuffer') {
+    return typeof ArrayBuffer !== 'undefined' && xhr.response instanceof ArrayBuffer ? xhr.response.byteLength : 0;
+  }
+  if (responseType === 'blob') {
+    return typeof Blob !== 'undefined' && xhr.response instanceof Blob ? xhr.response.size : 0;
+  }
+  if (responseType === 'json') {
+    try {
+      return getUtf8Size(JSON.stringify(xhr.response ?? ''));
+    } catch {
+      return 0;
+    }
+  }
+  return 0;
+}
 
 /**
  * Scrub sensitive data from URL
@@ -211,7 +278,9 @@ function interceptFetch() {
     }
     const startTime = Date.now();
     const method = (init?.method || 'GET').toUpperCase();
-    return originalFetch(input, init).then(response => {
+    const requestBodySize = config.captureSizes ? getBodySize(init?.body) : 0;
+    return originalFetch(input, init).then(async response => {
+      const responseBodySize = config.captureSizes ? await getFetchResponseSize(response) : 0;
       queueRequest({
         requestId: `f${startTime}`,
         method,
@@ -220,7 +289,9 @@ function interceptFetch() {
         duration: Date.now() - startTime,
         startTimestamp: startTime,
         endTimestamp: Date.now(),
-        success: response.ok
+        success: response.ok,
+        requestBodySize,
+        responseBodySize
       });
       return response;
     }, error => {
@@ -233,7 +304,8 @@ function interceptFetch() {
         startTimestamp: startTime,
         endTimestamp: Date.now(),
         success: false,
-        errorMessage: error?.message || 'Network error'
+        errorMessage: error?.message || 'Network error',
+        requestBodySize
       });
       throw error;
     });
@@ -268,9 +340,15 @@ function interceptXHR() {
     if (!shouldSampleRequest(path)) {
       return originalXHRSend.call(this, body);
     }
+    if (config.captureSizes && body) {
+      data.reqSize = getBodySize(body);
+    } else {
+      data.reqSize = 0;
+    }
     data.t = Date.now();
     const onComplete = () => {
       const endTime = Date.now();
+      const responseBodySize = config.captureSizes ? getXhrResponseSize(this) : 0;
       queueRequest({
         requestId: `x${data.t}`,
         method: data.m,
@@ -280,7 +358,9 @@ function interceptXHR() {
         startTimestamp: data.t,
         endTimestamp: endTime,
         success: this.status >= 200 && this.status < 400,
-        errorMessage: this.status === 0 ? 'Network error' : undefined
+        errorMessage: this.status === 0 ? 'Network error' : undefined,
+        requestBodySize: data.reqSize,
+        responseBodySize
       });
     };
     this.addEventListener('load', onComplete);

package/lib/module/expoRouterTracking.js

@@ -0,0 +1,135 @@
+/**
+ * Optional Expo Router integration for @rejourneyco/react-native
+ *
+ * This file is only loaded when you import '@rejourneyco/react-native/expo-router'.
+ * It contains require('expo-router') and related subpaths. Metro bundles require()
+ * at build time, so keeping this in a separate entry ensures apps that use
+ * Expo with react-navigation (without expo-router) never pull in expo-router
+ * and avoid "Requiring unknown module" crashes.
+ *
+ * If you use expo-router, add this once (e.g. in your root _layout.tsx):
+ *   import '@rejourneyco/react-native/expo-router';
+ */
+
+import { trackScreen, setExpoRouterPollingInterval, isExpoRouterTrackingEnabled } from './sdk/autoTracking';
+import { normalizeScreenName, getScreenNameFromPath } from './sdk/navigation';
+const MAX_POLLING_ERRORS = 10;
+function extractScreenNameFromRouterState(state, getScreenNameFromPathFn, normalizeScreenNameFn, accumulatedSegments = []) {
+  if (!state?.routes) return null;
+  const route = state.routes[state.index ?? state.routes.length - 1];
+  if (!route) return null;
+  const newSegments = [...accumulatedSegments, route.name];
+  if (route.state) {
+    return extractScreenNameFromRouterState(route.state, getScreenNameFromPathFn, normalizeScreenNameFn, newSegments);
+  }
+  const cleanSegments = newSegments.filter(s => !s.startsWith('(') && !s.endsWith(')'));
+  if (cleanSegments.length === 0) {
+    for (let i = newSegments.length - 1; i >= 0; i--) {
+      const seg = newSegments[i];
+      if (seg && !seg.startsWith('(') && !seg.endsWith(')')) {
+        cleanSegments.push(seg);
+        break;
+      }
+    }
+  }
+  const pathname = '/' + cleanSegments.join('/');
+  return getScreenNameFromPathFn(pathname, newSegments);
+}
+function setupExpoRouterPolling() {
+  let lastDetectedScreen = '';
+  let pollingErrors = 0;
+  try {
+    const EXPO_ROUTER = 'expo-router';
+    const expoRouter = require(EXPO_ROUTER);
+    const router = expoRouter.router;
+    if (!router) {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.debug('[Rejourney] Expo Router: router object not found');
+      }
+      return;
+    }
+    const intervalId = setInterval(() => {
+      try {
+        let state = null;
+        if (typeof router.getState === 'function') {
+          state = router.getState();
+        } else if (router.rootState) {
+          state = router.rootState;
+        }
+        if (!state) {
+          try {
+            const STORE_PATH = 'expo-router/build/global-state/router-store';
+            const storeModule = require(STORE_PATH);
+            if (storeModule?.store) {
+              state = storeModule.store.state;
+              if (!state && storeModule.store.navigationRef?.current) {
+                state = storeModule.store.navigationRef.current.getRootState?.();
+              }
+              if (!state) {
+                state = storeModule.store.rootState || storeModule.store.initialState;
+              }
+            }
+          } catch {
+            // Ignore
+          }
+        }
+        if (!state) {
+          try {
+            const IMPERATIVE_PATH = 'expo-router/build/imperative-api';
+            const imperative = require(IMPERATIVE_PATH);
+            if (imperative?.router) {
+              state = imperative.router.getState?.();
+            }
+          } catch {
+            // Ignore
+          }
+        }
+        if (state) {
+          pollingErrors = 0;
+          const screenName = extractScreenNameFromRouterState(state, getScreenNameFromPath, normalizeScreenName);
+          if (screenName && screenName !== lastDetectedScreen) {
+            lastDetectedScreen = screenName;
+            trackScreen(screenName);
+          }
+        } else {
+          pollingErrors++;
+          if (pollingErrors >= MAX_POLLING_ERRORS) {
+            clearInterval(intervalId);
+            setExpoRouterPollingInterval(null);
+          }
+        }
+      } catch {
+        pollingErrors++;
+        if (pollingErrors >= MAX_POLLING_ERRORS) {
+          clearInterval(intervalId);
+          setExpoRouterPollingInterval(null);
+        }
+      }
+    }, 500);
+    setExpoRouterPollingInterval(intervalId);
+  } catch (e) {
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.debug('[Rejourney] Expo Router not available:', e);
+    }
+  }
+}
+let attempts = 0;
+const maxAttempts = 5;
+function trySetup() {
+  attempts++;
+  try {
+    const EXPO_ROUTER = 'expo-router';
+    const expoRouter = require(EXPO_ROUTER);
+    if (expoRouter?.router && isExpoRouterTrackingEnabled()) {
+      setupExpoRouterPolling();
+      return;
+    }
+  } catch {
+    // Not ready or not installed
+  }
+  if (attempts < maxAttempts) {
+    setTimeout(trySetup, 200 * attempts);
+  }
+}
+setTimeout(trySetup, 200);
+//# sourceMappingURL=expoRouterTracking.js.map

package/lib/module/index.js

@@ -160,7 +160,12 @@ const noopAutoTracking = {
   getSessionMetrics: () => ({}),
   resetMetrics: () => {},
   collectDeviceInfo: async () => ({}),
-  ensurePersistentAnonymousId: async () => 'anonymous'
+  ensurePersistentAnonymousId: async () => 'anonymous',
+  useNavigationTracking: () => ({
+    ref: null,
+    onReady: () => {},
+    onStateChange: () => {}
+  })
 };
 function getAutoTracking() {
   if (_sdkDisabled) return noopAutoTracking;
@@ -183,6 +188,11 @@ let _appStateSubscription = null;
 let _authErrorSubscription = null;
 let _currentAppState = 'active'; // Default to active, will be updated on init
 let _userIdentity = null;
+let _backgroundEntryTime = null; // Track when app went to background
+let _storedMetadata = {}; // Accumulate metadata for session rollover
+
+// Session timeout - must match native side (60 seconds)
+const SESSION_TIMEOUT_MS = 60_000;
 
 // Scroll throttling - reduce native bridge calls from 60fps to at most 10/sec
 let _lastScrollTime = 0;
@@ -437,7 +447,7 @@ function safeNativeCallSync(methodName, fn, defaultValue) {
 /**
  * Main Rejourney API (Internal)
  */
-const Rejourney = {
+export const Rejourney = {
   /**
    * SDK Version
    */
@@ -572,7 +582,9 @@ const Rejourney = {
         trackJSErrors: true,
         trackPromiseRejections: true,
         trackReactNativeErrors: true,
-        collectDeviceInfo: _storedConfig?.collectDeviceInfo !== false
+        trackConsoleLogs: _storedConfig?.trackConsoleLogs ?? true,
+        collectDeviceInfo: _storedConfig?.collectDeviceInfo !== false,
+        autoTrackExpoRouter: _storedConfig?.autoTrackExpoRouter !== false
       }, {
         // Rage tap callback - log as frustration event
         onRageTap: (count, x, y) => {
@@ -584,13 +596,8 @@ const Rejourney = {
           });
           getLogger().logFrustration(`Rage tap (${count} taps)`);
         },
-        // Error callback - log as error event
+        // Error callback - SDK forwarding is handled in autoTracking.trackError
         onError: error => {
-          this.logEvent('error', {
-            message: error.message,
-            stack: error.stack,
-            name: error.name
-          });
           getLogger().logError(error.message);
         },
         onScreen: (_screenName, _previousScreen) => {}
@@ -605,7 +612,12 @@ const Rejourney = {
       }
       if (_storedConfig?.autoTrackNetwork !== false) {
         try {
-          const ignoreUrls = [apiUrl, '/api/sdk/config', '/api/ingest/presign', '/api/ingest/batch/complete', '/api/ingest/session/end', ...(_storedConfig?.networkIgnoreUrls || [])];
+          // JS-level fetch/XHR patching is the primary mechanism for capturing network
+          // calls within React Native. Native interceptors (RejourneyURLProtocol on iOS,
+          // RejourneyNetworkInterceptor on Android) are supplementary — they capture
+          // native-originated HTTP calls that bypass JS fetch(), but cannot intercept
+          // RN's own networking since it creates its NSURLSession/OkHttpClient at init time.
+          const ignoreUrls = [apiUrl, '/api/sdk/config', '/api/ingest/presign', '/api/ingest/batch/complete', '/api/ingest/session/end', '/api/ingest/segment/presign', '/api/ingest/segment/complete', ...(_storedConfig?.networkIgnoreUrls || [])];
           getNetworkInterceptor().initNetworkInterceptor(request => {
             getAutoTracking().trackAPIRequest(request.success || false, request.statusCode, request.duration || 0, request.responseBodySize || 0);
             Rejourney.logNetworkRequest(request);
@@ -694,17 +706,57 @@ const Rejourney = {
     }
   },
   /**
-   * Tag the current screen
+  /**
+   * Set custom session metadata.
+   * Can be called with a single key-value pair or an object of properties.
+   * Useful for filtering sessions later (e.g., plan: 'premium', role: 'admin').
+   * Caps at 100 properties per session.
+   * 
+   * @param keyOrProperties Property name string, or an object containing key-value pairs
+   * @param value Property value (if first argument is a string)
+   */
+  setMetadata(keyOrProperties, value) {
+    if (typeof keyOrProperties === 'string') {
+      const key = keyOrProperties;
+      if (!key) {
+        getLogger().warn('setMetadata requires a non-empty string key');
+        return;
+      }
+      if (value !== undefined && typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
+        getLogger().warn('setMetadata value must be a string, number, or boolean when using a key string');
+        return;
+      }
+      this.logEvent('$user_property', {
+        key,
+        value
+      });
+      // Track for session rollover restoration
+      _storedMetadata[key] = value;
+    } else if (keyOrProperties && typeof keyOrProperties === 'object') {
+      const properties = keyOrProperties;
+      const validProps = {};
+      for (const [k, v] of Object.entries(properties)) {
+        if (typeof k === 'string' && k && (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean')) {
+          validProps[k] = v;
+        }
+      }
+      if (Object.keys(validProps).length > 0) {
+        this.logEvent('$user_property', validProps);
+        // Track for session rollover restoration
+        Object.assign(_storedMetadata, validProps);
+      }
+    } else {
+      getLogger().warn('setMetadata requires a string key and value, or a properties object');
+    }
+  },
+  /**
+   * Track current screen (manual)
    * 
    * @param screenName - Screen name
    * @param params - Optional screen parameters
    */
-  tagScreen(screenName, _params) {
+  trackScreen(screenName, _params) {
     getAutoTracking().trackScreen(screenName);
-    getAutoTracking().notifyStateChange();
-    safeNativeCallSync('tagScreen', () => {
-      getRejourneyNative().screenChanged(screenName).catch(() => {});
-    }, undefined);
   },
   /**
    * Mark a view as sensitive (will be occluded in recordings)
@@ -1002,6 +1054,23 @@ const Rejourney = {
       getRejourneyNative().logEvent('network_request', networkEvent).catch(() => {});
     }, undefined);
   },
+  /**
+   * Log customer feedback (e.g. from an in-app survey or NPS widget).
+   * 
+   * @param rating - Numeric rating (e.g. 1 to 5)
+   * @param message - Associated feedback text or comment
+   */
+  logFeedback(rating, message) {
+    safeNativeCallSync('logFeedback', () => {
+      const feedbackEvent = {
+        type: 'feedback',
+        timestamp: Date.now(),
+        rating,
+        message
+      };
+      getRejourneyNative().logEvent('feedback', feedbackEvent).catch(() => {});
+    }, undefined);
+  },
   /**
    * Get SDK telemetry metrics for observability
    * 
@@ -1037,17 +1106,12 @@ const Rejourney = {
     });
   },
   /**
-   * Trigger a debug ANR (Dev only)
-   * Blocks the main thread for the specified duration
+   * Trigger an ANR test by blocking the main thread for the specified duration.
    */
   debugTriggerANR(durationMs) {
-    if (__DEV__) {
-      safeNativeCallSync('debugTriggerANR', () => {
-        getRejourneyNative().debugTriggerANR(durationMs);
-      }, undefined);
-    } else {
-      getLogger().warn('debugTriggerANR is only available in development mode');
-    }
+    safeNativeCallSync('debugTriggerANR', () => {
+      getRejourneyNative().debugTriggerANR(durationMs);
+    }, undefined);
   },
   /**
    * Mask a view by its nativeID prop (will be occluded in recordings)
@@ -1081,13 +1145,109 @@ const Rejourney = {
     safeNativeCallSync('unmaskView', () => {
       getRejourneyNative().unmaskViewByNativeID(nativeID).catch(() => {});
     }, undefined);
+  },
+  /**
+   * Initialize Rejourney SDK
+   */
+  init(publicRouteKey, options) {
+    initRejourney(publicRouteKey, options);
+  },
+  /**
+   * Start recording
+   */
+  start() {
+    startRejourney();
+  },
+  /**
+   * Stop recording
+   */
+  stop() {
+    stopRejourney();
+  },
+  /**
+   * Hook for automatic React Navigation tracking.
+   */
+  useNavigationTracking() {
+    return getAutoTracking().useNavigationTracking();
   }
 };
 
+/**
+ * Reinitialize JS-side auto-tracking for a new session after background timeout.
+ *
+ * When the app was in background for >60s the native layer rolls over to a
+ * fresh session automatically.  The JS side must tear down stale tracking
+ * state (metrics, console-log counter, screen history, error handlers) and
+ * re-initialize so that trackScreen, logEvent, setMetadata, etc. work
+ * correctly against the new native session.
+ */
+function _reinitAutoTrackingForNewSession() {
+  try {
+    // 1. Tear down old session's auto-tracking state
+    getAutoTracking().cleanupAutoTracking();
+
+    // 2. Re-initialize auto-tracking with the same config
+    getAutoTracking().initAutoTracking({
+      rageTapThreshold: _storedConfig?.rageTapThreshold ?? 3,
+      rageTapTimeWindow: _storedConfig?.rageTapTimeWindow ?? 500,
+      rageTapRadius: 50,
+      trackJSErrors: true,
+      trackPromiseRejections: true,
+      trackReactNativeErrors: true,
+      trackConsoleLogs: _storedConfig?.trackConsoleLogs ?? true,
+      collectDeviceInfo: _storedConfig?.collectDeviceInfo !== false,
+      autoTrackExpoRouter: _storedConfig?.autoTrackExpoRouter !== false
+    }, {
+      onRageTap: (count, x, y) => {
+        Rejourney.logEvent('frustration', {
+          frustrationKind: 'rage_tap',
+          tapCount: count,
+          x,
+          y
+        });
+        getLogger().logFrustration(`Rage tap (${count} taps)`);
+      },
+      onError: error => {
+        getLogger().logError(error.message);
+      },
+      onScreen: (_screenName, _previousScreen) => {}
+    });
+
+    // 3. Re-collect device info for the new session
+    if (_storedConfig?.collectDeviceInfo !== false) {
+      getAutoTracking().collectDeviceInfo().then(deviceInfo => {
+        Rejourney.logEvent('device_info', deviceInfo);
+      }).catch(() => {});
+    }
+
+    // 4. Re-send user identity to the new native session
+    if (_userIdentity) {
+      safeNativeCallSync('setUserIdentity', () => {
+        getRejourneyNative().setUserIdentity(_userIdentity).catch(() => {});
+      }, undefined);
+      getLogger().debug(`Restored user identity '${_userIdentity}' to new session`);
+    }
+
+    // 5. Re-send any stored metadata to the new native session
+    if (Object.keys(_storedMetadata).length > 0) {
+      for (const [key, value] of Object.entries(_storedMetadata)) {
+        if (value !== undefined && value !== null) {
+          Rejourney.setMetadata(key, value);
+        }
+      }
+      getLogger().debug('Restored metadata to new session');
+    }
+    getLogger().logLifecycleEvent('JS auto-tracking reinitialized for new session');
+  } catch (error) {
+    getLogger().warn('Failed to reinitialize auto-tracking after session rollover:', error);
+  }
+}
+
 /**
  * Handle app state changes for automatic session management
  * - Pauses recording when app goes to background
  * - Resumes recording when app comes back to foreground
+ * - Reinitializes JS-side auto-tracking when native rolls over to a new session
  * - Cleans up properly when app is terminated
  */
 function handleAppStateChange(nextAppState) {
@@ -1096,9 +1256,22 @@ function handleAppStateChange(nextAppState) {
     if (_currentAppState.match(/active/) && nextAppState === 'background') {
       // App going to background - native module handles this automatically
       getLogger().logLifecycleEvent('App moving to background');
+      _backgroundEntryTime = Date.now();
     } else if (_currentAppState.match(/inactive|background/) && nextAppState === 'active') {
       // App coming back to foreground
       getLogger().logLifecycleEvent('App returning to foreground');
+
+      // Check if we exceeded the session timeout (60s).
+      // Native side will have already ended the old session and started a new
+      // one — we need to reset JS-side auto-tracking state to match.
+      if (_backgroundEntryTime && _isRecording) {
+        const backgroundDurationMs = Date.now() - _backgroundEntryTime;
+        if (backgroundDurationMs > SESSION_TIMEOUT_MS) {
+          getLogger().debug(`Session rollover: background ${Math.round(backgroundDurationMs / 1000)}s > ${SESSION_TIMEOUT_MS / 1000}s timeout`);
+          _reinitAutoTrackingForNewSession();
+        }
+      }
+      _backgroundEntryTime = null;
     }
     _currentAppState = nextAppState;
   } catch (error) {
@@ -1163,8 +1336,10 @@ function setupAuthErrorListener() {
         }
       });
     }
-  } catch (error) {
-    getLogger().debug('Auth error listener not available:', error);
+  } catch {
+    // Expected on some architectures where NativeEventEmitter isn't fully supported.
+    // Auth errors are still handled synchronously via native callback — this listener
+    // is purely supplementary. No need to log.
   }
 }
 
@@ -1301,7 +1476,7 @@ export function stopRejourney() {
 }
 export default Rejourney;
 export * from './types';
-export { trackTap, trackScroll, trackGesture, trackInput, trackScreen, captureError, getSessionMetrics } from './sdk/autoTracking';
+export { trackTap, trackScroll, trackGesture, trackInput, captureError, getSessionMetrics } from './sdk/autoTracking';
 export { trackNavigationState, useNavigationTracking } from './sdk/autoTracking';
 export { LogLevel } from './sdk/utils';