nuxt-error-tracker 0.1.18 → 0.1.19

package/README.md

@@ -185,6 +185,9 @@ per environment (staging vs. production) without touching code.
 | `captureConsole`      | `boolean` | `true`      | Patch `console.error` to capture logged-but-not-thrown errors.     |
 | `captureInputs`       | `boolean` | `false`     | Record form input values as breadcrumbs (on change/blur). Sensitive fields masked. **Opt-in** — captures user-entered data. |
 | `flushDelay`          | `number`  | `2000`      | Debounce (ms) before a queued batch is sent.                       |
+| `minFlushInterval`    | `number`  | `0`         | Floor (ms) between consecutive flushes — throttles request rate during an error storm. `0` = off. |
+| `sampleRate`          | `number`  | `1`         | Fraction (0..1) of captured errors actually sent; the rest are dropped at capture. `0.3` ≈ keep 30%. Thins volume before the server rate limit. |
+| `maxPerMinute`        | `number`  | `0`         | Client-side cap on errors queued per rolling minute (fixed window); excess dropped. Mirrors the server per-project rate limit. `0` = unlimited. |
 | `maxPerSession`       | `number`  | `5`         | Max occurrences of the *same* error captured per session.          |
 | `maxBatch`            | `number`  | `20`        | Max errors per request (clamped to server hard cap of 20).         |
 | `maxBreadcrumbs`      | `number`  | `30`        | Breadcrumbs kept in the ring buffer / sent per error (clamped to 50). |

package/README.uk.md

