@reproapp/node-sdk 0.0.41 → 0.0.42

package/dist/index.js

@@ -841,7 +841,7 @@ function emitRequestCaptureStart(cfg, sessionId, actionId, scope, openedAtMs) {
                 },
                 t: openedAt,
             }],
-    }, { priority: 'high' });
+    }, { priority: 'critical' });
 }
 const als = new async_hooks_1.AsyncLocalStorage();
 const getCtx = () => als.getStore() || {};
@@ -985,7 +985,7 @@ const SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = (() => {
 const SDK_BACKGROUND_MAX_DEFER_MS = (() => {
     const raw = String(process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS ?? '').trim().toLowerCase();
     if (!raw) {
-        return Number.POSITIVE_INFINITY;
+        return 30000;
     }
     if (raw === 'off' || raw === 'never' || raw === 'infinite' || raw === 'infinity' || raw === '-1') {
         return Number.POSITIVE_INFINITY;

package/dist/ingest/client.d.ts

@@ -1,6 +1,6 @@
 import type { IngestClientConfig, LegacyEntry } from './types';
 export type EnqueueIngestOptions = {
-    priority?: 'normal' | 'high';
+    priority?: 'normal' | 'high' | 'critical';
 };
 export declare const configureIngestQueueDrain: (options: {
     shouldDefer?: (() => boolean) | null;

package/dist/ingest/client.js

@@ -14,6 +14,22 @@ const DEFAULT_QUEUE_MAX_ITEMS = (() => {
 const DEFAULT_QUEUE_MAX_ATTEMPTS = 5;
 const DEFAULT_QUEUE_BACKOFF_MAX_MS = 4000;
 const DEFAULT_DEFER_DRAIN_MS = 25;
+const DEFAULT_BATCH_MAX_ENTRIES = (() => {
+    const env = Number(typeof process !== 'undefined' ? process?.env?.REPRO_INGEST_BATCH_MAX_ENTRIES : undefined);
+    if (Number.isFinite(env) && env > 0) {
+        return Math.trunc(env);
+    }
+    return 100;
+})();
+const DEFAULT_BATCH_MAX_SERIALIZED_BYTES = (() => {
+    const env = Number(typeof process !== 'undefined'
+        ? process?.env?.REPRO_INGEST_BATCH_MAX_SERIALIZED_BYTES
+        : undefined);
+    if (Number.isFinite(env) && env > 0) {
+        return Math.trunc(env);
+    }
+    return 1024 * 1024;
+})();
 const DEFAULT_INGEST_REQUEST_TIMEOUT_MS = (() => {
     const env = Number(typeof process !== 'undefined' ? process?.env?.REPRO_INGEST_REQUEST_TIMEOUT_MS : undefined);
     if (Number.isFinite(env) && env >= 0) {
@@ -22,9 +38,13 @@ const DEFAULT_INGEST_REQUEST_TIMEOUT_MS = (() => {
     return 120000;
 })();
 const ingestQueue = [];
+const criticalIngestQueue = [];
 let drainTimer = null;
+let criticalDrainTimer = null;
 let draining = false;
+let criticalDraining = false;
 let backoffMs = 0;
+let criticalBackoffMs = 0;
 let shouldDeferDrain = null;
 let deferDrainMs = DEFAULT_DEFER_DRAIN_MS;
 const configureIngestQueueDrain = (options) => {
@@ -35,12 +55,15 @@ const configureIngestQueueDrain = (options) => {
 };
 exports.configureIngestQueueDrain = configureIngestQueueDrain;
 const kickIngestQueueDrain = () => {
+    if (criticalIngestQueue.length > 0 && !criticalDrainTimer) {
+        scheduleCriticalDrain();
+    }
     if (ingestQueue.length > 0 && !drainTimer) {
         scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
     }
 };
 exports.kickIngestQueueDrain = kickIngestQueueDrain;
-const isCriticalIngestEntry = (entry) => (entry.requestCaptureStart !== undefined ||
+const isHighPriorityIngestEntry = (entry) => (entry.requestCaptureStart !== undefined ||
     entry.requestCaptureManifest !== undefined ||
     entry.sessionCaptureManifest !== undefined ||
     entry.request !== undefined ||
@@ -48,10 +71,72 @@ const isCriticalIngestEntry = (entry) => (entry.requestCaptureStart !== undefine
     entry.trace !== undefined ||
     entry.email !== undefined);
 const resolveBatchPriority = (entries, options) => {
-    if (options.priority === 'high') {
-        return 'high';
+    if (options.priority === 'high' || options.priority === 'critical') {
+        return options.priority;
+    }
+    return entries.some(isHighPriorityIngestEntry) ? 'high' : 'normal';
+};
+const sameIngestDestination = (left, right) => (left.sessionId === right.sessionId &&
+    left.priority === right.priority &&
+    left.config.appId === right.config.appId &&
+    left.config.tenantId === right.config.tenantId &&
+    left.config.appSecret === right.config.appSecret &&
+    left.config.appName === right.config.appName &&
+    left.config.serviceName === right.config.serviceName &&
+    left.config.ingestBase === right.config.ingestBase &&
+    left.config.ingestPath === right.config.ingestPath &&
+    left.config.actorId === right.config.actorId &&
+    left.config.actorType === right.config.actorType &&
+    JSON.stringify(left.config.actorLabels ?? null) ===
+        JSON.stringify(right.config.actorLabels ?? null) &&
+    left.config.source === right.config.source &&
+    left.config.schemaVersion === right.config.schemaVersion);
+const serializedBytes = (value) => {
+    try {
+        return Buffer.byteLength(JSON.stringify(value), 'utf8');
+    }
+    catch {
+        return DEFAULT_BATCH_MAX_SERIALIZED_BYTES + 1;
     }
-    return entries.some(isCriticalIngestEntry) ? 'high' : 'normal';
+};
+const selectSendBatch = (queue) => {
+    const first = queue[0];
+    if (!first) {
+        return null;
+    }
+    if (first.priority === 'normal') {
+        return { batch: first, queueItems: 1 };
+    }
+    const entries = first.entries.slice();
+    let bytes = serializedBytes(entries);
+    let queueItems = 1;
+    for (let index = 1; index < queue.length && entries.length < DEFAULT_BATCH_MAX_ENTRIES; index += 1) {
+        const candidate = queue[index];
+        if (!candidate || !sameIngestDestination(first, candidate)) {
+            break;
+        }
+        if (entries.length + candidate.entries.length > DEFAULT_BATCH_MAX_ENTRIES) {
+            break;
+        }
+        const candidateBytes = serializedBytes(candidate.entries);
+        if (bytes + candidateBytes > DEFAULT_BATCH_MAX_SERIALIZED_BYTES) {
+            break;
+        }
+        entries.push(...candidate.entries);
+        bytes += candidateBytes;
+        queueItems += 1;
+    }
+    if (queueItems === 1) {
+        return { batch: first, queueItems };
+    }
+    return {
+        batch: {
+            ...first,
+            entries,
+            attempts: Math.max(...queue.slice(0, queueItems).map((item) => item.attempts)),
+        },
+        queueItems,
+    };
 };
 const resolveIngestUrl = (config) => {
     const envBase = typeof process !== 'undefined' ? process?.env?.REPRO_INGEST_BASE : undefined;
@@ -144,6 +229,51 @@ const scheduleDrain = (delayMs = 0) => {
     }
     catch { }
 };
+const scheduleCriticalDrain = (delayMs = 0) => {
+    if (criticalDrainTimer) {
+        return;
+    }
+    criticalDrainTimer = setTimeout(() => {
+        criticalDrainTimer = null;
+        void drainCriticalIngestQueue();
+    }, Math.max(0, delayMs));
+    try {
+        criticalDrainTimer.unref?.();
+    }
+    catch { }
+};
+const drainCriticalIngestQueue = async () => {
+    if (criticalDraining) {
+        return;
+    }
+    criticalDraining = true;
+    try {
+        while (criticalIngestQueue.length > 0) {
+            const selected = selectSendBatch(criticalIngestQueue);
+            if (!selected) {
+                return;
+            }
+            const ok = await sendIngestEntries(selected.batch.config, selected.batch.sessionId, selected.batch.entries);
+            if (ok) {
+                criticalIngestQueue.splice(0, selected.queueItems);
+                criticalBackoffMs = 0;
+                continue;
+            }
+            for (let index = 0; index < selected.queueItems; index += 1) {
+                criticalIngestQueue[index].attempts += 1;
+            }
+            criticalBackoffMs = Math.min(DEFAULT_QUEUE_BACKOFF_MAX_MS, criticalBackoffMs ? criticalBackoffMs * 2 : 250);
+            scheduleCriticalDrain(criticalBackoffMs);
+            return;
+        }
+    }
+    finally {
+        criticalDraining = false;
+        if (criticalIngestQueue.length > 0 && !criticalDrainTimer) {
+            scheduleCriticalDrain(criticalBackoffMs);
+        }
+    }
+};
 const drainIngestQueue = async () => {
     if (draining) {
         return;
@@ -159,15 +289,22 @@ const drainIngestQueue = async () => {
                 scheduleDrain(deferDrainMs);
                 return;
             }
-            const batch = ingestQueue[0];
+            const selected = selectSendBatch(ingestQueue);
+            if (!selected) {
+                return;
+            }
+            const batch = selected.batch;
             const ok = await sendIngestEntries(batch.config, batch.sessionId, batch.entries);
             if (ok) {
-                ingestQueue.shift();
+                ingestQueue.splice(0, selected.queueItems);
                 backoffMs = 0;
                 continue;
             }
-            batch.attempts += 1;
-            if (batch.attempts >= DEFAULT_QUEUE_MAX_ATTEMPTS && batch.priority !== 'high') {
+            for (let index = 0; index < selected.queueItems; index += 1) {
+                ingestQueue[index].attempts += 1;
+            }
+            if (ingestQueue[0].attempts >= DEFAULT_QUEUE_MAX_ATTEMPTS &&
+                ingestQueue[0].priority === 'normal') {
                 ingestQueue.shift();
                 backoffMs = 0;
                 continue;
@@ -196,6 +333,11 @@ const enqueueIngestEntries = (config, sessionId, entries, options = {}) => {
         attempts: 0,
         priority,
     };
+    if (priority === 'critical') {
+        criticalIngestQueue.push(batch);
+        scheduleCriticalDrain();
+        return true;
+    }
     if (priority === 'high') {
         const firstNormalIndex = ingestQueue.findIndex((queued) => queued.priority !== 'high');
         if (firstNormalIndex === -1) {
@@ -228,10 +370,15 @@ const enqueueIngestEntries = (config, sessionId, entries, options = {}) => {
 };
 exports.enqueueIngestEntries = enqueueIngestEntries;
 const flushIngestQueue = async () => {
+    if (criticalDrainTimer) {
+        clearTimeout(criticalDrainTimer);
+        criticalDrainTimer = null;
+    }
     if (drainTimer) {
         clearTimeout(drainTimer);
         drainTimer = null;
     }
+    await drainCriticalIngestQueue();
     await drainIngestQueue();
 };
 exports.flushIngestQueue = flushIngestQueue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.41",
+  "version": "0.0.42",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,7 @@
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
     "prepublishOnly": "npm run build",
-    "test": "npm run build && node test/unawaited.test.js && node test/integration-unawaited.js && node test/request-flush-timing.test.js && node test/request-capture-background.test.js && node test/init-auto-http-server.test.js && node test/backend-live-mode.test.js && node test/client-performance-regression.test.js && node test/request-manifest-priority.test.js && node test/runtime-no-double-invoke.test.js && node test/express-trace-http-args.test.js && node test/trace-batch-size.test.js && node test/sdk-background-priority.test.js && node test/ingest-queue-retention.test.js && node test/ingest-high-priority-retention.test.js && node test/ingest-critical-retention.test.js && node test/ingest-critical-retry-retention.test.js && node test/ingest-timeout.test.js && node -r ./tracer/register test/promise-map.test.js && node test/disable-subtree.test.js && node test/circular-capture.test.js && node test/wrap-plugin-arrow-args.test.js && node test/wrap-plugin-super-call.test.js && node test/function-arg-identity.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js && node test/amqplib-integration.test.js && node test/mongodb-integration.test.js && node test/mongodb-esm-import-hook.test.js && node test/mongodb-suppression-cleanup.test.js && node test/postgresql-integration.test.js",
+    "test": "npm run build && node test/unawaited.test.js && node test/integration-unawaited.js && node test/request-flush-timing.test.js && node test/request-capture-background.test.js && node test/init-auto-http-server.test.js && node test/backend-live-mode.test.js && node test/client-performance-regression.test.js && node test/request-manifest-priority.test.js && node test/runtime-no-double-invoke.test.js && node test/express-trace-http-args.test.js && node test/trace-batch-size.test.js && node test/sdk-background-priority.test.js && node test/ingest-queue-retention.test.js && node test/ingest-high-priority-retention.test.js && node test/ingest-critical-retention.test.js && node test/ingest-critical-retry-retention.test.js && node test/ingest-batching.test.js && node test/ingest-timeout.test.js && node -r ./tracer/register test/promise-map.test.js && node test/disable-subtree.test.js && node test/circular-capture.test.js && node test/wrap-plugin-arrow-args.test.js && node test/wrap-plugin-super-call.test.js && node test/function-arg-identity.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js && node test/amqplib-integration.test.js && node test/mongodb-integration.test.js && node test/mongodb-esm-import-hook.test.js && node test/mongodb-suppression-cleanup.test.js && node test/postgresql-integration.test.js",
     "test:containers": "npm run build && node test/runtime-no-double-invoke.testcontainers.test.js && node test/wrap-plugin-super-call.testcontainers.test.js && node test/function-arg-identity.testcontainers.test.js && node test/mongodb-mongoose-native-suppression.testcontainers.test.js && node test/postgresql-integrations.testcontainers.test.js"
   },
   "peerDependencies": {

package/src/index.ts

@@ -1249,7 +1249,7 @@ function emitRequestCaptureStart(
             },
             t: openedAt,
         }],
-    }, { priority: 'high' });
+    }, { priority: 'critical' });
 }
 
 const als = new AsyncLocalStorage<Ctx>();
@@ -1393,7 +1393,7 @@ const SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = (() => {
 const SDK_BACKGROUND_MAX_DEFER_MS = (() => {
     const raw = String(process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS ?? '').trim().toLowerCase();
     if (!raw) {
-        return Number.POSITIVE_INFINITY;
+        return 30000;
     }
     if (raw === 'off' || raw === 'never' || raw === 'infinite' || raw === 'infinity' || raw === '-1') {
         return Number.POSITIVE_INFINITY;

package/src/ingest/client.ts

@@ -13,6 +13,24 @@ const DEFAULT_QUEUE_MAX_ITEMS = (() => {
 const DEFAULT_QUEUE_MAX_ATTEMPTS = 5;
 const DEFAULT_QUEUE_BACKOFF_MAX_MS = 4000;
 const DEFAULT_DEFER_DRAIN_MS = 25;
+const DEFAULT_BATCH_MAX_ENTRIES = (() => {
+    const env = Number(typeof process !== 'undefined' ? (process as any)?.env?.REPRO_INGEST_BATCH_MAX_ENTRIES : undefined);
+    if (Number.isFinite(env) && env > 0) {
+        return Math.trunc(env);
+    }
+    return 100;
+})();
+const DEFAULT_BATCH_MAX_SERIALIZED_BYTES = (() => {
+    const env = Number(
+        typeof process !== 'undefined'
+            ? (process as any)?.env?.REPRO_INGEST_BATCH_MAX_SERIALIZED_BYTES
+            : undefined,
+    );
+    if (Number.isFinite(env) && env > 0) {
+        return Math.trunc(env);
+    }
+    return 1024 * 1024;
+})();
 const DEFAULT_INGEST_REQUEST_TIMEOUT_MS = (() => {
     const env = Number(typeof process !== 'undefined' ? (process as any)?.env?.REPRO_INGEST_REQUEST_TIMEOUT_MS : undefined);
     if (Number.isFinite(env) && env >= 0) {
@@ -26,17 +44,21 @@ type QueuedIngestBatch = {
     sessionId: string;
     entries: LegacyEntry[];
     attempts: number;
-    priority: 'normal' | 'high';
+    priority: 'normal' | 'high' | 'critical';
 };
 
 export type EnqueueIngestOptions = {
-    priority?: 'normal' | 'high';
+    priority?: 'normal' | 'high' | 'critical';
 };
 
 const ingestQueue: QueuedIngestBatch[] = [];
+const criticalIngestQueue: QueuedIngestBatch[] = [];
 let drainTimer: ReturnType<typeof setTimeout> | null = null;
+let criticalDrainTimer: ReturnType<typeof setTimeout> | null = null;
 let draining = false;
+let criticalDraining = false;
 let backoffMs = 0;
+let criticalBackoffMs = 0;
 let shouldDeferDrain: (() => boolean) | null = null;
 let deferDrainMs = DEFAULT_DEFER_DRAIN_MS;
 
@@ -51,12 +73,15 @@ export const configureIngestQueueDrain = (options: {
 };
 
 export const kickIngestQueueDrain = (): void => {
+    if (criticalIngestQueue.length > 0 && !criticalDrainTimer) {
+        scheduleCriticalDrain();
+    }
     if (ingestQueue.length > 0 && !drainTimer) {
         scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
     }
 };
 
-const isCriticalIngestEntry = (entry: LegacyEntry): boolean => (
+const isHighPriorityIngestEntry = (entry: LegacyEntry): boolean => (
     entry.requestCaptureStart !== undefined ||
     entry.requestCaptureManifest !== undefined ||
     entry.sessionCaptureManifest !== undefined ||
@@ -70,10 +95,89 @@ const resolveBatchPriority = (
     entries: LegacyEntry[],
     options: EnqueueIngestOptions,
 ): QueuedIngestBatch['priority'] => {
-    if (options.priority === 'high') {
-        return 'high';
+    if (options.priority === 'high' || options.priority === 'critical') {
+        return options.priority;
+    }
+    return entries.some(isHighPriorityIngestEntry) ? 'high' : 'normal';
+};
+
+const sameIngestDestination = (
+    left: QueuedIngestBatch,
+    right: QueuedIngestBatch,
+): boolean => (
+    left.sessionId === right.sessionId &&
+    left.priority === right.priority &&
+    left.config.appId === right.config.appId &&
+    left.config.tenantId === right.config.tenantId &&
+    left.config.appSecret === right.config.appSecret &&
+    left.config.appName === right.config.appName &&
+    left.config.serviceName === right.config.serviceName &&
+    left.config.ingestBase === right.config.ingestBase &&
+    left.config.ingestPath === right.config.ingestPath &&
+    left.config.actorId === right.config.actorId &&
+    left.config.actorType === right.config.actorType &&
+    JSON.stringify(left.config.actorLabels ?? null) ===
+        JSON.stringify(right.config.actorLabels ?? null) &&
+    left.config.source === right.config.source &&
+    left.config.schemaVersion === right.config.schemaVersion
+);
+
+const serializedBytes = (value: unknown): number => {
+    try {
+        return Buffer.byteLength(JSON.stringify(value), 'utf8');
+    } catch {
+        return DEFAULT_BATCH_MAX_SERIALIZED_BYTES + 1;
     }
-    return entries.some(isCriticalIngestEntry) ? 'high' : 'normal';
+};
+
+const selectSendBatch = (
+    queue: QueuedIngestBatch[],
+): { batch: QueuedIngestBatch; queueItems: number } | null => {
+    const first = queue[0];
+    if (!first) {
+        return null;
+    }
+    if (first.priority === 'normal') {
+        return { batch: first, queueItems: 1 };
+    }
+
+    const entries = first.entries.slice();
+    let bytes = serializedBytes(entries);
+    let queueItems = 1;
+    for (
+        let index = 1;
+        index < queue.length && entries.length < DEFAULT_BATCH_MAX_ENTRIES;
+        index += 1
+    ) {
+        const candidate = queue[index];
+        if (!candidate || !sameIngestDestination(first, candidate)) {
+            break;
+        }
+        if (entries.length + candidate.entries.length > DEFAULT_BATCH_MAX_ENTRIES) {
+            break;
+        }
+        const candidateBytes = serializedBytes(candidate.entries);
+        if (bytes + candidateBytes > DEFAULT_BATCH_MAX_SERIALIZED_BYTES) {
+            break;
+        }
+        entries.push(...candidate.entries);
+        bytes += candidateBytes;
+        queueItems += 1;
+    }
+
+    if (queueItems === 1) {
+        return { batch: first, queueItems };
+    }
+    return {
+        batch: {
+            ...first,
+            entries,
+            attempts: Math.max(
+                ...queue.slice(0, queueItems).map((item) => item.attempts),
+            ),
+        },
+        queueItems,
+    };
 };
 
 const resolveIngestUrl = (config: IngestClientConfig): string => {
@@ -181,6 +285,59 @@ const scheduleDrain = (delayMs = 0): void => {
     } catch {}
 };
 
+const scheduleCriticalDrain = (delayMs = 0): void => {
+    if (criticalDrainTimer) {
+        return;
+    }
+    criticalDrainTimer = setTimeout(() => {
+        criticalDrainTimer = null;
+        void drainCriticalIngestQueue();
+    }, Math.max(0, delayMs));
+    try {
+        (criticalDrainTimer as any).unref?.();
+    } catch {}
+};
+
+const drainCriticalIngestQueue = async (): Promise<void> => {
+    if (criticalDraining) {
+        return;
+    }
+    criticalDraining = true;
+    try {
+        while (criticalIngestQueue.length > 0) {
+            const selected = selectSendBatch(criticalIngestQueue);
+            if (!selected) {
+                return;
+            }
+            const ok = await sendIngestEntries(
+                selected.batch.config,
+                selected.batch.sessionId,
+                selected.batch.entries,
+            );
+            if (ok) {
+                criticalIngestQueue.splice(0, selected.queueItems);
+                criticalBackoffMs = 0;
+                continue;
+            }
+
+            for (let index = 0; index < selected.queueItems; index += 1) {
+                criticalIngestQueue[index].attempts += 1;
+            }
+            criticalBackoffMs = Math.min(
+                DEFAULT_QUEUE_BACKOFF_MAX_MS,
+                criticalBackoffMs ? criticalBackoffMs * 2 : 250,
+            );
+            scheduleCriticalDrain(criticalBackoffMs);
+            return;
+        }
+    } finally {
+        criticalDraining = false;
+        if (criticalIngestQueue.length > 0 && !criticalDrainTimer) {
+            scheduleCriticalDrain(criticalBackoffMs);
+        }
+    }
+};
+
 const drainIngestQueue = async (): Promise<void> => {
     if (draining) {
         return;
@@ -196,16 +353,25 @@ const drainIngestQueue = async (): Promise<void> => {
                 scheduleDrain(deferDrainMs);
                 return;
             }
-            const batch = ingestQueue[0];
+            const selected = selectSendBatch(ingestQueue);
+            if (!selected) {
+                return;
+            }
+            const batch = selected.batch;
             const ok = await sendIngestEntries(batch.config, batch.sessionId, batch.entries);
             if (ok) {
-                ingestQueue.shift();
+                ingestQueue.splice(0, selected.queueItems);
                 backoffMs = 0;
                 continue;
             }
 
-            batch.attempts += 1;
-            if (batch.attempts >= DEFAULT_QUEUE_MAX_ATTEMPTS && batch.priority !== 'high') {
+            for (let index = 0; index < selected.queueItems; index += 1) {
+                ingestQueue[index].attempts += 1;
+            }
+            if (
+                ingestQueue[0].attempts >= DEFAULT_QUEUE_MAX_ATTEMPTS &&
+                ingestQueue[0].priority === 'normal'
+            ) {
                 ingestQueue.shift();
                 backoffMs = 0;
                 continue;
@@ -243,6 +409,11 @@ export const enqueueIngestEntries = (
         attempts: 0,
         priority,
     };
+    if (priority === 'critical') {
+        criticalIngestQueue.push(batch);
+        scheduleCriticalDrain();
+        return true;
+    }
     if (priority === 'high') {
         const firstNormalIndex = ingestQueue.findIndex((queued) => queued.priority !== 'high');
         if (firstNormalIndex === -1) {
@@ -273,10 +444,15 @@ export const enqueueIngestEntries = (
 };
 
 export const flushIngestQueue = async (): Promise<void> => {
+    if (criticalDrainTimer) {
+        clearTimeout(criticalDrainTimer);
+        criticalDrainTimer = null;
+    }
     if (drainTimer) {
         clearTimeout(drainTimer);
         drainTimer = null;
     }
+    await drainCriticalIngestQueue();
     await drainIngestQueue();
 };
 

package/test/client-performance-regression.test.js

@@ -119,6 +119,11 @@ async function main() {
         });
 
         await sleep(2200);
+        assert.equal(
+            eventsOf(capturedBodies, 'request_capture_start').length,
+            1,
+            `request-open fence was deferred with background work: ${JSON.stringify(capturedBodies)}`,
+        );
         assert.equal(
             eventsOf(capturedBodies, 'backend_request').length,
             0,

package/test/ingest-batching.test.js

@@ -0,0 +1,67 @@
+process.env.REPRO_INGEST_BATCH_MAX_ENTRIES = '100';
+process.env.REPRO_INGEST_BATCH_MAX_SERIALIZED_BYTES = String(1024 * 1024);
+
+const assert = require('node:assert/strict');
+
+const originalFetch = global.fetch;
+const capturedBodies = [];
+
+global.fetch = async (_url, init = {}) => {
+    capturedBodies.push(JSON.parse(String(init.body || '{}')));
+    return {
+        ok: true,
+        status: 202,
+        json: async () => ({ ok: true }),
+        text: async () => '{"ok":true}',
+    };
+};
+
+const { enqueueIngestEntries, flushIngestQueue } = require('../dist/ingest/client');
+
+async function main() {
+    const cfg = {
+        tenantId: 'TENANT_test',
+        appId: 'APP_test',
+        appSecret: 'secret',
+        serviceName: 'batching-test',
+        ingestBase: 'http://127.0.0.1:65535',
+    };
+    const sessionId = 'S_ingest_batching';
+
+    for (let index = 0; index < 209; index += 1) {
+        enqueueIngestEntries(cfg, sessionId, [{
+            actionId: 'A_ingest_batching',
+            requestRid: 'R_ingest_batching',
+            db: [{
+                collection: 'subjects',
+                op: 'findOne',
+                query: { index },
+            }],
+            t: Date.now() + index,
+        }], { priority: 'high' });
+    }
+
+    await flushIngestQueue();
+
+    const events = capturedBodies.flatMap((body) =>
+        Array.isArray(body?.events) ? body.events : [],
+    );
+    assert.equal(events.length, 209);
+    assert(events.every((event) => event.event_type === 'db_change'));
+    assert.equal(
+        capturedBodies.length,
+        3,
+        `209 small evidence entries should use three bounded requests, got ${capturedBodies.length}`,
+    );
+
+    console.log('ingest batching OK');
+}
+
+main()
+    .catch((error) => {
+        console.error(error);
+        process.exitCode = 1;
+    })
+    .finally(() => {
+        global.fetch = originalFetch;
+    });

package/test/request-capture-background.test.js

@@ -107,14 +107,19 @@ async function main() {
         });
 
         await sleep(100);
+        assert.equal(
+            countEvents(capturedBodies, 'request_capture_start'),
+            1,
+            `request-open fence must bypass client workload deferral: ${JSON.stringify(capturedBodies)}`,
+        );
         assert.equal(
             countEvents(capturedBodies, 'backend_request'),
             0,
             `request capture should defer while another client request is active: ${JSON.stringify(capturedBodies)}`,
         );
 
-        held.res.emit('finish');
         await waitFor(() => countEvents(capturedBodies, 'backend_request') === 1);
+        held.res.emit('finish');
         await flushIngestQueue();
 
         assert.equal(countEvents(capturedBodies, 'backend_request'), 1, JSON.stringify(capturedBodies));