@reproapp/node-sdk 0.0.50 → 0.0.51

package/dist/index.js

@@ -1121,22 +1121,20 @@ function hasActiveClientRequests() {
 function noteClientActivity(now = Date.now()) {
     lastClientActivityAt = now;
 }
-function getSdkBackgroundDelayMs(now = Date.now()) {
+function getSdkBackgroundDelayMs(now = Date.now(), ingestEnqueuedAt) {
+    // Bound deferral by work age, not just by a continuously active request.
+    // Short non-overlapping requests reset oldestActiveClientRequestAt forever.
+    const oldestWorkAt = Math.min(sdkBackgroundHighQueue[0]?.enqueuedAt ?? Infinity, sdkBackgroundQueue[0]?.enqueuedAt ?? Infinity, ingestEnqueuedAt ?? Infinity, oldestActiveClientRequestAt ?? Infinity);
+    const remainingDeferMs = Number.isFinite(oldestWorkAt) && Number.isFinite(SDK_BACKGROUND_MAX_DEFER_MS)
+        ? Math.max(0, oldestWorkAt + SDK_BACKGROUND_MAX_DEFER_MS - now)
+        : Infinity;
     if (hasActiveClientRequests()) {
-        if (oldestActiveClientRequestAt !== null &&
-            Number.isFinite(SDK_BACKGROUND_MAX_DEFER_MS) &&
-            SDK_BACKGROUND_MAX_DEFER_MS >= 0) {
-            const activeForMs = now - oldestActiveClientRequestAt;
-            if (activeForMs >= SDK_BACKGROUND_MAX_DEFER_MS)
-                return 0;
-            return Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, Math.max(0, SDK_BACKGROUND_MAX_DEFER_MS - activeForMs));
-        }
-        return SDK_BACKGROUND_IDLE_DELAY_MS;
+        return Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, remainingDeferMs);
     }
     const sinceLastActivity = now - lastClientActivityAt;
     const idleDelayRemaining = Math.max(0, SDK_BACKGROUND_IDLE_DELAY_MS - sinceLastActivity);
     const quietWindowRemaining = Math.max(0, sdkBackgroundQuietUntil - now);
-    return Math.max(idleDelayRemaining, quietWindowRemaining);
+    return Math.min(Math.max(idleDelayRemaining, quietWindowRemaining), remainingDeferMs);
 }
 function shouldDeferSdkBackgroundWork(now = Date.now()) {
     return getSdkBackgroundDelayMs(now) > 0;
@@ -1372,13 +1370,8 @@ function beginClientRequest() {
         oldestActiveClientRequestAt = now;
     }
     activeClientRequestCount += 1;
-    if (sdkBackgroundTimer) {
-        try {
-            clearTimeout(sdkBackgroundTimer);
-        }
-        catch { }
-        sdkBackgroundTimer = null;
-    }
+    // The scheduled drain rechecks activity; cancelling it here loses the
+    // queued work's deadline under sustained traffic.
 }
 function endClientRequest() {
     activeClientRequestCount = Math.max(0, activeClientRequestCount - 1);
@@ -1397,15 +1390,18 @@ function endClientRequest() {
     }
 }
 function scheduleSdkBackgroundWork(work, options = {}) {
+    const item = { work, enqueuedAt: Date.now() };
     if (options.priority === 'high') {
-        sdkBackgroundHighQueue.push(work);
+        sdkBackgroundHighQueue.push(item);
     }
     else {
-        sdkBackgroundQueue.push(work);
+        sdkBackgroundQueue.push(item);
     }
     scheduleSdkBackgroundDrain();
 }
 function scheduleSdkBackgroundDrain(delayMs = 0) {
+    if (!sdkBackgroundHighQueue.length && !sdkBackgroundQueue.length)
+        return;
     if (sdkBackgroundTimer)
         return;
     const nextDelay = Math.max(delayMs, getSdkBackgroundDelayMs());
@@ -1441,12 +1437,12 @@ async function drainSdkBackgroundQueue() {
                 scheduleSdkBackgroundDrain();
                 return;
             }
-            const work = sdkBackgroundHighQueue.shift() ?? sdkBackgroundQueue.shift();
-            if (!work)
+            const item = sdkBackgroundHighQueue.shift() ?? sdkBackgroundQueue.shift();
+            if (!item)
                 continue;
             try {
                 await drainQueuedIngestBeforeBackgroundWork();
-                await runSdkBackgroundWork(work);
+                await runSdkBackgroundWork(item.work);
             }
             catch {
                 // never break user code
@@ -1464,8 +1460,8 @@ async function drainSdkBackgroundQueue() {
     }
 }
 (0, client_1.configureIngestQueueDrain)({
-    shouldDefer: shouldDeferSdkBackgroundWork,
-    deferMs: SDK_BACKGROUND_IDLE_DELAY_MS,
+    shouldDefer: (enqueuedAt) => getSdkBackgroundDelayMs(Date.now(), enqueuedAt) > 0,
+    deferMs: Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, SDK_BACKGROUND_MAX_DEFER_MS),
 });
 // Track in-flight requests per session so we can delay flushing until a session is drained.
 const sessionInFlight = new Map();

