@diegotsi/flint-core 1.7.0 → 1.8.0

package/dist/index.cjs

@@ -64,6 +64,7 @@ __export(index_exports, {
   collectEnvironment: () => collectEnvironment,
   createConsoleCollector: () => createConsoleCollector,
   createDatadogReplayProvider: () => createDatadogReplayProvider,
+  createErrorCaptureCollector: () => createErrorCaptureCollector,
   createFormErrorCollector: () => createFormErrorCollector,
   createFrustrationCollector: () => createFrustrationCollector,
   createNetworkCollector: () => createNetworkCollector,
@@ -141,8 +142,7 @@ async function submitReplay(serverUrl, projectKey, reportId, events) {
   });
 }
 
-// src/collectors/console.ts
-var MAX_ENTRIES = 50;
+// src/sanitize.ts
 var SENSITIVE_PATTERNS = [
   /(?:password|passwd|pwd|secret|token|api[_-]?key|access[_-]?key|authorization|bearer)\s*[:=]\s*["']?[^\s"',]{4,}/gi,
   /\b(sk-[a-zA-Z0-9_-]{20,})\b/g,
@@ -161,6 +161,9 @@ function sanitize(str) {
   }
   return result;
 }
+
+// src/collectors/console.ts
+var MAX_ENTRIES = 50;
 function createConsoleCollector() {
   const entries = [];
   let active = false;
@@ -280,6 +283,216 @@ function collectEnvironment() {
   };
 }
 
+// src/collectors/errorCapture.ts
+var MAX_MESSAGE = 1e3;
+var MAX_STACK = 8e3;
+var MAX_BATCH = 20;
+var MAX_PAYLOAD_BYTES = 6e4;
+var PER_KEY_PER_MINUTE = 10;
+var GLOBAL_PAGE_CAP = 100;
+var FLUSH_INTERVAL_MS = 5e3;
+var THROTTLE_WINDOW_MS = 6e4;
+var BREADCRUMB_CONSOLE = 10;
+var BREADCRUMB_NETWORK = 10;
+var DEFAULT_IGNORE = [/ResizeObserver loop/i, /^Script error\.?$/];
+var EXTENSION_URL = /(chrome|moz|safari|safari-web)-extension:\/\//;
+function normalizeForKey(message) {
+  return message.toLowerCase().replace(/\d+/g, "#").replace(/\s+/g, " ").trim().slice(0, 200);
+}
+function topFrame(stack) {
+  if (!stack) return "";
+  const lines = stack.split("\n").map((l) => l.trim());
+  return lines.find((l) => l.startsWith("at ") || /@/.test(l)) ?? "";
+}
+function createErrorCaptureCollector(options) {
+  const sampleRate = options.sampleRate ?? 1;
+  const ignoreList = [...DEFAULT_IGNORE, ...options.ignoreErrors ?? []];
+  const sessionId = `s_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
+  let active = false;
+  let queue = [];
+  let interval = null;
+  let sentCount = 0;
+  let environment;
+  const keyTimestamps = /* @__PURE__ */ new Map();
+  function debugLog2(...args) {
+    if (options.debug) console.log("[Flint]", ...args);
+  }
+  function isIgnored(message, stack, frameUrl) {
+    for (const entry of ignoreList) {
+      if (typeof entry === "string") {
+        if (message.includes(entry)) return true;
+      } else if (entry.test(message)) {
+        return true;
+      }
+    }
+    if (EXTENSION_URL.test(frameUrl ?? "") || EXTENSION_URL.test(stack ?? "")) return true;
+    return false;
+  }
+  function isThrottled(localKey) {
+    const now = Date.now();
+    const stamps = (keyTimestamps.get(localKey) ?? []).filter((t) => now - t < THROTTLE_WINDOW_MS);
+    if (stamps.length >= PER_KEY_PER_MINUTE) {
+      keyTimestamps.set(localKey, stamps);
+      return true;
+    }
+    stamps.push(now);
+    keyTimestamps.set(localKey, stamps);
+    return false;
+  }
+  function capture(input) {
+    try {
+      if (sentCount + queue.length >= GLOBAL_PAGE_CAP) return;
+      let message = input.message.slice(0, MAX_MESSAGE);
+      if (isIgnored(message, input.stack, input.frameUrl)) return;
+      if (sampleRate < 1 && Math.random() >= sampleRate) return;
+      const localKey = `${input.type}|${normalizeForKey(message)}|${topFrame(input.stack)}`;
+      if (isThrottled(localKey)) return;
+      const pending = queue.find((e) => e._localKey === localKey);
+      if (pending) {
+        pending.count += 1;
+        return;
+      }
+      message = sanitize(message);
+      const stack = input.stack ? sanitize(input.stack.slice(0, MAX_STACK)) : void 0;
+      if (!environment && options.getEnvironment) {
+        try {
+          environment = options.getEnvironment();
+        } catch {
+        }
+      }
+      const user = options.getUser?.();
+      let event = {
+        type: input.type,
+        message,
+        errorClass: input.errorClass,
+        stack,
+        url: typeof location !== "undefined" ? location.href : "",
+        timestamp: Date.now(),
+        release: options.release,
+        appVersion: options.appVersion,
+        userId: user?.id,
+        sessionId,
+        browser: environment?.browser,
+        os: environment?.os,
+        count: 1,
+        breadcrumbs: options.getBreadcrumbs ? {
+          consoleLogs: options.getBreadcrumbs().consoleLogs.slice(-BREADCRUMB_CONSOLE),
+          networkErrors: options.getBreadcrumbs().networkErrors.slice(-BREADCRUMB_NETWORK)
+        } : void 0,
+        _localKey: localKey
+      };
+      if (options.beforeSend) {
+        try {
+          const result = options.beforeSend(event);
+          if (!result) return;
+          event = { ...result, _localKey: localKey };
+        } catch {
+        }
+      }
+      queue.push(event);
+      debugLog2("Error captured", input.errorClass, message);
+      if (queue.length >= MAX_BATCH) flush(false);
+    } catch {
+    }
+  }
+  function serialize(events) {
+    const wire = events.map(({ _localKey, ...e }) => e);
+    let body = JSON.stringify(wire);
+    if (body.length > MAX_PAYLOAD_BYTES) {
+      body = JSON.stringify(wire.map((e) => ({ ...e, breadcrumbs: void 0 })));
+      if (body.length > MAX_PAYLOAD_BYTES) {
+        body = JSON.stringify(wire.map((e) => ({ ...e, breadcrumbs: void 0, stack: e.stack?.slice(0, 2e3) })));
+      }
+    }
+    return body;
+  }
+  function flush(unloading) {
+    if (queue.length === 0) return;
+    const events = queue;
+    queue = [];
+    sentCount += events.length;
+    const base = options.serverUrl.replace(/\/$/, "");
+    const url = `${base}/api/v1/error-events?project_key=${encodeURIComponent(options.projectKey)}`;
+    const body = serialize(events);
+    if (unloading && typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") {
+      const ok = navigator.sendBeacon(url, body);
+      debugLog2("Flushed via beacon", events.length, ok);
+      if (ok) return;
+    }
+    fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "text/plain;charset=UTF-8" },
+      body,
+      keepalive: unloading
+    }).catch(() => {
+    });
+    debugLog2("Flushed via fetch", events.length);
+  }
+  function onError(event) {
+    const e = event;
+    if (typeof e.message !== "string" && !(e.error instanceof Error)) return;
+    const err = e.error instanceof Error ? e.error : void 0;
+    capture({
+      type: "error",
+      message: err?.message ?? (e.message || "Unknown error"),
+      errorClass: err?.name ?? "Error",
+      stack: err?.stack,
+      frameUrl: e.filename
+    });
+  }
+  function onRejection(event) {
+    const reason = event.reason;
+    const err = reason instanceof Error ? reason : void 0;
+    let message;
+    if (err) {
+      message = err.message;
+    } else {
+      try {
+        message = typeof reason === "string" ? reason : JSON.stringify(reason);
+      } catch {
+        message = String(reason);
+      }
+    }
+    capture({
+      type: "unhandledrejection",
+      message: message || "Unhandled promise rejection",
+      errorClass: err?.name ?? "UnhandledRejection",
+      stack: err?.stack
+    });
+  }
+  function onPageHide() {
+    flush(true);
+  }
+  function onVisibilityChange() {
+    if (document.visibilityState === "hidden") flush(true);
+  }
+  return {
+    start() {
+      if (active) return;
+      active = true;
+      window.addEventListener("error", onError, { capture: true });
+      window.addEventListener("unhandledrejection", onRejection, { capture: true });
+      window.addEventListener("pagehide", onPageHide);
+      document.addEventListener("visibilitychange", onVisibilityChange);
+      interval = setInterval(() => flush(false), FLUSH_INTERVAL_MS);
+    },
+    stop() {
+      if (!active) return;
+      active = false;
+      window.removeEventListener("error", onError, { capture: true });
+      window.removeEventListener("unhandledrejection", onRejection, { capture: true });
+      window.removeEventListener("pagehide", onPageHide);
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+      if (interval) clearInterval(interval);
+      interval = null;
+      flush(false);
+    },
+    flush() {
+      flush(false);
+    }
+  };
+}
+
 // src/collectors/formErrors.ts
 var MAX_ENTRIES2 = 30;
 var POST_SUBMIT_CHECK_MS = 300;
@@ -977,6 +1190,8 @@ function init(config) {
     enableFormErrors = true,
     enableFrustration = false,
     autoReportFrustration = false,
+    enableErrorMonitoring = true,
+    errorMonitoring: errorMonitoringOpts,
     enableReplay = false,
     replayBufferMs = DEFAULT_REPLAY_BUFFER_MS,
     blockedHosts = [],
@@ -1012,6 +1227,23 @@ function init(config) {
   }
   const frustrationCol = enableFrustration ? createFrustrationCollector(frustrationOpts) : null;
   frustrationCol?.start();
+  const errorCaptureCol = enableErrorMonitoring ? createErrorCaptureCollector({
+    serverUrl: config.serverUrl,
+    projectKey: config.projectKey,
+    release: config.release,
+    appVersion: config.appVersion,
+    debug: config.debug,
+    sampleRate: errorMonitoringOpts?.sampleRate,
+    ignoreErrors: errorMonitoringOpts?.ignoreErrors,
+    beforeSend: errorMonitoringOpts?.beforeSend,
+    getUser: () => getSnapshot().user ?? config.user,
+    getBreadcrumbs: () => ({
+      consoleLogs: consoleCol?.getEntries() ?? [],
+      networkErrors: networkCol?.getEntries() ?? []
+    }),
+    getEnvironment: _collectors?.environment ?? collectEnvironment
+  }) : null;
+  errorCaptureCol?.start();
   if (config.user) {
     flint.setUser(config.user);
   }
@@ -1021,7 +1253,8 @@ function init(config) {
     console: !!consoleCol,
     network: !!networkCol,
     formErrors: !!formErrorsCol,
-    frustration: !!frustrationCol
+    frustration: !!frustrationCol,
+    errorCapture: !!errorCaptureCol
   });
   instance = {
     config,
@@ -1029,6 +1262,7 @@ function init(config) {
     network: networkCol,
     formErrors: formErrorsCol,
     frustration: frustrationCol,
+    errorCapture: errorCaptureCol,
     replayEvents,
     stopReplay: null
   };
@@ -1109,6 +1343,7 @@ function shutdown() {
   instance.formErrors?.stop();
   _setFormErrorCollector(null);
   instance.frustration?.stop();
+  instance.errorCapture?.stop();
   instance.stopReplay?.();
   instance = null;
 }
@@ -1200,6 +1435,7 @@ function resolveTheme(theme) {
   collectEnvironment,
   createConsoleCollector,
   createDatadogReplayProvider,
+  createErrorCaptureCollector,
   createFormErrorCollector,
   createFrustrationCollector,
   createNetworkCollector,