react-native-inapp-inspector 2.2.2 → 2.2.4

package/src/helpers/memoryManager.ts

@@ -0,0 +1,138 @@
+import {AppState, NativeEventSubscription, Platform} from 'react-native';
+import {pruneNetworkLogs} from '../customHooks/networkLogger';
+import {pruneConsoleLogs} from '../customHooks/consoleLogger';
+import {pruneReduxHistory} from '../customHooks/reduxLogger';
+import {pruneAnalyticsLogs} from '../customHooks/analyticsLogger';
+import {pruneCrashRecords, addCrashBreadcrumb} from '../customHooks/crashHandler';
+import {prunePerformanceEvents} from '../customHooks/performanceTracker';
+import {showToast} from './toast';
+
+export interface MemoryPruneSummary {
+  timestamp: number;
+  prunedNetwork: number;
+  prunedConsole: number;
+  prunedRedux: number;
+  prunedAnalytics: number;
+  prunedCrashes: number;
+  prunedPerformance: number;
+  totalPruned: number;
+  triggeredBy: 'memory-warning' | 'manual' | 'ram-threshold';
+}
+
+type MemoryWarningListener = (summary: MemoryPruneSummary) => void;
+
+const memoryListeners = new Set<MemoryWarningListener>();
+let appStateSubscription: NativeEventSubscription | null = null;
+let isMemoryWarningHandlerActive = false;
+let lastPruneTimestamp = 0;
+
+/**
+ * Prunes all in-memory log stores to prevent OOM / memory pressure.
+ * Keeps targetRetentionPct (default: 50%) of existing logs.
+ */
+export const pruneAllLogs = (
+  triggeredBy: MemoryPruneSummary['triggeredBy'] = 'manual',
+  targetRetentionPct: number = 0.5,
+): MemoryPruneSummary => {
+  const targetPct = Math.max(0.1, Math.min(1.0, targetRetentionPct));
+
+  const prunedNetwork = pruneNetworkLogs(undefined);
+  const prunedConsole = pruneConsoleLogs(undefined);
+  const prunedRedux = pruneReduxHistory(undefined);
+  const prunedAnalytics = pruneAnalyticsLogs(undefined);
+  const prunedCrashes = pruneCrashRecords(undefined);
+  const prunedPerformance = prunePerformanceEvents(undefined);
+
+  const totalPruned =
+    prunedNetwork +
+    prunedConsole +
+    prunedRedux +
+    prunedAnalytics +
+    prunedCrashes +
+    prunedPerformance;
+
+  lastPruneTimestamp = Date.now();
+
+  // Trigger Hermes/V8 Garbage Collection if exposed
+  if (typeof (globalThis as any).gc === 'function') {
+    try {
+      (globalThis as any).gc();
+    } catch {}
+  }
+
+  const summary: MemoryPruneSummary = {
+    timestamp: lastPruneTimestamp,
+    prunedNetwork,
+    prunedConsole,
+    prunedRedux,
+    prunedAnalytics,
+    prunedCrashes,
+    prunedPerformance,
+    totalPruned,
+    triggeredBy,
+  };
+
+  try {
+    addCrashBreadcrumb(
+      'system',
+      `[MemoryManager] Low memory auto-prune executed (${triggeredBy}). Freed ${totalPruned} log records.`,
+      summary,
+    );
+  } catch {}
+
+  memoryListeners.forEach(listener => {
+    try {
+      listener(summary);
+    } catch {}
+  });
+
+  return summary;
+};
+
+/**
+ * Starts listening to OS memory pressure warnings via AppState 'memoryWarning'.
+ * Automatically prunes logs and notifies subscribers when memory is constrained.
+ */
+export const setupMemoryWarningHandler = (): (() => void) => {
+  if (isMemoryWarningHandlerActive) {
+    return () => {};
+  }
+
+  isMemoryWarningHandlerActive = true;
+
+  try {
+    appStateSubscription = AppState.addEventListener('memoryWarning' as any, (state: any) => {
+      const summary = pruneAllLogs('memory-warning', 0.5);
+      try {
+        showToast(`Memory Warning: Auto-pruned ${summary.totalPruned} inspector logs`);
+      } catch {}
+    });
+  } catch (e) {
+    // AppState memoryWarning might not be supported on all mock/test platforms
+  }
+
+  return () => {
+    if (appStateSubscription) {
+      try {
+        appStateSubscription.remove();
+      } catch {}
+      appStateSubscription = null;
+    }
+    isMemoryWarningHandlerActive = false;
+  };
+};
+
+/**
+ * Subscribes to memory prune events.
+ */
+export const subscribeMemoryWarning = (
+  listener: MemoryWarningListener,
+): (() => void) => {
+  memoryListeners.add(listener);
+  return () => {
+    memoryListeners.delete(listener);
+  };
+};
+
+export const getLastPruneTimestamp = (): number => lastPruneTimestamp;
+export const isMemoryHandlerActive = (): boolean => isMemoryWarningHandlerActive;

