@rejourneyco/react-native 1.0.7 → 1.0.9

package/src/index.ts

@@ -247,13 +247,13 @@ interface RemoteConfig {
 }
 
 // Result type for fetchRemoteConfig - distinguishes network errors from access denial
-type ConfigFetchResult = 
+type ConfigFetchResult =
   | { status: 'success'; config: RemoteConfig }
   | { status: 'network_error' }  // Proceed with defaults (fail-open)
   | { status: 'access_denied'; httpStatus: number };  // Abort recording (fail-closed)
 
 let _remoteConfig: RemoteConfig | null = null;
-let _sessionSampledOut: boolean = false; // True = telemetry only, no replay video
+let _sessionSampledOut: boolean = false; // True = telemetry only, no visual replay capture
 
 /**
  * Fetch project configuration from backend
@@ -323,7 +323,7 @@ function shouldRecordSession(sampleRate: number): boolean {
   // sampleRate is 0-100 (percentage)
   if (sampleRate >= 100) return true;
   if (sampleRate <= 0) return false;
-  
+
   const randomValue = Math.random() * 100;
   return randomValue < sampleRate;
 }
@@ -522,7 +522,7 @@ const Rejourney: RejourneyAPI = {
       // This determines if recording is enabled and at what rate
       // =========================================================
       const configResult = await fetchRemoteConfig(apiUrl, publicKey);
-      
+
       // =========================================================
       // CASE 0: Access denied (401/403) - abort immediately
       // This means project disabled, invalid key, etc - HARD STOP
@@ -531,10 +531,10 @@ const Rejourney: RejourneyAPI = {
         getLogger().info(`Recording disabled - access denied (${configResult.httpStatus})`);
         return false;
       }
-      
+
       // For success, extract the config; for network_error, proceed with null
       _remoteConfig = configResult.status === 'success' ? configResult.config : null;
-      
+
       if (_remoteConfig) {
         // =========================================================
         // CASE 1: Rejourney completely disabled - abort early, nothing captured
@@ -560,7 +560,7 @@ const Rejourney: RejourneyAPI = {
         // =========================================================
         _sessionSampledOut = !shouldRecordSession(_remoteConfig.sampleRate ?? 100);
         if (_sessionSampledOut) {
-          getLogger().info(`Session sampled out (rate: ${_remoteConfig.sampleRate}%) - telemetry only, no replay video`);
+          getLogger().info(`Session sampled out (rate: ${_remoteConfig.sampleRate}%) - telemetry only, no visual replay capture`);
         }
 
         // =========================================================
@@ -635,6 +635,7 @@ const Rejourney: RejourneyAPI = {
           trackJSErrors: true,
           trackPromiseRejections: true,
           trackReactNativeErrors: true,
+          trackConsoleLogs: _storedConfig?.trackConsoleLogs ?? true,
           collectDeviceInfo: _storedConfig?.collectDeviceInfo !== false,
         },
         {
@@ -648,13 +649,8 @@ const Rejourney: RejourneyAPI = {
             });
             getLogger().logFrustration(`Rage tap (${count} taps)`);
           },
-          // Error callback - log as error event
+          // Error callback - SDK forwarding is handled in autoTracking.trackError
           onError: (error: { message: string; stack?: string; name?: string }) => {
-            this.logEvent('error', {
-              message: error.message,
-              stack: error.stack,
-              name: error.name,
-            });
             getLogger().logError(error.message);
           },
           onScreen: (_screenName: string, _previousScreen?: string) => {
@@ -673,6 +669,11 @@ const Rejourney: RejourneyAPI = {
 
       if (_storedConfig?.autoTrackNetwork !== false) {
         try {
+          // 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: (string | RegExp)[] = [
             apiUrl,
             '/api/sdk/config',
@@ -868,7 +869,6 @@ const Rejourney: RejourneyAPI = {
         duration: 0,
         deviceInfo: { model: '', os: 'ios', osVersion: '', screenWidth: 0, screenHeight: 0, pixelRatio: 1 },
         eventCount: 0,
-        videoSegmentCount: 0,
         storageSize: 0,
         sdkVersion: SDK_VERSION,
         isComplete: false,
@@ -957,10 +957,10 @@ const Rejourney: RejourneyAPI = {
   },
 
   /**
-   * Report a scroll event for video capture timing
+   * Report a scroll event for visual replay timing
    * 
    * Call this from your ScrollView's onScroll handler to improve scroll capture.
-   * The SDK captures video at 2 FPS continuously, but this helps log scroll events
+   * The SDK captures visual replay frames continuously, and this helps log scroll events
    * for timeline correlation during replay.
    * 
    * @param scrollOffset - Current scroll offset (vertical or horizontal)
@@ -1155,6 +1155,28 @@ const Rejourney: RejourneyAPI = {
     );
   },
 
+  /**
+   * 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: number, message: string): void {
+    safeNativeCallSync(
+      'logFeedback',
+      () => {
+        const feedbackEvent = {
+          type: 'feedback',
+          timestamp: Date.now(),
+          rating,
+          message,
+        };
+        getRejourneyNative()!.logEvent('feedback', feedbackEvent).catch(() => { });
+      },
+      undefined
+    );
+  },
+
   /**
    * Get SDK telemetry metrics for observability
    * 
@@ -1195,21 +1217,16 @@ const Rejourney: RejourneyAPI = {
   },
 
   /**
-   * 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: number): void {
-    if (__DEV__) {
-      safeNativeCallSync(
-        'debugTriggerANR',
-        () => {
-          getRejourneyNative()!.debugTriggerANR(durationMs);
-        },
-        undefined
-      );
-    } else {
-      getLogger().warn('debugTriggerANR is only available in development mode');
-    }
+    safeNativeCallSync(
+      'debugTriggerANR',
+      () => {
+        getRejourneyNative()!.debugTriggerANR(durationMs);
+      },
+      undefined
+    );
   },
 
   /**

package/src/sdk/autoTracking.ts

@@ -142,6 +142,7 @@ export interface AutoTrackingConfig {
   trackJSErrors?: boolean;
   trackPromiseRejections?: boolean;
   trackReactNativeErrors?: boolean;
+  trackConsoleLogs?: boolean;
   collectDeviceInfo?: boolean;
   maxSessionDurationMs?: number;
   detectDeadTaps?: boolean;
@@ -183,6 +184,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,6 +207,7 @@ export function initAutoTracking(
     trackJSErrors: true,
     trackPromiseRejections: true,
     trackReactNativeErrors: true,
+    trackConsoleLogs: true,
     collectDeviceInfo: true,
     maxSessionDurationMs: trackingConfig.maxSessionDurationMs,
     ...trackingConfig,
@@ -221,6 +224,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 +242,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 +365,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 +392,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 +458,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 +572,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,6 +616,92 @@ 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;
 let lastDetectedScreen = '';
 let navigationSetupDone = false;
@@ -1174,7 +1289,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 +1340,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 {
-      return await nativeModule.getUserIdentity() || generateAnonymousId();
+      const stored = await nativeModule.getAnonymousId();
+      if (stored && typeof stored === 'string') return stored;
     } catch {
-      return generateAnonymousId();
+      // Continue to fallbacks
     }
   }
+
+  // 2. Backward compatibility fallback for older native modules
+  if (nativeModule?.getUserIdentity) {
+    try {
+      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 {
+      // Continue to fallback
+    }
+  }
+
+  // 3. Generate and persist new ID
   return generateAnonymousId();
 }
 
@@ -1223,7 +1382,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 {

package/src/sdk/constants.ts

@@ -26,7 +26,7 @@ export { SDK_VERSION };
 /** Default configuration values */
 export const DEFAULT_CONFIG = {
   enabled: true,
-  captureFPS: 0.5,
+  captureFPS: 1.0,
   captureOnEvents: true,
   maxSessionDuration: 10 * 60 * 1000,
   maxStorageSize: 50 * 1024 * 1024,
@@ -79,7 +79,7 @@ export const PLAYBACK_SPEEDS = [0.5, 1, 2, 4] as const;
 
 /** Capture settings */
 export const CAPTURE_SETTINGS = {
-  DEFAULT_FPS: 0.5,
+  DEFAULT_FPS: 1.0,
   MIN_FPS: 0.1,
   MAX_FPS: 2,
   CAPTURE_SCALE: 0.25,

package/src/sdk/networkInterceptor.ts

@@ -59,6 +59,94 @@ const config = {
 
 const SENSITIVE_KEYS = ['token', 'key', 'secret', 'password', 'auth', 'access_token', 'api_key'];
 
+function getUtf8Size(text: string): number {
+  if (!text) return 0;
+  if (typeof TextEncoder !== 'undefined') {
+    return new TextEncoder().encode(text).length;
+  }
+  return text.length;
+}
+
+function getBodySize(body: unknown): number {
+  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 as any)) {
+    return (body as ArrayBufferView).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: Response): Promise<number> {
+  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: XMLHttpRequest): number {
+  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
  */
@@ -225,8 +313,15 @@ function interceptFetch(): void {
 
     const startTime = Date.now();
     const method = ((init?.method || 'GET').toUpperCase()) as NetworkRequestParams['method'];
+
+    const requestBodySize = config.captureSizes ? getBodySize(init?.body) : 0;
+
     return originalFetch!(input, init).then(
-      (response) => {
+      async (response) => {
+        const responseBodySize = config.captureSizes
+          ? await getFetchResponseSize(response)
+          : 0;
+
         queueRequest({
           requestId: `f${startTime}`,
           method,
@@ -236,6 +331,8 @@ function interceptFetch(): void {
           startTimestamp: startTime,
           endTimestamp: Date.now(),
           success: response.ok,
+          requestBodySize,
+          responseBodySize,
         });
         return response;
       },
@@ -250,6 +347,7 @@ function interceptFetch(): void {
           endTimestamp: Date.now(),
           success: false,
           errorMessage: error?.message || 'Network error',
+          requestBodySize,
         });
         throw error;
       }
@@ -296,10 +394,19 @@ function interceptXHR(): void {
       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 as NetworkRequestParams['method'],
@@ -310,6 +417,8 @@ function interceptXHR(): void {
         endTimestamp: endTime,
         success: this.status >= 200 && this.status < 400,
         errorMessage: this.status === 0 ? 'Network error' : undefined,
+        requestBodySize: data.reqSize,
+        responseBodySize,
       });
     };
 

package/src/sdk/utils.ts

@@ -324,7 +324,7 @@ class Logger {
   }
 
   notice(...args: any[]): void {
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    if (this.minimumLogLevel <= LogLevel.INFO) {
       console.info(this.prefix, ...args);
     }
   }