@rejourneyco/react-native 1.0.8 → 1.0.10

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/types/index.ts

@@ -31,6 +31,8 @@ export interface RejourneyConfig {
   maxStorageSize?: number;
   /** Enable automatic screen name detection with React Navigation (default: true) */
   autoScreenTracking?: boolean;
+  /** Enable automatic screen name detection with Expo Router (default: true) */
+  autoTrackExpoRouter?: boolean;
   /** Enable automatic gesture detection (default: true) */
   autoGestureTracking?: boolean;
   /** Enable privacy occlusion for text inputs (default: true) */
@@ -102,8 +104,12 @@ export interface RejourneyConfig {
    * Disable if you want minimal network tracking overhead.
    */
   networkCaptureSizes?: boolean;
+  /**
+   * Automatically intercept console.log/info/warn/error and include them in session recordings.
+   * Useful for debugging sessions. Capped at 1,000 logs per session. (default: true)
+   */
+  trackConsoleLogs?: boolean;
 }
-
 export type GestureType =
   | 'tap'
   | 'double_tap'
@@ -517,7 +523,17 @@ export interface RejourneyNativeModule {
 export interface RejourneyAPI {
   /** SDK version */
   readonly version: string;
-  /** Internal method to start recording session (called by startRejourney) */
+  /**
+   * Initialize Rejourney SDK
+   * @param publicRouteKey - Your public route key from the Rejourney dashboard
+   * @param options - Optional configuration options
+   */
+  init(publicRouteKey: string, options?: Omit<RejourneyConfig, 'publicRouteKey'>): void;
+  /** Start recording (call after user consent) */
+  start(): void;
+  /** Stop recording */
+  stop(): void;
+  /** Internal method to start recording session (called by start() / startRejourney()) */
   _startSession(): Promise<boolean>;
   /** Internal method to stop recording session (called by stopRejourney) */
   _stopSession(): Promise<void>;
@@ -527,8 +543,18 @@ export interface RejourneyAPI {
   setUserIdentity(userId: string): void;
   /** Clear user identity */
   clearUserIdentity(): void;
-  /** Tag current screen */
-  tagScreen(screenName: string, params?: Record<string, unknown>): void;
+  /**
+   * 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: string | Record<string, string | number | boolean>, value?: string | number | boolean): void;
+  /** Track current screen (manual) */
+  trackScreen(screenName: string, params?: Record<string, unknown>): void;
   /** Mark a view as sensitive (will be occluded in recording) */
   setOccluded(viewRef: { current: any }, occluded?: boolean): void;
   /** Add a tag to current session */
@@ -577,16 +603,24 @@ export interface RejourneyAPI {
   /** Get storage usage */
   getStorageUsage(): Promise<{ used: number; max: number }>;
 
+  /** 
+   * 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;
+
   /** 
    * Get SDK telemetry metrics for observability
+
    * Returns metrics about SDK health including upload success rates,
    * retry attempts, circuit breaker events, and memory pressure.
    */
   getSDKMetrics(): Promise<SDKMetrics>;
 
   /**
-   * 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;
 
@@ -616,6 +650,22 @@ export interface RejourneyAPI {
    * @param nativeID - The nativeID prop of the view to unmask
    */
   unmaskView(nativeID: string): void;
+
+  /**
+   * Hook for automatic React Navigation tracking.
+   * Pass the returned object to your NavigationContainer props.
+   * 
+   * @example
+   * ```tsx
+   * const navigationTracking = Rejourney.useNavigationTracking();
+   * <NavigationContainer {...navigationTracking}>
+   * ```
+   */
+  useNavigationTracking(): {
+    ref: any;
+    onReady: () => void;
+    onStateChange: (state: any) => void;
+  };
 }
 
 /**
@@ -686,6 +736,8 @@ export interface UseRejourneyResult {
   stopRecording: () => Promise<void>;
   /** Log custom event */
   logEvent: (name: string, properties?: Record<string, unknown>) => void;
+  /** Set custom session metadata */
+  setMetadata: (keyOrProperties: string | Record<string, string | number | boolean>, value?: string | number | boolean) => void;
   /** Error if any */
   error: Error | null;
 }