@@ -185,6 +185,9 @@ export default defineNuxtConfig({
 | `captureConsole`      | `boolean` | `true`      | Патчить `console.error`, щоб ловити залоговані-але-не-кинуті помилки. |
 | `captureInputs`       | `boolean` | `false`     | Записує значення полів форм як breadcrumbs (на change/blur). Чутливі поля маскуються. **Opt-in** — захоплює введені користувачем дані. |
 | `flushDelay`          | `number`  | `2000`      | Debounce (мс) перед відправкою черги-батча.                        |
+| `minFlushInterval`    | `number`  | `0`         | Мін. пауза (мс) між флашами — throttle частоти запитів під час шторму помилок. `0` = вимкнено. |
+| `sampleRate`          | `number`  | `1`         | Частка (0..1) захоплених помилок, що реально шлються; решта дропається при capture. `0.3` ≈ 30%. Ріже обʼєм до серверного rate limit. |
+| `maxPerMinute`        | `number`  | `0`         | Клієнтський ліміт помилок у чергу за rolling-хвилину (fixed window); понад — дроп. Дзеркалить серверний per-project rate limit. `0` = без ліміту. |
 | `maxPerSession`       | `number`  | `5`         | Макс. кількість occurrences *тієї самої* помилки за сесію.          |
 | `maxBatch`            | `number`  | `20`        | Макс. помилок на запит (обрізається серверним лімітом 20).         |
 | `maxBreadcrumbs`      | `number`  | `30`        | Breadcrumbs у ring buffer / на помилку (обрізається до 50).        |

package/dist/module.d.mts

@@ -21,8 +21,34 @@ interface ModuleOptions {
      * masked. Default false — opt in, since it can capture user-entered data.
      */
     captureInputs?: boolean;
-    /** Debounce before a batch is flushed, in ms. Default 2000. */
+    /**
+     * How often batches leave the browser (debounce before a flush), in ms.
+     * A flush is scheduled `flushDelay` after the first queued error; more errors
+     * arriving in that window ride the same batch. Default 2000.
+     */
     flushDelay?: number;
+    /**
+     * Floor on the spacing between consecutive flushes, in ms. Unlike `flushDelay`
+     * (a per-batch debounce), this throttles the *rate* of network requests during
+     * a sustained error storm: a flush never fires sooner than `minFlushInterval`
+     * after the previous one. Default 0 (off — `flushDelay` alone governs cadence).
+     */
+    minFlushInterval?: number;
+    /**
+     * Client-side sampling: fraction (0..1) of captured errors to actually send;
+     * the rest are dropped before they ever queue. 1 = send everything (default),
+     * 0.3 = keep ~30%. Thins volume at the source so a high-traffic app doesn't
+     * flood the per-project server rate limit. Applied per occurrence, before the
+     * per-session dedup — so with a low rate even a rare error may be dropped.
+     */
+    sampleRate?: number;
+    /**
+     * Client-side hard cap on errors *queued* per rolling minute (fixed window);
+     * anything over is dropped. Mirrors the server's per-project rate limit so the
+     * browser stops emitting instead of shipping batches that get rejected.
+     * Default 0 (off — unlimited).
+     */
+    maxPerMinute?: number;
     /** Max occurrences of the same error captured per session. Default 5. */
     maxPerSession?: number;
     /** Max errors per flushed batch. Default 20 (server also caps at 20). */

package/dist/module.d.ts

@@ -21,8 +21,34 @@ interface ModuleOptions {
      * masked. Default false — opt in, since it can capture user-entered data.
      */
     captureInputs?: boolean;
-    /** Debounce before a batch is flushed, in ms. Default 2000. */
+    /**
+     * How often batches leave the browser (debounce before a flush), in ms.
+     * A flush is scheduled `flushDelay` after the first queued error; more errors
+     * arriving in that window ride the same batch. Default 2000.
+     */
     flushDelay?: number;
+    /**
+     * Floor on the spacing between consecutive flushes, in ms. Unlike `flushDelay`
+     * (a per-batch debounce), this throttles the *rate* of network requests during
+     * a sustained error storm: a flush never fires sooner than `minFlushInterval`
+     * after the previous one. Default 0 (off — `flushDelay` alone governs cadence).
+     */
+    minFlushInterval?: number;
+    /**
+     * Client-side sampling: fraction (0..1) of captured errors to actually send;
+     * the rest are dropped before they ever queue. 1 = send everything (default),
+     * 0.3 = keep ~30%. Thins volume at the source so a high-traffic app doesn't
+     * flood the per-project server rate limit. Applied per occurrence, before the
+     * per-session dedup — so with a low rate even a rare error may be dropped.
+     */
+    sampleRate?: number;
+    /**
+     * Client-side hard cap on errors *queued* per rolling minute (fixed window);
+     * anything over is dropped. Mirrors the server's per-project rate limit so the
+     * browser stops emitting instead of shipping batches that get rejected.
+     * Default 0 (off — unlimited).
+     */
+    maxPerMinute?: number;
     /** Max occurrences of the same error captured per session. Default 5. */
     maxPerSession?: number;
     /** Max errors per flushed batch. Default 20 (server also caps at 20). */

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-error-tracker",
   "configKey": "errorTracker",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "2.0.0"

package/dist/module.mjs

@@ -4,6 +4,14 @@ function posInt(value, fallback) {
   const n = Number(value);
   return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
 }
+function clamp01(value, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) ? Math.min(Math.max(n, 0), 1) : fallback;
+}
+function nonNegInt(value, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) && n >= 0 ? Math.floor(n) : fallback;
+}
 const module = defineNuxtModule({
   meta: {
     name: "nuxt-error-tracker",
@@ -19,6 +27,9 @@ const module = defineNuxtModule({
     captureConsole: true,
     captureInputs: false,
     flushDelay: 2e3,
+    minFlushInterval: 0,
+    sampleRate: 1,
+    maxPerMinute: 0,
     maxPerSession: 5,
     maxBatch: 20,
     maxBreadcrumbs: 30
@@ -35,6 +46,9 @@ const module = defineNuxtModule({
       captureConsole: options.captureConsole !== false,
       captureInputs: options.captureInputs === true,
       flushDelay: posInt(options.flushDelay, 2e3),
+      minFlushInterval: nonNegInt(options.minFlushInterval, 0),
+      sampleRate: clamp01(options.sampleRate, 1),
+      maxPerMinute: nonNegInt(options.maxPerMinute, 0),
       maxPerSession: posInt(options.maxPerSession, 5),
       // Server hard-caps batches at 20 — never emit larger, even if misconfigured.
       maxBatch: Math.min(posInt(options.maxBatch, 20), 20),

package/dist/runtime/plugin.client.js

@@ -11,12 +11,29 @@ export default defineNuxtPlugin((nuxtApp) => {
   if (!config || !config.endpoint || !config.publicKey) return;
   const route = useRoute();
   const FLUSH_DELAY = config.flushDelay ?? 2e3;
+  const MIN_FLUSH_INTERVAL = config.minFlushInterval ?? 0;
+  const SAMPLE_RATE = config.sampleRate ?? 1;
+  const MAX_PER_MINUTE = config.maxPerMinute ?? 0;
   const MAX_PER_SESSION = config.maxPerSession ?? 5;
   const MAX_BATCH = config.maxBatch ?? 20;
   const MAX_CRUMBS = config.maxBreadcrumbs ?? 30;
   const queue = [];
   const sessionCounts = /* @__PURE__ */ new Map();
   let flushTimer = null;
+  let lastFlushAt = 0;
+  let rateWindowStart = 0;
+  let rateWindowCount = 0;
+  function rateLimited() {
+    if (!MAX_PER_MINUTE) return false;
+    const now = Date.now();
+    if (now - rateWindowStart >= 6e4) {
+      rateWindowStart = now;
+      rateWindowCount = 0;
+    }
+    if (rateWindowCount >= MAX_PER_MINUTE) return true;
+    rateWindowCount++;
+    return false;
+  }
   const crumbs = [];
   function addCrumb(c) {
     crumbs.push({ ...c, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
@@ -43,6 +60,7 @@ export default defineNuxtPlugin((nuxtApp) => {
   const MAX_QUEUE = 200;
   function flush(useBeacon = false) {
     if (!queue.length) return;
+    lastFlushAt = Date.now();
     try {
       const batch = queue.splice(0, MAX_BATCH);
       const body = {
@@ -78,18 +96,22 @@ export default defineNuxtPlugin((nuxtApp) => {
   }
   function scheduleFlush() {
     if (flushTimer) return;
+    const sinceLast = Date.now() - lastFlushAt;
+    const wait = Math.max(FLUSH_DELAY, MIN_FLUSH_INTERVAL - sinceLast);
     flushTimer = setTimeout(() => {
       flushTimer = null;
       flush();
-    }, FLUSH_DELAY);
+    }, wait);
   }
   function capture(err, source, level = "error") {
     try {
       const error = err instanceof Error ? err : new Error(String(err));
       if (error.message === "Script error.") return;
+      if (SAMPLE_RATE < 1 && Math.random() >= SAMPLE_RATE) return;
       const key = sessionKey(error.message, error.stack ?? "");
       const count = sessionCounts.get(key) ?? 0;
       if (count >= MAX_PER_SESSION) return;
+      if (rateLimited()) return;
       sessionCounts.set(key, count + 1);
       queue.push({
         message: error.message.slice(0, 1e3),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-error-tracker",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "type": "module",
   "license": "PolyForm-Shield-1.0.0",
   "exports": {