@diegotsi/flint-core 1.7.0 → 1.8.0

package/dist/index.d.ts

@@ -75,6 +75,32 @@ interface FormErrorEntry {
     url: string;
     timestamp: number;
 }
+interface ErrorBreadcrumbs {
+    consoleLogs: ConsoleEntry[];
+    networkErrors: NetworkEntry[];
+}
+interface ErrorEventPayload {
+    type: "error" | "unhandledrejection";
+    message: string;
+    errorClass: string;
+    stack?: string;
+    /** Page URL where the error occurred */
+    url: string;
+    /** Client time — orders breadcrumbs only; the server buckets by receive time */
+    timestamp: number;
+    release?: string;
+    appVersion?: string;
+    userId?: string;
+    /** Anonymous per-page-load session hash when no user is set */
+    sessionId?: string;
+    browser?: string;
+    os?: string;
+    /** In-batch dedup count — identical errors merged client-side before flush */
+    count: number;
+    breadcrumbs?: ErrorBreadcrumbs;
+    /** @internal client-side throttle/dedup key — stripped before sending */
+    _localKey?: string;
+}
 type Locale = "pt-BR" | "en-US";
 type Theme = "light" | "dark" | ThemeOverride;
 interface ThemeOverride {
@@ -128,6 +154,16 @@ interface FlintConfig {
         enableDeadClicks?: boolean;
     };
     onFrustration?: (event: FrustrationEvent) => void;
+    /** Capture uncaught errors & unhandled rejections automatically. Default: true */
+    enableErrorMonitoring?: boolean;
+    errorMonitoring?: {
+        /** Fraction of captured errors to report, 0..1. Default: 1.0 */
+        sampleRate?: number;
+        /** Errors whose message matches any entry are dropped (string = substring match) */
+        ignoreErrors?: (string | RegExp)[];
+        /** Mutate or drop (return null) an event before it is sent */
+        beforeSend?: (event: ErrorEventPayload) => ErrorEventPayload | null;
+    };
     /** Application version string, e.g. "2.1.0" */
     appVersion?: string;
     /** Release/deploy identifier, e.g. "v2.1.0-rc1" or a commit SHA */
@@ -185,6 +221,33 @@ declare function submitReplay(serverUrl: string, projectKey: string, reportId: s
 
 declare function collectEnvironment(): EnvironmentInfo;
 
+interface ErrorCaptureCollector {
+    start(): void;
+    stop(): void;
+    /** Flush pending events immediately (also called on pagehide/interval). */
+    flush(): void;
+}
+interface ErrorCaptureOptions {
+    serverUrl: string;
+    projectKey: string;
+    release?: string;
+    appVersion?: string;
+    /** Fraction of captured errors to report, 0..1. Default 1.0 */
+    sampleRate?: number;
+    /** Errors whose message matches any entry are dropped (string = substring match) */
+    ignoreErrors?: (string | RegExp)[];
+    /** Mutate or drop (return null) an event before it is queued for sending */
+    beforeSend?: (event: ErrorEventPayload) => ErrorEventPayload | null;
+    getUser?: () => FlintUser | undefined;
+    getBreadcrumbs?: () => {
+        consoleLogs: ConsoleEntry[];
+        networkErrors: NetworkEntry[];
+    };
+    getEnvironment?: () => EnvironmentInfo;
+    debug?: boolean;
+}
+declare function createErrorCaptureCollector(options: ErrorCaptureOptions): ErrorCaptureCollector;
+
 interface FormErrorCollector {
     start(): void;
     stop(): void;
@@ -233,6 +296,7 @@ interface FlintInstance {
     network: NetworkCollector | null;
     formErrors: FormErrorCollector | null;
     frustration: FrustrationCollector | null;
+    errorCapture: ErrorCaptureCollector | null;
     replayEvents: unknown[];
     stopReplay: (() => void) | null;
 }
@@ -282,4 +346,4 @@ interface ResolvedTheme {
 }
 declare function resolveTheme(theme: Theme): ResolvedTheme;
 
-export { type CollectedMeta, type ConsoleCollector, type ConsoleEntry, DATADOG_BLOCKED_HOSTS, type EnvironmentInfo, Flint, type FlintConfig, type FlintState, type FlintUser, type FlintWidgetProps, type FormErrorCollector, type FormErrorEntry, type FrustrationCollector, type FrustrationEvent, type Locale, type NetworkCollector, type NetworkEntry, type ReportPayload, type ReportResult, type ResolvedTheme, type Severity, type Theme, type ThemeOverride, _setFormErrorCollector, collectEnvironment, createConsoleCollector, createDatadogReplayProvider, createFormErrorCollector, createFrustrationCollector, createNetworkCollector, getSnapshot, resolveTheme, submitReplay, submitReport, subscribe };
+export { type CollectedMeta, type ConsoleCollector, type ConsoleEntry, DATADOG_BLOCKED_HOSTS, type EnvironmentInfo, type ErrorBreadcrumbs, type ErrorCaptureCollector, type ErrorCaptureOptions, type ErrorEventPayload, Flint, type FlintConfig, type FlintState, type FlintUser, type FlintWidgetProps, type FormErrorCollector, type FormErrorEntry, type FrustrationCollector, type FrustrationEvent, type Locale, type NetworkCollector, type NetworkEntry, type ReportPayload, type ReportResult, type ResolvedTheme, type Severity, type Theme, type ThemeOverride, _setFormErrorCollector, collectEnvironment, createConsoleCollector, createDatadogReplayProvider, createErrorCaptureCollector, createFormErrorCollector, createFrustrationCollector, createNetworkCollector, getSnapshot, resolveTheme, submitReplay, submitReport, subscribe };

package/dist/index.js

@@ -69,8 +69,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,
@@ -89,6 +88,9 @@ function sanitize(str) {
   }
   return result;
 }
+
+// src/collectors/console.ts
+var MAX_ENTRIES = 50;
 function createConsoleCollector() {
   const entries = [];
   let active = false;
@@ -208,6 +210,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;
@@ -902,6 +1114,8 @@ function init(config) {
     enableFormErrors = true,
     enableFrustration = false,
     autoReportFrustration = false,
+    enableErrorMonitoring = true,
+    errorMonitoring: errorMonitoringOpts,
     enableReplay = false,
     replayBufferMs = DEFAULT_REPLAY_BUFFER_MS,
     blockedHosts = [],
@@ -937,6 +1151,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);
   }
@@ -946,7 +1177,8 @@ function init(config) {
     console: !!consoleCol,
     network: !!networkCol,
     formErrors: !!formErrorsCol,
-    frustration: !!frustrationCol
+    frustration: !!frustrationCol,
+    errorCapture: !!errorCaptureCol
   });
   instance = {
     config,
@@ -954,6 +1186,7 @@ function init(config) {
     network: networkCol,
     formErrors: formErrorsCol,
     frustration: frustrationCol,
+    errorCapture: errorCaptureCol,
     replayEvents,
     stopReplay: null
   };
@@ -1034,6 +1267,7 @@ function shutdown() {
   instance.formErrors?.stop();
   _setFormErrorCollector(null);
   instance.frustration?.stop();
+  instance.errorCapture?.stop();
   instance.stopReplay?.();
   instance = null;
 }
@@ -1124,6 +1358,7 @@ export {
   collectEnvironment,
   createConsoleCollector,
   createDatadogReplayProvider,
+  createErrorCaptureCollector,
   createFormErrorCollector,
   createFrustrationCollector,
   createNetworkCollector,