@rejourneyco/react-native 1.0.0

package/lib/module/sdk/networkInterceptor.js

@@ -0,0 +1,401 @@
+/**
+ * Network Interceptor for Rejourney - Optimized Version
+ * 
+ * Automatically intercepts fetch() and XMLHttpRequest to log API calls.
+ * 
+ * PERFORMANCE OPTIMIZATIONS:
+ * - Minimal synchronous overhead (just captures timing, no processing)
+ * - Batched async logging (doesn't block requests)
+ * - Circular buffer with max size limit
+ * - Sampling for high-frequency endpoints
+ * - No string allocations in hot path
+ * - Lazy URL parsing
+ * - PII Scrubbing for query parameters
+ */
+
+// Store original implementations
+let originalFetch = null;
+let originalXHROpen = null;
+let originalXHRSend = null;
+
+// Callback to log network requests (called asynchronously)
+let logCallback = null;
+
+// Pending requests buffer (circular buffer for memory efficiency)
+const MAX_PENDING_REQUESTS = 100;
+const pendingRequests = new Array(MAX_PENDING_REQUESTS).fill(null);
+let pendingHead = 0;
+let pendingTail = 0;
+let pendingCount = 0;
+
+// Flush timer
+let flushTimer = null;
+const FLUSH_INTERVAL = 500; // Flush every 500ms
+
+// Sampling for high-frequency endpoints
+const endpointCounts = new Map();
+const SAMPLE_WINDOW = 10000; // 10 second window
+const MAX_PER_ENDPOINT = 20; // Max 20 requests per endpoint per window
+
+// Configuration
+const config = {
+  enabled: true,
+  ignorePatterns: [],
+  // Simple string patterns for fast matching
+  maxUrlLength: 300,
+  // Shorter for efficiency
+  captureSizes: false // Disabled by default for performance
+};
+
+// PII Scrubbing - Sensitive keys to look for in query params
+const SENSITIVE_KEYS = ['token', 'key', 'secret', 'password', 'auth', 'access_token', 'api_key'];
+
+/**
+ * Scrub sensitive data from URL
+ */
+function scrubUrl(url) {
+  try {
+    // Fast check if URL might contain params
+    if (url.indexOf('?') === -1) return url;
+    const urlObj = new URL(url);
+    let modified = false;
+    SENSITIVE_KEYS.forEach(key => {
+      if (urlObj.searchParams.has(key)) {
+        urlObj.searchParams.set(key, '[REDACTED]');
+        modified = true;
+      }
+    });
+
+    // Also scan for partial matches (case-insensitive) if strict scrubbing needed
+    // But for performance, we stick to exact keys or common variations
+
+    return modified ? urlObj.toString() : url;
+  } catch {
+    // If URL parsing fails (relative URL?), try primitive replacement
+    let scrubbed = url;
+    SENSITIVE_KEYS.forEach(key => {
+      const regex = new RegExp(`([?&])${key}=[^&]*`, 'gi');
+      scrubbed = scrubbed.replace(regex, `$1${key}=[REDACTED]`);
+    });
+    return scrubbed;
+  }
+}
+
+/**
+ * Fast check if URL should be ignored (no regex for speed)
+ */
+function shouldIgnoreUrl(url) {
+  const patterns = config.ignorePatterns;
+  for (let i = 0; i < patterns.length; i++) {
+    const pattern = patterns[i];
+    if (pattern && url.indexOf(pattern) !== -1) return true;
+  }
+  return false;
+}
+
+/**
+ * Check if we should sample this request (rate limiting per endpoint)
+ */
+function shouldSampleRequest(urlPath) {
+  const now = Date.now();
+  let entry = endpointCounts.get(urlPath);
+  if (!entry || now - entry.lastReset > SAMPLE_WINDOW) {
+    entry = {
+      count: 0,
+      lastReset: now
+    };
+    endpointCounts.set(urlPath, entry);
+  }
+  entry.count++;
+  return entry.count <= MAX_PER_ENDPOINT;
+}
+
+/**
+ * Add request to pending buffer (non-blocking)
+ */
+function queueRequest(request) {
+  if (pendingCount >= MAX_PENDING_REQUESTS) {
+    // Buffer full, drop oldest
+    pendingHead = (pendingHead + 1) % MAX_PENDING_REQUESTS;
+    pendingCount--;
+  }
+
+  // Scrub URL before queuing
+  request.url = scrubUrl(request.url);
+  pendingRequests[pendingTail] = request;
+  pendingTail = (pendingTail + 1) % MAX_PENDING_REQUESTS;
+  pendingCount++;
+
+  // Schedule flush if not already scheduled
+  if (!flushTimer) {
+    flushTimer = setTimeout(flushPendingRequests, FLUSH_INTERVAL);
+  }
+}
+
+/**
+ * Flush pending requests to callback
+ */
+function flushPendingRequests() {
+  flushTimer = null;
+  if (!logCallback || pendingCount === 0) return;
+
+  // Process all pending requests
+  while (pendingCount > 0) {
+    const request = pendingRequests[pendingHead];
+    pendingRequests[pendingHead] = null; // Allow GC
+    pendingHead = (pendingHead + 1) % MAX_PENDING_REQUESTS;
+    pendingCount--;
+    if (request) {
+      try {
+        logCallback(request);
+      } catch {
+        // Ignore logging errors
+      }
+    }
+  }
+}
+
+/**
+ * Parse URL efficiently (only extract what we need)
+ */
+function parseUrlFast(url) {
+  // Fast path for common patterns
+  let hostEnd = -1;
+  let pathStart = -1;
+
+  // Find :// 
+  const protoEnd = url.indexOf('://');
+  if (protoEnd !== -1) {
+    const afterProto = protoEnd + 3;
+    // Find end of host (first / after ://)
+    const slashPos = url.indexOf('/', afterProto);
+    if (slashPos !== -1) {
+      hostEnd = slashPos;
+      pathStart = slashPos;
+    } else {
+      hostEnd = url.length;
+      pathStart = url.length;
+    }
+    return {
+      host: url.substring(afterProto, hostEnd),
+      path: pathStart < url.length ? url.substring(pathStart) : '/'
+    };
+  }
+
+  // Relative URL
+  return {
+    host: '',
+    path: url
+  };
+}
+
+/**
+ * Intercept fetch - minimal overhead version
+ */
+function interceptFetch() {
+  if (typeof globalThis.fetch === 'undefined') return;
+  if (originalFetch) return;
+  originalFetch = globalThis.fetch;
+  globalThis.fetch = function optimizedFetch(input, init) {
+    // Fast path: if disabled or no callback, skip entirely
+    if (!config.enabled || !logCallback) {
+      return originalFetch(input, init);
+    }
+
+    // Extract URL string (minimal work)
+    const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+
+    // Fast ignore check
+    if (shouldIgnoreUrl(url)) {
+      return originalFetch(input, init);
+    }
+
+    // Parse URL and check sampling
+    const {
+      path
+    } = parseUrlFast(url);
+    if (!shouldSampleRequest(path)) {
+      return originalFetch(input, init);
+    }
+
+    // Capture start time (only synchronous work)
+    const startTime = Date.now();
+    const method = (init?.method || 'GET').toUpperCase();
+
+    // Call original fetch
+    return originalFetch(input, init).then(response => {
+      // Success - queue the log asynchronously
+      queueRequest({
+        requestId: `f${startTime}`,
+        method,
+        url: url.length > config.maxUrlLength ? url.substring(0, config.maxUrlLength) : url,
+        statusCode: response.status,
+        duration: Date.now() - startTime,
+        startTimestamp: startTime,
+        endTimestamp: Date.now(),
+        success: response.ok
+      });
+      return response;
+    }, error => {
+      // Error - queue the log asynchronously  
+      queueRequest({
+        requestId: `f${startTime}`,
+        method,
+        url: url.length > config.maxUrlLength ? url.substring(0, config.maxUrlLength) : url,
+        statusCode: 0,
+        duration: Date.now() - startTime,
+        startTimestamp: startTime,
+        endTimestamp: Date.now(),
+        success: false,
+        errorMessage: error?.message || 'Network error'
+      });
+      throw error;
+    });
+  };
+}
+
+/**
+ * Intercept XMLHttpRequest - minimal overhead version
+ */
+function interceptXHR() {
+  if (typeof XMLHttpRequest === 'undefined') return;
+  if (originalXHROpen) return;
+  originalXHROpen = XMLHttpRequest.prototype.open;
+  originalXHRSend = XMLHttpRequest.prototype.send;
+  XMLHttpRequest.prototype.open = function (method, url, async = true, username, password) {
+    const urlString = typeof url === 'string' ? url : url.toString();
+
+    // Store minimal info
+    this.__rj = {
+      m: method.toUpperCase(),
+      u: urlString,
+      t: 0
+    };
+    return originalXHROpen.call(this, method, urlString, async, username, password);
+  };
+  XMLHttpRequest.prototype.send = function (body) {
+    const data = this.__rj;
+    if (!config.enabled || !logCallback || !data || shouldIgnoreUrl(data.u)) {
+      return originalXHRSend.call(this, body);
+    }
+
+    // Check sampling
+    const {
+      path
+    } = parseUrlFast(data.u);
+    if (!shouldSampleRequest(path)) {
+      return originalXHRSend.call(this, body);
+    }
+    data.t = Date.now();
+    const onComplete = () => {
+      const endTime = Date.now();
+      queueRequest({
+        requestId: `x${data.t}`,
+        method: data.m,
+        url: data.u.length > config.maxUrlLength ? data.u.substring(0, config.maxUrlLength) : data.u,
+        statusCode: this.status,
+        duration: endTime - data.t,
+        startTimestamp: data.t,
+        endTimestamp: endTime,
+        success: this.status >= 200 && this.status < 400,
+        errorMessage: this.status === 0 ? 'Network error' : undefined
+      });
+    };
+
+    // Use load/error events (more efficient than readystatechange)
+    // Note: We use basic addEventListener without options for RN compatibility
+    this.addEventListener('load', onComplete);
+    this.addEventListener('error', onComplete);
+    this.addEventListener('abort', onComplete);
+    return originalXHRSend.call(this, body);
+  };
+}
+
+/**
+ * Initialize network interception
+ */
+export function initNetworkInterceptor(callback, options) {
+  logCallback = callback;
+
+  // Convert patterns to simple strings for fast matching
+  if (options?.ignoreUrls) {
+    config.ignorePatterns = options.ignoreUrls.filter(p => typeof p === 'string');
+    // Note: RegExp patterns are not supported in optimized version for performance
+  }
+  if (options?.captureSizes !== undefined) {
+    config.captureSizes = options.captureSizes;
+  }
+  interceptFetch();
+  interceptXHR();
+}
+
+/**
+ * Disable network interception
+ */
+export function disableNetworkInterceptor() {
+  config.enabled = false;
+
+  // Flush any pending requests
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  flushPendingRequests();
+}
+
+/**
+ * Re-enable network interception
+ */
+export function enableNetworkInterceptor() {
+  config.enabled = true;
+}
+
+/**
+ * Force flush pending requests (call before app termination)
+ */
+export function flushNetworkRequests() {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  flushPendingRequests();
+}
+
+/**
+ * Restore original fetch and XHR
+ */
+export function restoreNetworkInterceptor() {
+  if (originalFetch) {
+    globalThis.fetch = originalFetch;
+    originalFetch = null;
+  }
+  if (originalXHROpen && originalXHRSend) {
+    XMLHttpRequest.prototype.open = originalXHROpen;
+    XMLHttpRequest.prototype.send = originalXHRSend;
+    originalXHROpen = null;
+    originalXHRSend = null;
+  }
+  logCallback = null;
+
+  // Clear state
+  pendingHead = 0;
+  pendingTail = 0;
+  pendingCount = 0;
+  endpointCounts.clear();
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+}
+
+/**
+ * Get stats for debugging
+ */
+export function getNetworkInterceptorStats() {
+  return {
+    pendingCount,
+    endpointCount: endpointCounts.size,
+    enabled: config.enabled
+  };
+}
+//# sourceMappingURL=networkInterceptor.js.map