package/dist/ingest/client.d.ts

@@ -3,8 +3,8 @@ export type EnqueueIngestOptions = {
     priority?: 'normal' | 'high' | 'critical';
 };
 export declare const configureIngestQueueDrain: (options: {
-    shouldDefer?: (() => boolean) | null;
-    deferMs?: number;
+    shouldDefer?: ((enqueuedAt?: number) => boolean) | null | undefined;
+    deferMs?: number | undefined;
 }) => void;
 export declare const kickIngestQueueDrain: () => void;
 export declare const postIngestEntries: (config: IngestClientConfig, sessionId: string, entries: LegacyEntry[]) => Promise<void>;

package/dist/ingest/client.js

@@ -61,7 +61,7 @@ const kickIngestQueueDrain = () => {
         scheduleCriticalDrain();
     }
     if (ingestQueue.length > 0 && !drainTimer) {
-        scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
+        scheduleDrain(shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt) ? deferDrainMs : 0);
     }
 };
 exports.kickIngestQueueDrain = kickIngestQueueDrain;
@@ -233,12 +233,12 @@ const scheduleDrain = (delayMs = 0) => {
     if (drainTimer) {
         return;
     }
-    const nextDelay = shouldDeferDrain?.()
+    const nextDelay = shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)
         ? Math.max(delayMs, deferDrainMs)
         : delayMs;
     drainTimer = setTimeout(() => {
         drainTimer = null;
-        if (shouldDeferDrain?.()) {
+        if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
             scheduleDrain(deferDrainMs);
             return;
         }
@@ -302,14 +302,14 @@ const drainIngestQueue = async () => {
     if (draining) {
         return;
     }
-    if (shouldDeferDrain?.()) {
+    if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
         scheduleDrain(deferDrainMs);
         return;
     }
     draining = true;
     try {
         while (ingestQueue.length > 0) {
-            if (shouldDeferDrain?.()) {
+            if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
                 scheduleDrain(deferDrainMs);
                 return;
             }
@@ -367,6 +367,7 @@ const enqueueIngestEntries = (config, sessionId, entries, options = {}) => {
         sessionId,
         entries: entries.slice(),
         attempts: 0,
+        enqueuedAt: Date.now(),
         priority,
     };
     if (priority === 'critical') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.50",
+  "version": "0.0.51",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,7 +15,7 @@
     "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
     "prepublishOnly": "npm run build",
     "test": "npm run build && node test/semantic-serialization.test.js && node test/semantic-serialization-trace.test.js && node test/content-addressed-trace-values.test.js && node test/trace-observation-snapshots.test.js && node test/session-storage-budget.test.js && node test/trace-source-exclude.test.js && 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/sdk-background-timeout-isolation.test.js && node test/runtime-service-registration.test.js && node test/ingest-queue-retention.test.js && node test/ingest-high-priority-retention.test.js && node test/ingest-high-priority-fairness.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-service-scope.test.js && node test/privacy-policy-index.test.js && node test/policy-capture-attestation.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/content-addressed-mongodb.testcontainers.test.js && node test/policy-session-completion.testcontainers.test.js && node test/postgresql-integrations.testcontainers.test.js"
+    "test:containers": "npm run build && node test/background-continuous-traffic.testcontainers.test.js && 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/content-addressed-mongodb.testcontainers.test.js && node test/policy-session-completion.testcontainers.test.js && node test/postgresql-integrations.testcontainers.test.js"
   },
   "peerDependencies": {
     "express": "^5.1.0",

package/src/index.ts

@@ -1552,8 +1552,9 @@ let activeClientRequestCount = 0;
 let oldestActiveClientRequestAt: number | null = null;
 let lastClientActivityAt = 0;
 let sdkBackgroundQuietUntil = 0;
-const sdkBackgroundHighQueue: Array<() => Promise<void> | void> = [];
-const sdkBackgroundQueue: Array<() => Promise<void> | void> = [];
+type SdkBackgroundWork = { work: () => Promise<void> | void; enqueuedAt: number };
+const sdkBackgroundHighQueue: SdkBackgroundWork[] = [];
+const sdkBackgroundQueue: SdkBackgroundWork[] = [];
 let sdkBackgroundTimer: NodeJS.Timeout | null = null;
 let sdkBackgroundDraining = false;
 let traceMaterializerWorker: any = null;
@@ -1575,23 +1576,25 @@ function noteClientActivity(now = Date.now()): void {
     lastClientActivityAt = now;
 }
 
-function getSdkBackgroundDelayMs(now = Date.now()): number {
+function getSdkBackgroundDelayMs(now = Date.now(), ingestEnqueuedAt?: number): number {
+    // Bound deferral by work age, not just by a continuously active request.
+    // Short non-overlapping requests reset oldestActiveClientRequestAt forever.
+    const oldestWorkAt = Math.min(
+        sdkBackgroundHighQueue[0]?.enqueuedAt ?? Infinity,
+        sdkBackgroundQueue[0]?.enqueuedAt ?? Infinity,
+        ingestEnqueuedAt ?? Infinity,
+        oldestActiveClientRequestAt ?? Infinity,
+    );
+    const remainingDeferMs = Number.isFinite(oldestWorkAt) && Number.isFinite(SDK_BACKGROUND_MAX_DEFER_MS)
+        ? Math.max(0, oldestWorkAt + SDK_BACKGROUND_MAX_DEFER_MS - now)
+        : Infinity;
     if (hasActiveClientRequests()) {
-        if (
-            oldestActiveClientRequestAt !== null &&
-            Number.isFinite(SDK_BACKGROUND_MAX_DEFER_MS) &&
-            SDK_BACKGROUND_MAX_DEFER_MS >= 0
-        ) {
-            const activeForMs = now - oldestActiveClientRequestAt;
-            if (activeForMs >= SDK_BACKGROUND_MAX_DEFER_MS) return 0;
-            return Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, Math.max(0, SDK_BACKGROUND_MAX_DEFER_MS - activeForMs));
-        }
-        return SDK_BACKGROUND_IDLE_DELAY_MS;
+        return Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, remainingDeferMs);
     }
     const sinceLastActivity = now - lastClientActivityAt;
     const idleDelayRemaining = Math.max(0, SDK_BACKGROUND_IDLE_DELAY_MS - sinceLastActivity);
     const quietWindowRemaining = Math.max(0, sdkBackgroundQuietUntil - now);
-    return Math.max(idleDelayRemaining, quietWindowRemaining);
+    return Math.min(Math.max(idleDelayRemaining, quietWindowRemaining), remainingDeferMs);
 }
 
 function shouldDeferSdkBackgroundWork(now = Date.now()): boolean {
@@ -1804,10 +1807,8 @@ function beginClientRequest(): void {
         oldestActiveClientRequestAt = now;
     }
     activeClientRequestCount += 1;
-    if (sdkBackgroundTimer) {
-        try { clearTimeout(sdkBackgroundTimer); } catch {}
-        sdkBackgroundTimer = null;
-    }
+    // The scheduled drain rechecks activity; cancelling it here loses the
+    // queued work's deadline under sustained traffic.
 }
 
 function endClientRequest(): void {
@@ -1828,15 +1829,17 @@ function scheduleSdkBackgroundWork(
     work: () => Promise<void> | void,
     options: { priority?: 'high' | 'normal' } = {},
 ): void {
+    const item = { work, enqueuedAt: Date.now() };
     if (options.priority === 'high') {
-        sdkBackgroundHighQueue.push(work);
+        sdkBackgroundHighQueue.push(item);
     } else {
-        sdkBackgroundQueue.push(work);
+        sdkBackgroundQueue.push(item);
     }
     scheduleSdkBackgroundDrain();
 }
 
 function scheduleSdkBackgroundDrain(delayMs = 0): void {
+    if (!sdkBackgroundHighQueue.length && !sdkBackgroundQueue.length) return;
     if (sdkBackgroundTimer) return;
     const nextDelay = Math.max(delayMs, getSdkBackgroundDelayMs());
     sdkBackgroundTimer = setTimeout(() => {
@@ -1871,11 +1874,11 @@ async function drainSdkBackgroundQueue(): Promise<void> {
                 scheduleSdkBackgroundDrain();
                 return;
             }
-            const work = sdkBackgroundHighQueue.shift() ?? sdkBackgroundQueue.shift();
-            if (!work) continue;
+            const item = sdkBackgroundHighQueue.shift() ?? sdkBackgroundQueue.shift();
+            if (!item) continue;
             try {
                 await drainQueuedIngestBeforeBackgroundWork();
-                await runSdkBackgroundWork(work);
+                await runSdkBackgroundWork(item.work);
             } catch {
                 // never break user code
             }
@@ -1891,8 +1894,8 @@ async function drainSdkBackgroundQueue(): Promise<void> {
 }
 
 configureIngestQueueDrain({
-    shouldDefer: shouldDeferSdkBackgroundWork,
-    deferMs: SDK_BACKGROUND_IDLE_DELAY_MS,
+    shouldDefer: (enqueuedAt) => getSdkBackgroundDelayMs(Date.now(), enqueuedAt) > 0,
+    deferMs: Math.min(SDK_BACKGROUND_IDLE_DELAY_MS, SDK_BACKGROUND_MAX_DEFER_MS),
 });
 
 // Track in-flight requests per session so we can delay flushing until a session is drained.

package/src/ingest/client.ts

@@ -44,6 +44,7 @@ type QueuedIngestBatch = {
     sessionId: string;
     entries: LegacyEntry[];
     attempts: number;
+    enqueuedAt: number;
     priority: 'normal' | 'high' | 'critical';
 };
 
@@ -59,13 +60,13 @@ let draining = false;
 let criticalDraining = false;
 let backoffMs = 0;
 let criticalBackoffMs = 0;
-let shouldDeferDrain: (() => boolean) | null = null;
+let shouldDeferDrain: ((enqueuedAt?: number) => boolean) | null = null;
 let deferDrainMs = DEFAULT_DEFER_DRAIN_MS;
 const throttledUntil = new Map<string, number>();
 const throttleDelay = (config: IngestClientConfig) => Math.max(0, (throttledUntil.get(resolveIngestUrl(config)) ?? 0) - Date.now());
 
 export const configureIngestQueueDrain = (options: {
-    shouldDefer?: (() => boolean) | null;
+    shouldDefer?: ((enqueuedAt?: number) => boolean) | null;
     deferMs?: number;
 }): void => {
     shouldDeferDrain = options.shouldDefer ?? null;
@@ -79,7 +80,7 @@ export const kickIngestQueueDrain = (): void => {
         scheduleCriticalDrain();
     }
     if (ingestQueue.length > 0 && !drainTimer) {
-        scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
+        scheduleDrain(shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt) ? deferDrainMs : 0);
     }
 };
 
@@ -288,12 +289,12 @@ const scheduleDrain = (delayMs = 0): void => {
     if (drainTimer) {
         return;
     }
-    const nextDelay = shouldDeferDrain?.()
+    const nextDelay = shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)
         ? Math.max(delayMs, deferDrainMs)
         : delayMs;
     drainTimer = setTimeout(() => {
         drainTimer = null;
-        if (shouldDeferDrain?.()) {
+        if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
             scheduleDrain(deferDrainMs);
             return;
         }
@@ -365,14 +366,14 @@ const drainIngestQueue = async (): Promise<void> => {
     if (draining) {
         return;
     }
-    if (shouldDeferDrain?.()) {
+    if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
         scheduleDrain(deferDrainMs);
         return;
     }
     draining = true;
     try {
         while (ingestQueue.length > 0) {
-            if (shouldDeferDrain?.()) {
+            if (shouldDeferDrain?.(ingestQueue[0]?.enqueuedAt)) {
                 scheduleDrain(deferDrainMs);
                 return;
             }
@@ -444,6 +445,7 @@ export const enqueueIngestEntries = (
         sessionId,
         entries: entries.slice(),
         attempts: 0,
+        enqueuedAt: Date.now(),
         priority,
     };
     if (priority === 'critical') {

package/test/background-continuous-traffic.testcontainers.test.js

@@ -0,0 +1,100 @@
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '2000';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '200';
+process.env.TRACE_IDLE_FLUSH_MS = '10';
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const { GenericContainer, Wait } = require('testcontainers');
+const { initRepro } = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+async function main() {
+  const events = [];
+  let rejectedOnce = false;
+  const sink = http.createServer((req, res) => {
+    const chunks = [];
+    req.on('data', chunk => chunks.push(chunk));
+    req.on('end', () => {
+      const batch = JSON.parse(Buffer.concat(chunks)).events;
+      if (!rejectedOnce && batch.some(event => event.event_type === 'backend_request')) {
+        rejectedOnce = true;
+        res.writeHead(503); res.end('{}'); return;
+      }
+      events.push(...batch);
+      res.writeHead(202); res.end('{}');
+    });
+  });
+  await new Promise(resolve => sink.listen(0, '127.0.0.1', resolve));
+  let mongo, app, polling;
+  let stopped = false, polls = 0, maxPollGap = 0;
+  try {
+    mongo = await new GenericContainer('mongo:7').withExposedPorts(27017)
+      .withWaitStrategy(Wait.forListeningPorts()).start();
+    const config = { tenantId: 'TENANT_busy', appId: 'APP_busy', appSecret: 'test',
+      privacy: { environment: 'dev', captureRaw: true },
+      ingestBase: `http://127.0.0.1:${sink.address().port}`,
+      tracing: { fullValueCapture: true, disableFunctionTypes: ['constructor'], logFunctionCalls: false } };
+    await initRepro(config);
+    app = await require('./fixtures/live-capture-limits-server').start(config,
+      `mongodb://${mongo.getHost()}:${mongo.getMappedPort(27017)}/busy`);
+    const base = `http://127.0.0.1:${app.server.address().port}`;
+    polling = (async () => {
+      let previous = Date.now();
+      while (!stopped) {
+        // Untagged, short requests also participate in the SDK's activity tracking.
+        const response = await fetch(`${base}/uncorrelated`);
+        await response.text();
+        maxPollGap = Math.max(maxPollGap, Date.now() - previous);
+        previous = Date.now();
+        polls++;
+        await sleep(20);
+      }
+    })();
+    for (const mode of ['live', 'staging']) {
+      const response = await fetch(`${base}/shipment?__repro_sid=S_busy_${mode}&__repro_aid=A_${mode}&__repro_mode=${mode}`);
+      assert.equal(response.status, 200);
+      const body = await response.json();
+      assert.equal(body.rows.length, 157, 'capture must not change business responses');
+      assert.equal(body.rows[156].id, 156);
+    }
+    const complete = () => ['live', 'staging'].every(mode => {
+      const scoped = events.filter(event => event.session_id === `S_busy_${mode}`);
+      return ['request_capture_start', 'backend_request', 'request_capture_manifest', 'trace_batch', 'db_change']
+        .every(type => scoped.some(event => event.event_type === type));
+    });
+    // Do not call flushIngestQueue: automatic delivery must work while traffic continues.
+    const deadline = Date.now() + 6000;
+    while (!complete() && Date.now() < deadline) await sleep(25);
+    assert(polls > 5, 'continuous traffic must overlap capture finalization');
+    assert(maxPollGap < 2000, `traffic must not accidentally create an idle window: ${maxPollGap}ms`);
+    assert(complete(), `uploads starved during short requests: ${JSON.stringify(events.map(e => [e.session_id, e.event_type]))}`);
+    assert(rejectedOnce, 'the test must exercise a real collector retry');
+    for (const mode of ['live', 'staging']) {
+      const scoped = events.filter(event => event.session_id === `S_busy_${mode}`);
+      const requests = scoped.filter(event => event.event_type === 'backend_request');
+      assert.equal(requests.length, 1, 'finish and close must not duplicate requests');
+      const request = requests[0].payload.request;
+      const values = scoped.flatMap(e => [...(e.payload.requestValues || []), ...(e.payload.traceValues || []), ...(e.payload.dbValues || [])]);
+      const body = values.find(v => v.id === request.respBodyValueCapture?.valueId)?.value || request.respBody;
+      assert.equal(body.rows.length, mode === 'live' ? 101 : 157);
+      const trace = scoped.flatMap(e => e.payload.trace || []).find(e => e.fn === 'inspectShipment' && e.type === 'enter');
+      assert(trace, 'instrumented function arguments must survive background delivery');
+      const args = values.find(v => v.id === trace.argsValueCapture?.valueId)?.value || trace.args;
+      assert.equal(args[0].rows.length, mode === 'live' ? 101 : 157);
+      assert(scoped.flatMap(e => e.payload.db || []).some(change => change.op === 'findOne'));
+    }
+    console.log(`continuous short HTTP traffic: complete live/staging captures delivered during ${polls} requests`);
+  } finally {
+    stopped = true;
+    if (polling) await polling;
+    if (app) await app.close();
+    await sleep(2100);
+    await flushIngestQueue();
+    await new Promise(resolve => sink.close(resolve));
+    if (mongo) await mongo.stop();
+  }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });