@crashsense/core 1.0.4 → 1.1.0

package/dist/index.mjs

@@ -30,7 +30,12 @@ function resolveConfig(userConfig) {
     preCrashMemoryThreshold: userConfig.preCrashMemoryThreshold ?? 0.8,
     piiScrubbing: userConfig.piiScrubbing ?? true,
     debug: userConfig.debug ?? false,
-    onCrash: userConfig.onCrash ?? null
+    onCrash: userConfig.onCrash ?? null,
+    enableOOMRecovery: userConfig.enableOOMRecovery ?? false,
+    checkpointInterval: userConfig.checkpointInterval ?? 1e4,
+    oomRecoveryThreshold: userConfig.oomRecoveryThreshold ?? 0.3,
+    flushEndpoint: userConfig.flushEndpoint ?? null,
+    onOOMRecovery: userConfig.onOOMRecovery ?? null
   };
 }
 
@@ -968,6 +973,373 @@ function classifyCrash(event) {
   };
 }
 
+// src/checkpoint-manager.ts
+var CHECKPOINT_KEY = "__crashsense_checkpoint";
+var CHECKPOINT_VERSION = 1;
+function createCheckpointManager(bus, config, sessionId, deviceInfo, getSystemState, getBreadcrumbs) {
+  let intervalId = null;
+  let checkpointCount = 0;
+  const preCrashWarnings = [];
+  let lastMemoryTrend = null;
+  function hasSessionStorage() {
+    try {
+      return typeof sessionStorage !== "undefined" && sessionStorage !== null;
+    } catch {
+      return false;
+    }
+  }
+  function writeCheckpoint() {
+    if (!hasSessionStorage()) return;
+    checkpointCount++;
+    const systemState = getSystemState();
+    if (systemState.memory?.trend) {
+      lastMemoryTrend = systemState.memory.trend;
+    }
+    const checkpoint = {
+      version: CHECKPOINT_VERSION,
+      timestamp: Date.now(),
+      sessionId,
+      appId: config.appId,
+      url: typeof location !== "undefined" ? location.href : "",
+      breadcrumbs: getBreadcrumbs().slice(-20),
+      systemState,
+      device: deviceInfo,
+      preCrashWarnings: preCrashWarnings.slice(-5),
+      memoryTrend: lastMemoryTrend,
+      checkpointCount
+    };
+    try {
+      sessionStorage.setItem(CHECKPOINT_KEY, JSON.stringify(checkpoint));
+      bus.emit("checkpoint_written", { timestamp: checkpoint.timestamp, sessionId });
+    } catch {
+      try {
+        const minimal = {
+          ...checkpoint,
+          breadcrumbs: checkpoint.breadcrumbs.slice(-5),
+          systemState: { memory: systemState.memory }
+        };
+        sessionStorage.setItem(CHECKPOINT_KEY, JSON.stringify(minimal));
+      } catch {
+      }
+    }
+  }
+  bus.on("pre_crash_warning", (data) => {
+    preCrashWarnings.push({
+      level: data.level,
+      reason: data.reason,
+      timestamp: data.timestamp
+    });
+    while (preCrashWarnings.length > 10) {
+      preCrashWarnings.shift();
+    }
+    writeCheckpoint();
+  });
+  bus.on("crash_detected", () => {
+    writeCheckpoint();
+  });
+  return {
+    start() {
+      if (typeof window === "undefined") return;
+      if (!hasSessionStorage()) return;
+      writeCheckpoint();
+      intervalId = setInterval(writeCheckpoint, config.checkpointInterval);
+    },
+    stop() {
+      if (intervalId !== null) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+    },
+    /** Force an immediate checkpoint write (used by lifecycle flush) */
+    flush() {
+      writeCheckpoint();
+    },
+    /** Read and remove the stored checkpoint (used by OOM recovery on next load) */
+    static: {
+      readCheckpoint() {
+        try {
+          if (typeof sessionStorage === "undefined") return null;
+          const raw = sessionStorage.getItem(CHECKPOINT_KEY);
+          if (!raw) return null;
+          const data = JSON.parse(raw);
+          if (data.version !== CHECKPOINT_VERSION) return null;
+          return data;
+        } catch {
+          return null;
+        }
+      },
+      clearCheckpoint() {
+        try {
+          if (typeof sessionStorage !== "undefined") {
+            sessionStorage.removeItem(CHECKPOINT_KEY);
+          }
+        } catch {
+        }
+      }
+    },
+    /** Clear checkpoint on clean shutdown (destroy) */
+    clearOnDestroy() {
+      try {
+        if (hasSessionStorage()) {
+          sessionStorage.removeItem(CHECKPOINT_KEY);
+        }
+      } catch {
+      }
+    }
+  };
+}
+function readCheckpoint() {
+  try {
+    if (typeof sessionStorage === "undefined") return null;
+    const raw = sessionStorage.getItem(CHECKPOINT_KEY);
+    if (!raw) return null;
+    const data = JSON.parse(raw);
+    if (data.version !== CHECKPOINT_VERSION) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function clearCheckpoint() {
+  try {
+    if (typeof sessionStorage !== "undefined") {
+      sessionStorage.removeItem(CHECKPOINT_KEY);
+    }
+  } catch {
+  }
+}
+function getNavigationType() {
+  try {
+    if (typeof performance === "undefined") return "unknown";
+    const entries = performance.getEntriesByType("navigation");
+    if (entries.length > 0) {
+      return entries[0].type || "unknown";
+    }
+  } catch {
+  }
+  return "unknown";
+}
+function getWasDiscarded() {
+  try {
+    const doc = document;
+    if ("wasDiscarded" in doc) {
+      return doc.wasDiscarded;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function detectOOMRecovery(bus, config, currentSessionId) {
+  if (typeof window === "undefined") return null;
+  const checkpoint = readCheckpoint();
+  if (!checkpoint) return null;
+  clearCheckpoint();
+  const now = Date.now();
+  const timeSinceCheckpoint = now - checkpoint.timestamp;
+  const MAX_OOM_AGE = 5 * 60 * 1e3;
+  if (timeSinceCheckpoint > MAX_OOM_AGE) return null;
+  if (checkpoint.appId !== config.appId) return null;
+  const wasDiscarded = getWasDiscarded();
+  const navigationType = getNavigationType();
+  const deviceInfo = collectDeviceInfo();
+  const signals = [];
+  let probability = 0;
+  if (wasDiscarded === true) {
+    probability += 0.45;
+    signals.push({
+      signal: "document_was_discarded",
+      weight: 0.45,
+      evidence: "document.wasDiscarded is true \u2014 OS confirmed tab discard"
+    });
+  }
+  if (navigationType === "reload" && timeSinceCheckpoint < 3e4) {
+    probability += 0.25;
+    signals.push({
+      signal: "recent_reload",
+      weight: 0.25,
+      evidence: `Page reloaded ${Math.round(timeSinceCheckpoint / 1e3)}s after last checkpoint`
+    });
+  } else if (navigationType === "reload" && timeSinceCheckpoint < 6e4) {
+    probability += 0.15;
+    signals.push({
+      signal: "moderate_reload",
+      weight: 0.15,
+      evidence: `Page reloaded ${Math.round(timeSinceCheckpoint / 1e3)}s after last checkpoint`
+    });
+  }
+  if (checkpoint.memoryTrend === "growing") {
+    probability += 0.1;
+    signals.push({
+      signal: "memory_growing_trend",
+      weight: 0.1,
+      evidence: "Memory was in growing trend before tab died"
+    });
+  } else if (checkpoint.memoryTrend === "spike") {
+    probability += 0.08;
+    signals.push({
+      signal: "memory_spike",
+      weight: 0.08,
+      evidence: "Memory was spiking before tab died"
+    });
+  }
+  if (checkpoint.preCrashWarnings.length > 0) {
+    const highestLevel = checkpoint.preCrashWarnings.reduce((max, w) => {
+      const severity = { elevated: 1, critical: 2, imminent: 3 };
+      return (severity[w.level] || 0) > (severity[max.level] || 0) ? w : max;
+    }, checkpoint.preCrashWarnings[0]);
+    if (highestLevel.level === "imminent") {
+      probability += 0.15;
+      signals.push({
+        signal: "pre_crash_warning_imminent",
+        weight: 0.15,
+        evidence: `Pre-crash warning at IMMINENT level: ${highestLevel.reason}`
+      });
+    } else if (highestLevel.level === "critical") {
+      probability += 0.1;
+      signals.push({
+        signal: "pre_crash_warning_critical",
+        weight: 0.1,
+        evidence: `Pre-crash warning at CRITICAL level: ${highestLevel.reason}`
+      });
+    } else {
+      probability += 0.05;
+      signals.push({
+        signal: "pre_crash_warning_elevated",
+        weight: 0.05,
+        evidence: `Pre-crash warning at ELEVATED level: ${highestLevel.reason}`
+      });
+    }
+  }
+  const memUtil = checkpoint.systemState?.memory?.utilizationPercent;
+  if (memUtil !== void 0 && memUtil !== null && memUtil > 85) {
+    probability += 0.1;
+    signals.push({
+      signal: "high_memory_at_checkpoint",
+      weight: 0.1,
+      evidence: `Memory was at ${memUtil}% utilization at last checkpoint`
+    });
+  }
+  if (checkpoint.device.touchSupport && checkpoint.device.deviceMemory !== null && checkpoint.device.deviceMemory <= 4) {
+    probability += 0.05;
+    signals.push({
+      signal: "mobile_low_memory_device",
+      weight: 0.05,
+      evidence: `Touch device with ${checkpoint.device.deviceMemory}GB RAM \u2014 higher OOM risk`
+    });
+  }
+  probability = Math.min(probability, 1);
+  if (probability < config.oomRecoveryThreshold) return null;
+  const report = {
+    id: generateId(),
+    type: "oom_recovery",
+    timestamp: now,
+    probability,
+    sessionId: currentSessionId,
+    previousSessionId: checkpoint.sessionId,
+    timeSinceLastCheckpoint: timeSinceCheckpoint,
+    wasDiscarded,
+    navigationType,
+    lastCheckpoint: checkpoint,
+    device: deviceInfo,
+    signals
+  };
+  bus.emit("oom_recovery", { report });
+  if (config.onOOMRecovery) {
+    try {
+      config.onOOMRecovery(report);
+    } catch {
+    }
+  }
+  if (config.debug) {
+    logOOMRecovery(report);
+  }
+  return report;
+}
+function logOOMRecovery(report) {
+  if (typeof console === "undefined") return;
+  const header = `[CrashSense] OOM Recovery Detected (${(report.probability * 100).toFixed(0)}% confidence)`;
+  const details = [
+    `Previous session: ${report.previousSessionId}`,
+    `Time since last checkpoint: ${Math.round(report.timeSinceLastCheckpoint / 1e3)}s`,
+    `Navigation type: ${report.navigationType}`,
+    `document.wasDiscarded: ${report.wasDiscarded}`,
+    `Last URL: ${report.lastCheckpoint.url}`,
+    `Memory trend: ${report.lastCheckpoint.memoryTrend || "unknown"}`,
+    `Pre-crash warnings: ${report.lastCheckpoint.preCrashWarnings.length}`,
+    `Breadcrumbs recovered: ${report.lastCheckpoint.breadcrumbs.length}`
+  ];
+  console.groupCollapsed?.(header) ?? console.log(header);
+  for (const d of details) console.log(d);
+  if (report.signals.length > 0) {
+    console.log("Signals:");
+    for (const s of report.signals) {
+      console.log(`  - ${s.signal} (${(s.weight * 100).toFixed(0)}%): ${s.evidence}`);
+    }
+  }
+  console.groupEnd?.();
+}
+
+// src/lifecycle-flush.ts
+function createLifecycleFlush(bus, config, sessionId, getSystemState, getBreadcrumbs, flushCheckpoint) {
+  let installed = false;
+  function buildFlushPayload(reason) {
+    return JSON.stringify({
+      type: "lifecycle_flush",
+      reason,
+      timestamp: Date.now(),
+      sessionId,
+      appId: config.appId,
+      url: typeof location !== "undefined" ? location.href : "",
+      breadcrumbs: getBreadcrumbs().slice(-10),
+      systemState: getSystemState()
+    });
+  }
+  function flush(reason) {
+    flushCheckpoint();
+    if (config.flushEndpoint && typeof navigator !== "undefined" && navigator.sendBeacon) {
+      try {
+        const payload = buildFlushPayload(reason);
+        navigator.sendBeacon(config.flushEndpoint, payload);
+      } catch {
+      }
+    }
+    bus.emit("lifecycle_flush", { reason, timestamp: Date.now() });
+  }
+  function handleVisibilityChange() {
+    if (typeof document !== "undefined" && document.visibilityState === "hidden") {
+      flush("visibilitychange_hidden");
+    }
+  }
+  function handlePageHide() {
+    flush("pagehide");
+  }
+  function handleFreeze() {
+    flush("freeze");
+  }
+  return {
+    install() {
+      if (typeof window === "undefined") return;
+      if (installed) return;
+      installed = true;
+      document.addEventListener("visibilitychange", handleVisibilityChange);
+      window.addEventListener("pagehide", handlePageHide, { capture: true });
+      if ("onfreeze" in document) {
+        document.addEventListener("freeze", handleFreeze);
+      }
+    },
+    uninstall() {
+      if (typeof window === "undefined") return;
+      if (!installed) return;
+      installed = false;
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+      window.removeEventListener("pagehide", handlePageHide, { capture: true });
+      if ("onfreeze" in document) {
+        document.removeEventListener("freeze", handleFreeze);
+      }
+    }
+  };
+}
+
 // src/crashsense.ts
 function createCrashSense(userConfig) {
   const config = resolveConfig(userConfig);
@@ -985,6 +1357,34 @@ function createCrashSense(userConfig) {
   const breadcrumbTracker = createBreadcrumbTracker(bus);
   const iframeTracker = createIframeTracker(bus);
   const preCrashWarning = createPreCrashWarning(bus, config, memoryMonitor, iframeTracker);
+  const checkpointManager = createCheckpointManager(
+    bus,
+    config,
+    sessionId,
+    deviceInfo,
+    () => ({
+      memory: memoryMonitor.getSnapshot(),
+      cpu: eventLoopMonitor.getCpuSnapshot(),
+      eventLoop: eventLoopMonitor.getEventLoopSnapshot(),
+      network: networkMonitor.getSnapshot(),
+      iframe: config.enableIframeTracking ? iframeTracker.getSnapshot() : void 0
+    }),
+    () => breadcrumbTracker.getBreadcrumbs()
+  );
+  const lifecycleFlush = createLifecycleFlush(
+    bus,
+    config,
+    sessionId,
+    () => ({
+      memory: memoryMonitor.getSnapshot(),
+      cpu: eventLoopMonitor.getCpuSnapshot(),
+      eventLoop: eventLoopMonitor.getEventLoopSnapshot(),
+      network: networkMonitor.getSnapshot(),
+      iframe: config.enableIframeTracking ? iframeTracker.getSnapshot() : void 0
+    }),
+    () => breadcrumbTracker.getBreadcrumbs(),
+    () => checkpointManager.flush()
+  );
   function buildRawEvent(error, source) {
     const stack = error.stack ? parseStackTrace(error.stack) : [];
     return {
@@ -1133,6 +1533,9 @@ function createCrashSense(userConfig) {
       data: { level: data.level, memoryUtilization: data.memoryUtilization, iframeCount: data.iframeCount }
     });
   });
+  if (config.enableOOMRecovery) {
+    detectOOMRecovery(bus, config, sessionId);
+  }
   errorInterceptor.install();
   breadcrumbTracker.install();
   if (config.enableMemoryMonitoring) memoryMonitor.start();
@@ -1140,6 +1543,10 @@ function createCrashSense(userConfig) {
   if (config.enableNetworkMonitoring) networkMonitor.start();
   if (config.enableIframeTracking) iframeTracker.start();
   if (config.enablePreCrashWarning) preCrashWarning.start();
+  if (config.enableOOMRecovery) {
+    checkpointManager.start();
+    lifecycleFlush.install();
+  }
   const core = {
     get config() {
       return config;
@@ -1197,6 +1604,9 @@ function createCrashSense(userConfig) {
       networkMonitor.stop();
       iframeTracker.stop();
       preCrashWarning.stop();
+      checkpointManager.stop();
+      checkpointManager.clearOnDestroy();
+      lifecycleFlush.uninstall();
       for (const plugin of plugins) {
         plugin.teardown();
       }