@reproapp/node-sdk 0.0.20 → 0.0.21

package/dist/index.js

@@ -4175,13 +4175,16 @@ function reproMiddleware(cfg) {
                             privacy: activePrivacy,
                         },
                     }, requestValueEntries);
+                const responseDurationMs = finishedAt !== null && Number.isFinite(finishedAt)
+                    ? Math.max(0, finishedAt - t0)
+                    : Date.now() - t0;
                 const requestPayload = {
                     rid,
                     method: req.method,
                     url,
                     path,
                     status: res.statusCode,
-                    durMs: Date.now() - t0,
+                    durMs: responseDurationMs,
                     headers: maskedHeaders,
                     key,
                     respBody: responseBody,
@@ -4217,6 +4220,12 @@ function reproMiddleware(cfg) {
                     return;
                 requestCaptureScheduled = true;
                 try {
+                    if (capturedBody === undefined && chunks.length) {
+                        const buf = Buffer.isBuffer(chunks[0])
+                            ? Buffer.concat(chunks.map(c => (Buffer.isBuffer(c) ? c : Buffer.from(String(c)))))
+                            : Buffer.from(chunks.map(String).join(''));
+                        capturedBody = coerceBodyToStorable(buf, res.getHeader?.('content-type'));
+                    }
                     const { chosenEndpoint, hasTraceEvents } = chooseRequestEndpoint();
                     const { requestPayload, requestValueEntries } = await buildRequestCapturePayloadAsync(chosenEndpoint, hasTraceEvents);
                     post(cfg, sid, {
@@ -4333,13 +4342,7 @@ function reproMiddleware(cfg) {
                     finishedAt = Date.now();
                     finishedAtAligned = alignTimestamp(finishedAt);
                 }
-                if (capturedBody === undefined && chunks.length) {
-                    const buf = Buffer.isBuffer(chunks[0])
-                        ? Buffer.concat(chunks.map(c => (Buffer.isBuffer(c) ? c : Buffer.from(String(c)))))
-                        : Buffer.from(chunks.map(String).join(''));
-                    capturedBody = coerceBodyToStorable(buf, res.getHeader?.('content-type'));
-                }
-                void emitRequestCaptureAsync();
+                scheduleSdkBackgroundWork(emitRequestCaptureAsync, { priority: 'high' });
                 if (!flushPayload) {
                     flushPayload = async () => {
                         let traceBatches = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "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-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-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",
+    "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/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-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",
     "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"
   },
   "peerDependencies": {

package/src/index.ts

@@ -5099,13 +5099,17 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         },
                     }, requestValueEntries);
 
+                const responseDurationMs =
+                    finishedAt !== null && Number.isFinite(finishedAt)
+                        ? Math.max(0, finishedAt - t0)
+                        : Date.now() - t0;
                 const requestPayload: Record<string, any> = {
                     rid,
                     method: req.method,
                     url,
                     path,
                     status: res.statusCode,
-                    durMs: Date.now() - t0,
+                    durMs: responseDurationMs,
                     headers: maskedHeaders,
                     key,
                     respBody: responseBody,
@@ -5134,6 +5138,13 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                 if (requestCaptureScheduled) return;
                 requestCaptureScheduled = true;
                 try {
+                    if (capturedBody === undefined && chunks.length) {
+                        const buf = Buffer.isBuffer(chunks[0])
+                            ? Buffer.concat(chunks.map(c => (Buffer.isBuffer(c) ? c : Buffer.from(String(c)))))
+                            : Buffer.from(chunks.map(String).join(''));
+                        capturedBody = coerceBodyToStorable(buf, res.getHeader?.('content-type'));
+                    }
+
                     const { chosenEndpoint, hasTraceEvents } = chooseRequestEndpoint();
                     const { requestPayload, requestValueEntries } = await buildRequestCapturePayloadAsync(
                         chosenEndpoint,
@@ -5259,14 +5270,8 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                     finishedAt = Date.now();
                     finishedAtAligned = alignTimestamp(finishedAt);
                 }
-                if (capturedBody === undefined && chunks.length) {
-                    const buf = Buffer.isBuffer(chunks[0])
-                        ? Buffer.concat(chunks.map(c => (Buffer.isBuffer(c) ? c : Buffer.from(String(c)))))
-                        : Buffer.from(chunks.map(String).join(''));
-                    capturedBody = coerceBodyToStorable(buf, res.getHeader?.('content-type'));
-                }
 
-                void emitRequestCaptureAsync();
+                scheduleSdkBackgroundWork(emitRequestCaptureAsync, { priority: 'high' });
 
                 if (!flushPayload) {
                     flushPayload = async () => {

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

@@ -0,0 +1,131 @@
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '500';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '25';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+process.env.TRACE_IDLE_FLUSH_MS = '10';
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+
+const assert = require('node:assert/strict');
+const { EventEmitter } = require('events');
+const { reproMiddleware } = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitFor(predicate, timeoutMs = 1500) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate()) return;
+        await sleep(20);
+    }
+    assert(predicate(), 'timed out waiting for expected condition');
+}
+
+function makeReqRes(sessionId, actionId) {
+    const req = new EventEmitter();
+    req.method = 'GET';
+    req.url = sessionId ? '/captured' : '/held-open';
+    req.headers = sessionId && actionId
+        ? {
+            'x-bug-session-id': sessionId,
+            'x-bug-action-id': actionId,
+            'x-bug-request-start': String(Date.now()),
+        }
+        : {};
+    req.body = undefined;
+    req.params = {};
+    req.query = {};
+
+    const res = new EventEmitter();
+    res.statusCode = 200;
+    res.getHeader = () => 'application/json';
+    res.setHeader = () => {};
+    res.json = function (body) { this.body = body; this.emit('finish'); return body; };
+    res.send = function (body) { this.body = body; this.emit('finish'); return body; };
+    res.write = () => true;
+    res.end = () => { res.emit('finish'); return true; };
+
+    return { req, res };
+}
+
+function flattenEvents(posts) {
+    return posts.flatMap((body) => Array.isArray(body?.events) ? body.events : []);
+}
+
+function countEvents(posts, eventType) {
+    return flattenEvents(posts).filter((event) => event?.event_type === eventType).length;
+}
+
+async function invokeMiddleware(middleware, req, res, handler) {
+    await new Promise((resolve, reject) => {
+        void middleware(req, res, async (err) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            try {
+                await handler();
+                resolve();
+            } catch (error) {
+                reject(error);
+            }
+        });
+    });
+}
+
+async function main() {
+    const capturedBodies = [];
+    const originalFetch = global.fetch;
+    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}',
+        };
+    };
+
+    try {
+        const cfg = {
+            tenantId: 'TENANT_test',
+            appId: 'APP_test',
+            appSecret: 'secret',
+            captureHeaders: false,
+            privacy: { environment: 'dev' },
+            ingestBase: 'http://127.0.0.1:65535',
+        };
+        const middleware = reproMiddleware(cfg);
+
+        const held = makeReqRes(null, null);
+        await invokeMiddleware(middleware, held.req, held.res, async () => {
+            // Keep this request open to simulate another client endpoint still in flight.
+        });
+
+        const tagged = makeReqRes('S_request_capture_background', 'A_request_capture_background');
+        await invokeMiddleware(middleware, tagged.req, tagged.res, async () => {
+            tagged.res.json({ ok: true, rows: Array.from({ length: 50 }, (_, i) => ({ i, value: `row-${i}` })) });
+        });
+
+        await sleep(100);
+        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);
+        await flushIngestQueue();
+
+        assert.equal(countEvents(capturedBodies, 'backend_request'), 1, JSON.stringify(capturedBodies));
+        console.log('request capture background OK');
+    } finally {
+        global.fetch = originalFetch;
+        await flushIngestQueue();
+    }
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});