package/src/helpers/searchQueryParser.ts

@@ -0,0 +1,283 @@
+import {NetworkLog, SearchScope} from '../types';
+
+export interface SearchQueryOptions {
+  scope?: SearchScope;
+  isRegex?: boolean;
+  isCaseSensitive?: boolean;
+}
+
+/**
+ * Parses query strings like `method:POST is:error slow:>1s status:200 auth`
+ * and checks whether a given NetworkLog matches all tokens against the specified scope.
+ */
+export function matchNetworkLogQuery(
+  log: NetworkLog,
+  searchQuery: string,
+  routePath?: string,
+  options?: SearchQueryOptions,
+): boolean {
+  if (!searchQuery || searchQuery.trim().length === 0) return true;
+
+  const rawTokens =
+    searchQuery.trim().match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
+
+  if (rawTokens.length === 0) return true;
+
+  const isCaseSensitive = Boolean(options?.isCaseSensitive);
+  const isRegex = Boolean(options?.isRegex);
+  const scope = options?.scope || 'all';
+
+  const methodRaw = log.method || '';
+  const urlRaw = log.url || '';
+  const statusNum =
+    typeof log.status === 'number'
+      ? log.status
+      : parseInt(String(log.status || 0), 10);
+  const statusStr = String(log.status ?? '');
+  const durationNum = log.duration || 0;
+  const clientRaw = log.client || '';
+  const reqRaw =
+    typeof log.request === 'string'
+      ? log.request
+      : JSON.stringify(log.request || '');
+  const resRaw =
+    typeof log.response === 'string'
+      ? log.response
+      : JSON.stringify(log.response || '');
+  const reqHeadersRaw = JSON.stringify(log.requestHeaders || '');
+  const resHeadersRaw = JSON.stringify(log.responseHeaders || '');
+  const pathRaw = routePath || '';
+
+  // Construct search corpus based on active scope
+  const getScopedCorpus = (caseSens: boolean): string => {
+    let parts: string[] = [];
+    if (scope === 'url') {
+      parts = [methodRaw, urlRaw, pathRaw];
+    } else if (scope === 'reqBody') {
+      parts = [reqRaw];
+    } else if (scope === 'resBody') {
+      parts = [resRaw];
+    } else if (scope === 'headers') {
+      parts = [reqHeadersRaw, resHeadersRaw];
+    } else {
+      parts = [
+        methodRaw,
+        urlRaw,
+        statusStr,
+        pathRaw,
+        clientRaw,
+        reqRaw,
+        resRaw,
+        reqHeadersRaw,
+        resHeadersRaw,
+      ];
+    }
+    const combined = parts.join(' ');
+    return caseSens ? combined : combined.toLowerCase();
+  };
+
+  const targetCorpus = getScopedCorpus(isCaseSensitive);
+
+  const methodStr = methodRaw.toLowerCase();
+  const urlStr = urlRaw.toLowerCase();
+  const clientStr = clientRaw.toLowerCase();
+  const reqStr = reqRaw.toLowerCase();
+  const resStr = resRaw.toLowerCase();
+  const reqHeadersStr = reqHeadersRaw.toLowerCase();
+  const resHeadersStr = resHeadersRaw.toLowerCase();
+  const pathStr = pathRaw.toLowerCase();
+
+  for (const rawToken of rawTokens) {
+    const token = rawToken.replace(/^["']|["']$/g, '').trim();
+    if (!token) continue;
+
+    const lowerToken = token.toLowerCase();
+
+    // 1. method:<VAL> or m:<VAL>
+    if (lowerToken.startsWith('method:') || lowerToken.startsWith('m:')) {
+      const targetMethod = lowerToken.replace(/^(method:|m:)/, '').trim();
+      if (targetMethod.startsWith('!')) {
+        if (methodStr === targetMethod.slice(1)) return false;
+      } else {
+        if (methodStr !== targetMethod) return false;
+      }
+      continue;
+    }
+
+    // 2. status:<VAL> or s:<VAL>
+    if (lowerToken.startsWith('status:') || lowerToken.startsWith('s:')) {
+      const val = lowerToken.replace(/^(status:|s:)/, '').trim();
+      if (val.startsWith('>=')) {
+        const threshold = parseInt(val.slice(2), 10);
+        if (isNaN(threshold) || statusNum < threshold) return false;
+      } else if (val.startsWith('>')) {
+        const threshold = parseInt(val.slice(1), 10);
+        if (isNaN(threshold) || statusNum <= threshold) return false;
+      } else if (val.startsWith('<=')) {
+        const threshold = parseInt(val.slice(2), 10);
+        if (isNaN(threshold) || statusNum > threshold) return false;
+      } else if (val.startsWith('<')) {
+        const threshold = parseInt(val.slice(1), 10);
+        if (isNaN(threshold) || statusNum >= threshold) return false;
+      } else if (val.endsWith('xx') || val.endsWith('x')) {
+        const prefix = val.replace(/x/g, '');
+        if (!statusStr.startsWith(prefix)) return false;
+      } else {
+        const targetCode = parseInt(val, 10);
+        if (!isNaN(targetCode)) {
+          if (statusNum !== targetCode) return false;
+        } else if (!statusStr.includes(val)) {
+          return false;
+        }
+      }
+      continue;
+    }
+
+    // 3. is:<FLAG>
+    if (lowerToken.startsWith('is:')) {
+      const flag = lowerToken.slice(3).trim();
+      if (
+        flag === 'error' ||
+        flag === 'failed' ||
+        flag === 'err' ||
+        flag === 'fail'
+      ) {
+        const isErr =
+          log.status === 0 || log.status == null || statusNum >= 400;
+        if (!isErr) return false;
+      } else if (flag === 'success' || flag === 'ok' || flag === '2xx') {
+        const isSuccess = statusNum >= 200 && statusNum < 300;
+        if (!isSuccess) return false;
+      } else if (flag === 'slow') {
+        if (durationNum < 1000) return false;
+      } else if (flag === 'fast') {
+        if (durationNum >= 200) return false;
+      } else if (flag === 'graphql' || flag === 'gql') {
+        const isGql =
+          urlStr.includes('graphql') ||
+          clientStr === 'graphql' ||
+          clientStr === 'apollo';
+        if (!isGql) return false;
+      } else if (flag === 'https') {
+        if (!urlStr.startsWith('https')) return false;
+      } else if (flag === 'http') {
+        if (urlStr.startsWith('https') || !urlStr.startsWith('http'))
+          return false;
+      } else if (flag === 'json') {
+        const isJson =
+          reqHeadersStr.includes('application/json') ||
+          resHeadersStr.includes('application/json') ||
+          urlStr.includes('.json');
+        if (!isJson) return false;
+      }
+      continue;
+    }
+
+    // 4. slow:<DURATION> or dur:<DURATION> or duration:<DURATION>
+    if (
+      lowerToken.startsWith('slow:') ||
+      lowerToken.startsWith('dur:') ||
+      lowerToken.startsWith('duration:')
+    ) {
+      const val = lowerToken.replace(/^(slow:|dur:|duration:)/, '').trim();
+      let thresholdMs = 0;
+      let isGreater = true;
+
+      let cleanVal = val;
+      if (val.startsWith('>=')) {
+        isGreater = true;
+        cleanVal = val.slice(2);
+      } else if (val.startsWith('>')) {
+        isGreater = true;
+        cleanVal = val.slice(1);
+      } else if (val.startsWith('<=')) {
+        isGreater = false;
+        cleanVal = val.slice(2);
+      } else if (val.startsWith('<')) {
+        isGreater = false;
+        cleanVal = val.slice(1);
+      }
+
+      if (cleanVal.endsWith('s') && !cleanVal.endsWith('ms')) {
+        thresholdMs = parseFloat(cleanVal.slice(0, -1)) * 1000;
+      } else if (cleanVal.endsWith('ms')) {
+        thresholdMs = parseFloat(cleanVal.slice(0, -2));
+      } else {
+        thresholdMs = parseFloat(cleanVal);
+      }
+
+      if (!isNaN(thresholdMs)) {
+        if (isGreater) {
+          if (durationNum < thresholdMs) return false;
+        } else {
+          if (durationNum > thresholdMs) return false;
+        }
+      }
+      continue;
+    }
+
+    // 5. client:<CLIENT> or c:<CLIENT>
+    if (lowerToken.startsWith('client:') || lowerToken.startsWith('c:')) {
+      const targetClient = lowerToken.replace(/^(client:|c:)/, '').trim();
+      if (!clientStr.includes(targetClient)) return false;
+      continue;
+    }
+
+    // 6. domain:<DOMAIN> or d:<DOMAIN>
+    if (lowerToken.startsWith('domain:') || lowerToken.startsWith('d:')) {
+      const targetDomain = lowerToken.replace(/^(domain:|d:)/, '').trim();
+      if (!urlStr.includes(targetDomain)) return false;
+      continue;
+    }
+
+    // 7. path:<PATH> or p:<PATH>
+    if (lowerToken.startsWith('path:') || lowerToken.startsWith('p:')) {
+      const targetPath = lowerToken.replace(/^(path:|p:)/, '').trim();
+      if (!urlStr.includes(targetPath) && !pathStr.includes(targetPath)) {
+        return false;
+      }
+      continue;
+    }
+
+    // 8. req:<TERM> or body:<TERM>
+    if (lowerToken.startsWith('req:') || lowerToken.startsWith('body:')) {
+      const target = lowerToken.replace(/^(req:|body:)/, '').trim();
+      if (!reqStr.includes(target)) return false;
+      continue;
+    }
+
+    // 9. res:<TERM>
+    if (lowerToken.startsWith('res:')) {
+      const target = lowerToken.slice(4).trim();
+      if (!resStr.includes(target)) return false;
+      continue;
+    }
+
+    // 10. header:<TERM> or h:<TERM>
+    if (lowerToken.startsWith('header:') || lowerToken.startsWith('h:')) {
+      const target = lowerToken.replace(/^(header:|h:)/, '').trim();
+      if (!reqHeadersStr.includes(target) && !resHeadersStr.includes(target)) {
+        return false;
+      }
+      continue;
+    }
+
+    // 11. Generic Match (handles Regex, Case-sensitivity, and Scoped corpus)
+    if (isRegex) {
+      try {
+        const re = new RegExp(token, isCaseSensitive ? '' : 'i');
+        if (!re.test(targetCorpus)) return false;
+      } catch {
+        const queryTerm = isCaseSensitive ? token : lowerToken;
+        if (!targetCorpus.includes(queryTerm)) return false;
+      }
+    } else {
+      const queryTerm = isCaseSensitive ? token : lowerToken;
+      if (!targetCorpus.includes(queryTerm)) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}

package/src/helpers/settingsStore.ts

@@ -0,0 +1,171 @@
+// #5 — Persistence layer for the inspector's settings selections.
+//
+// Backed by iOS Settings (NSUserDefaults) for iOS, or custom storage if passed (e.g. AsyncStorage/MMKV).
+// Contains an in-memory fallback for Android or Jest test environments.
+
+import { Platform, Settings } from 'react-native';
+import {InspectorStorage, PersistedSettings} from '../types';
+import {
+  getNativeStorageItem,
+  setNativeStorageItem,
+  isNativeModuleAvailable,
+} from '../native/NativeInspector';
+
+export {InspectorStorage, PersistedSettings};
+
+// In-memory fallback (settings survive for the app session only).
+const memory = new Map<string, string>();
+
+let customStorage: InspectorStorage | null = null;
+
+export function setCustomStorage(storage: InspectorStorage | null) {
+  customStorage = storage;
+}
+
+const SETTINGS_KEY = 'rn-inapp-inspector.settings.v1';
+
+export async function loadSettings(): Promise<PersistedSettings> {
+  try {
+    if (customStorage) {
+      const raw = await customStorage.getItem(SETTINGS_KEY);
+      if (!raw) return {};
+      const parsed = JSON.parse(raw);
+      return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+
+    if (isNativeModuleAvailable()) {
+      const raw = await getNativeStorageItem(SETTINGS_KEY);
+      if (raw) {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+      }
+    }
+
+    if (Platform.OS === 'ios') {
+      const raw = Settings.get(SETTINGS_KEY);
+      if (!raw) return {};
+      if (typeof raw === 'string') {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+      }
+      return raw && typeof raw === 'object' ? raw : {};
+    }
+
+    // In-memory fallback
+    const raw = memory.get(SETTINGS_KEY);
+    if (!raw) return {};
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+export function saveSettings(settings: PersistedSettings): void {
+  try {
+    const raw = JSON.stringify(settings);
+
+    if (customStorage) {
+      customStorage.setItem(SETTINGS_KEY, raw);
+      return;
+    }
+
+    if (isNativeModuleAvailable()) {
+      setNativeStorageItem(SETTINGS_KEY, raw);
+    }
+
+    if (Platform.OS === 'ios') {
+      Settings.set({ [SETTINGS_KEY]: raw });
+      return;
+    }
+
+    memory.set(SETTINGS_KEY, raw);
+  } catch {
+    // ignore
+  }
+}
+
+export async function clearPersistedSettings(): Promise<void> {
+  try {
+    if (customStorage) {
+      if (typeof (customStorage as any).removeItem === 'function') {
+        await (customStorage as any).removeItem(SETTINGS_KEY);
+      } else {
+        await customStorage.setItem(SETTINGS_KEY, '');
+      }
+      return;
+    }
+
+    if (isNativeModuleAvailable()) {
+      await setNativeStorageItem(SETTINGS_KEY, null);
+    }
+
+    if (Platform.OS === 'ios') {
+      Settings.set({ [SETTINGS_KEY]: null });
+      return;
+    }
+
+    memory.delete(SETTINGS_KEY);
+  } catch {
+    // ignore
+  }
+}
+
+export const isPersistentStorageAvailable = () => {
+  return customStorage !== null || isNativeModuleAvailable() || Platform.OS === 'ios';
+};
+
+export function getCustomStorage(): InspectorStorage | null {
+  return customStorage;
+}
+
+export interface RamLimitsProfile {
+  maxNetworkLogs: number;
+  maxConsoleLogs: number;
+  maxAnalyticsEvents: number;
+  maxCrashRecords: number;
+  profileName: 'High-End' | 'Standard' | 'Compact' | 'Ultra-Light';
+  freeRamMb: number;
+}
+
+export function calculateRamBasedLimits(freeRamMb: number): RamLimitsProfile {
+  if (freeRamMb >= 3000) {
+    return {
+      maxNetworkLogs: 100,
+      maxConsoleLogs: 100,
+      maxAnalyticsEvents: 75,
+      maxCrashRecords: 50,
+      profileName: 'High-End',
+      freeRamMb,
+    };
+  } else if (freeRamMb >= 1500) {
+    return {
+      maxNetworkLogs: 100,
+      maxConsoleLogs: 100,
+      maxAnalyticsEvents: 75,
+      maxCrashRecords: 50,
+      profileName: 'Standard',
+      freeRamMb,
+    };
+  } else if (freeRamMb >= 600) {
+    return {
+      maxNetworkLogs: 100,
+      maxConsoleLogs: 100,
+      maxAnalyticsEvents: 50,
+      maxCrashRecords: 25,
+      profileName: 'Compact',
+      freeRamMb,
+    };
+  } else {
+    return {
+      maxNetworkLogs: 50,
+      maxConsoleLogs: 50,
+      maxAnalyticsEvents: 25,
+      maxCrashRecords: 15,
+      profileName: 'Ultra-Light',
+      freeRamMb,
+    };
+  }
+}
+
+