@reproapp/node-sdk 0.0.14 → 0.0.15

package/dist/index.js

@@ -793,8 +793,11 @@ function createRequestCaptureScope(requestRid, transport) {
         emailEventCount: 0,
     };
 }
-function buildRequestCaptureManifestPayload(scope, traceBatchTotal) {
+function buildRequestCaptureManifestPayload(scope, traceBatchTotal, closedAtMs) {
     const expectedTraceBatches = Math.max(0, Math.trunc(traceBatchTotal));
+    const closedAt = typeof closedAtMs === 'number' && Number.isFinite(closedAtMs)
+        ? closedAtMs
+        : alignedNow();
     return {
         scopeId: `req:${scope.requestRid}`,
         requestRid: scope.requestRid,
@@ -811,7 +814,7 @@ function buildRequestCaptureManifestPayload(scope, traceBatchTotal) {
                 to: expectedTraceBatches - 1,
             }
             : undefined,
-        closedAt: alignedNow(),
+        closedAt,
     };
 }
 const als = new async_hooks_1.AsyncLocalStorage();
@@ -3960,6 +3963,7 @@ function reproMiddleware(cfg) {
             let flushed = false;
             let finished = false;
             let finishedAt = null;
+            let finishedAtAligned = null;
             let lastEventAt = Date.now();
             let idleTimer = null;
             let hardStopTimer = null;
@@ -4313,6 +4317,7 @@ function reproMiddleware(cfg) {
                 finished = true;
                 if (finishedAt === null) {
                     finishedAt = Date.now();
+                    finishedAtAligned = alignTimestamp(finishedAt);
                 }
                 if (capturedBody === undefined && chunks.length) {
                     const buf = Buffer.isBuffer(chunks[0])
@@ -4363,8 +4368,8 @@ function reproMiddleware(cfg) {
                                 entries: [{
                                         actionId: aid,
                                         requestRid: rid,
-                                        requestCaptureManifest: buildRequestCaptureManifestPayload(captureScope, traceBatches.length),
-                                        t: alignedNow(),
+                                        requestCaptureManifest: buildRequestCaptureManifestPayload(captureScope, traceBatches.length, finishedAtAligned),
+                                        t: finishedAtAligned ?? alignedNow(),
                                     }],
                             });
                         }

package/dist/ingest/client.js

@@ -14,6 +14,13 @@ 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_INGEST_REQUEST_TIMEOUT_MS = (() => {
+    const env = Number(typeof process !== 'undefined' ? process?.env?.REPRO_INGEST_REQUEST_TIMEOUT_MS : undefined);
+    if (Number.isFinite(env) && env >= 0) {
+        return Math.trunc(env);
+    }
+    return 5000;
+})();
 const ingestQueue = [];
 let drainTimer = null;
 let draining = false;
@@ -65,11 +72,29 @@ const sendIngestEntries = async (config, sessionId, entries) => {
     if (!events.length) {
         return true;
     }
+    let timeout = null;
+    const Controller = globalThis.AbortController;
+    const controller = DEFAULT_INGEST_REQUEST_TIMEOUT_MS > 0 && typeof Controller === 'function'
+        ? new Controller()
+        : null;
     try {
+        if (controller) {
+            timeout = setTimeout(() => {
+                try {
+                    controller.abort();
+                }
+                catch { }
+            }, DEFAULT_INGEST_REQUEST_TIMEOUT_MS);
+            try {
+                timeout.unref?.();
+            }
+            catch { }
+        }
         const response = await fetch(resolveIngestUrl(config), {
             method: 'POST',
             headers: toHeaders(config),
             body: JSON.stringify({ events }),
+            ...(controller ? { signal: controller.signal } : {}),
         });
         return response.ok;
     }
@@ -77,6 +102,14 @@ const sendIngestEntries = async (config, sessionId, entries) => {
         // swallow in SDK
         return false;
     }
+    finally {
+        if (timeout) {
+            try {
+                clearTimeout(timeout);
+            }
+            catch { }
+        }
+    }
 };
 const scheduleDrain = (delayMs = 0) => {
     if (drainTimer) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "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/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 -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/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/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/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js"
   },
   "peerDependencies": {
     "express": "^5.1.0",

package/src/index.ts

@@ -1181,8 +1181,13 @@ function createRequestCaptureScope(
 function buildRequestCaptureManifestPayload(
     scope: RequestCaptureScopeState,
     traceBatchTotal: number,
+    closedAtMs?: number | null,
 ): Record<string, any> {
     const expectedTraceBatches = Math.max(0, Math.trunc(traceBatchTotal));
+    const closedAt =
+        typeof closedAtMs === 'number' && Number.isFinite(closedAtMs)
+            ? closedAtMs
+            : alignedNow();
     return {
         scopeId: `req:${scope.requestRid}`,
         requestRid: scope.requestRid,
@@ -1200,7 +1205,7 @@ function buildRequestCaptureManifestPayload(
                     to: expectedTraceBatches - 1,
                 }
                 : undefined,
-        closedAt: alignedNow(),
+        closedAt,
     };
 }
 
@@ -4836,7 +4841,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
             return fn();
         };
 
-	        runInTrace(() => als.run({ sid, aid, rid, clockSkewMs, excludedSpanIds: new Set<string>(), maskReq, captureScope }, () => {
+        runInTrace(() => als.run({ sid, aid, rid, clockSkewMs, excludedSpanIds: new Set<string>(), maskReq, captureScope }, () => {
             const events: PendingTraceEventRecord[] = [];
             let endpointTrace: EndpointTraceInfo | null = null;
             let preferredAppTrace: EndpointTraceInfo | null = null;
@@ -4845,15 +4850,16 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
             let flushed = false;
             let finished = false;
             let finishedAt: number | null = null;
+            let finishedAtAligned: number | null = null;
             let lastEventAt: number = Date.now();
             let idleTimer: NodeJS.Timeout | null = null;
-	            let hardStopTimer: NodeJS.Timeout | null = null;
+            let hardStopTimer: NodeJS.Timeout | null = null;
             let flushPayload: null | (() => Promise<void>) = null;
             let requestCaptureScheduled = false;
             let sessionDrainWait: Promise<void> | null = null;
             const activeSpans = new Set<string>();
             let anonymousSpanDepth = 0;
-	            const ACTIVE_SPAN_FORCE_FLUSH_MS = 60000; // hard cutoff after finish to avoid endlessly running replies
+            const ACTIVE_SPAN_FORCE_FLUSH_MS = 60000; // hard cutoff after finish to avoid endlessly running replies
 
             const clearTimers = () => {
                 if (idleTimer) {
@@ -5231,6 +5237,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                 finished = true;
                 if (finishedAt === null) {
                     finishedAt = Date.now();
+                    finishedAtAligned = alignTimestamp(finishedAt);
                 }
                 if (capturedBody === undefined && chunks.length) {
                     const buf = Buffer.isBuffer(chunks[0])
@@ -5243,62 +5250,63 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
 
                 if (!flushPayload) {
                     flushPayload = async () => {
-                            try {
-                                const pendingEvents = preparePendingTraceEventsForFlush(events.slice());
-                                const materializedEvents = await materializePendingTraceEventsAsync(pendingEvents, {
-                                    cfg,
-                                    maskReq,
-                                    masking,
-                                    resolvePrivacy,
-                                });
-                                const baseEvents = balanceTraceEvents(materializedEvents.slice());
-                                const orderedEvents = TRACE_ORDER_MODE === 'tree'
-                                    ? reorderTraceEvents(baseEvents)
-                                    : sortTraceEventsChronologically(baseEvents);
-                                const traceBatches = chunkTraceEventsForTransport(
-                                    orderedEvents,
-                                    rid,
-                                    aid,
-                                );
-
-                                if (traceBatches.length) {
-                                    captureScope.traceBatchCount = traceBatches.length;
-                                    for (let i = 0; i < traceBatches.length; i++) {
-                                        const batch = traceBatches[i];
-                                        const traceValues = collectBatchTraceValueEntries(batch, i);
-
-                                        post(cfg, sid, {
-                                            entries: [{
-                                                actionId: aid,
-                                                trace: batch,
-                                                traceValues: traceValues.length ? traceValues : undefined,
-                                                traceBatch: {
-                                                    rid,
-                                                    index: i,
-                                                    total: traceBatches.length,
-                                                },
-                                                t: alignedNow(),
-                                            }],
-                                        });
-                                    }
-                                } else {
-                                    captureScope.traceBatchCount = 0;
-                                }
+                        try {
+                            const pendingEvents = preparePendingTraceEventsForFlush(events.slice());
+                            const materializedEvents = await materializePendingTraceEventsAsync(pendingEvents, {
+                                cfg,
+                                maskReq,
+                                masking,
+                                resolvePrivacy,
+                            });
+                            const baseEvents = balanceTraceEvents(materializedEvents.slice());
+                            const orderedEvents = TRACE_ORDER_MODE === 'tree'
+                                ? reorderTraceEvents(baseEvents)
+                                : sortTraceEventsChronologically(baseEvents);
+                            const traceBatches = chunkTraceEventsForTransport(
+                                orderedEvents,
+                                rid,
+                                aid,
+                            );
 
-                                post(cfg, sid, {
-                                    entries: [{
-                                        actionId: aid,
-                                        requestRid: rid,
-                                        requestCaptureManifest: buildRequestCaptureManifestPayload(
-                                            captureScope,
-                                            traceBatches.length,
-                                        ),
-                                        t: alignedNow(),
-                                    }],
-                                });
-                            } catch {
-                                // never break user code
+                            if (traceBatches.length) {
+                                captureScope.traceBatchCount = traceBatches.length;
+                                for (let i = 0; i < traceBatches.length; i++) {
+                                    const batch = traceBatches[i];
+                                    const traceValues = collectBatchTraceValueEntries(batch, i);
+
+                                    post(cfg, sid, {
+                                        entries: [{
+                                            actionId: aid,
+                                            trace: batch,
+                                            traceValues: traceValues.length ? traceValues : undefined,
+                                            traceBatch: {
+                                                rid,
+                                                index: i,
+                                                total: traceBatches.length,
+                                            },
+                                            t: alignedNow(),
+                                        }],
+                                    });
+                                }
+                            } else {
+                                captureScope.traceBatchCount = 0;
                             }
+
+                            post(cfg, sid, {
+                                entries: [{
+                                    actionId: aid,
+                                    requestRid: rid,
+                                    requestCaptureManifest: buildRequestCaptureManifestPayload(
+                                        captureScope,
+                                        traceBatches.length,
+                                        finishedAtAligned,
+                                    ),
+                                    t: finishedAtAligned ?? alignedNow(),
+                                }],
+                            });
+                        } catch {
+                            // never break user code
+                        }
                     };
                 }
 

package/src/ingest/client.ts

@@ -13,6 +13,13 @@ 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_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) {
+        return Math.trunc(env);
+    }
+    return 5000;
+})();
 
 type QueuedIngestBatch = {
     config: IngestClientConfig;
@@ -91,16 +98,41 @@ const sendIngestEntries = async (
         return true;
     }
 
+    let timeout: ReturnType<typeof setTimeout> | null = null;
+    const Controller = (globalThis as any).AbortController;
+    const controller =
+        DEFAULT_INGEST_REQUEST_TIMEOUT_MS > 0 && typeof Controller === 'function'
+            ? new Controller()
+            : null;
+
     try {
+        if (controller) {
+            timeout = setTimeout(() => {
+                try {
+                    controller.abort();
+                } catch {}
+            }, DEFAULT_INGEST_REQUEST_TIMEOUT_MS);
+            try {
+                (timeout as any).unref?.();
+            } catch {}
+        }
+
         const response = await fetch(resolveIngestUrl(config), {
             method: 'POST',
             headers: toHeaders(config),
             body: JSON.stringify({ events }),
+            ...(controller ? { signal: controller.signal } : {}),
         });
         return response.ok;
     } catch {
         // swallow in SDK
         return false;
+    } finally {
+        if (timeout) {
+            try {
+                clearTimeout(timeout);
+            } catch {}
+        }
     }
 };
 

package/test/ingest-timeout.test.js

@@ -0,0 +1,67 @@
+process.env.REPRO_INGEST_REQUEST_TIMEOUT_MS = '25';
+
+const assert = require('node:assert/strict');
+
+const { postIngestEntries } = require('../dist/ingest/client');
+
+async function main() {
+    const originalFetch = global.fetch;
+    let aborted = false;
+
+    global.fetch = async (_url, init = {}) => {
+        return await new Promise((_resolve, reject) => {
+            const signal = init.signal;
+            assert(signal, 'fetch should receive an AbortSignal');
+            const keepAlive = setTimeout(() => {}, 1000);
+            signal.addEventListener('abort', () => {
+                clearTimeout(keepAlive);
+                aborted = true;
+                const error = new Error('aborted');
+                error.name = 'AbortError';
+                reject(error);
+            });
+        });
+    };
+
+    try {
+        const startedAt = Date.now();
+        await postIngestEntries(
+            {
+                tenantId: 'TENANT_test',
+                appId: 'APP_test',
+                appSecret: 'secret',
+                ingestBase: 'http://127.0.0.1:65535',
+            },
+            'S_ingest_timeout',
+            [
+                {
+                    actionId: 'A_ingest_timeout',
+                    request: {
+                        rid: 'R_ingest_timeout',
+                        method: 'GET',
+                        url: '/timeout',
+                        status: 200,
+                        durMs: 1,
+                    },
+                    t: Date.now(),
+                },
+            ],
+        );
+        const elapsedMs = Date.now() - startedAt;
+
+        assert.equal(aborted, true, 'ingest fetch should be aborted on timeout');
+        assert(
+            elapsedMs < 500,
+            `ingest timeout should bound queue blocking; elapsed ${elapsedMs}ms`,
+        );
+
+        console.log('ingest timeout OK');
+    } finally {
+        global.fetch = originalFetch;
+    }
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/test/request-flush-timing.test.js

@@ -74,6 +74,10 @@ async function main() {
             ingestBase: 'http://127.0.0.1:65535',
         };
         const { req, res } = makeTaggedReqRes('S_request_flush_timing', 'A_request_flush_timing');
+        let responseFinishedAt = 0;
+        res.on('finish', () => {
+            responseFinishedAt = Date.now();
+        });
 
         await new Promise((resolve, reject) => {
             void reproMiddleware(cfg)(req, res, async (err) => {
@@ -114,6 +118,14 @@ async function main() {
             1,
             JSON.stringify(capturedBodies),
         );
+        const manifestEvent = flattenEvents(capturedBodies)
+            .find((event) => event?.event_type === 'request_capture_manifest');
+        const manifestClosedAt = Number(manifestEvent?.payload?.requestCaptureManifest?.closedAt);
+        assert(Number.isFinite(manifestClosedAt), JSON.stringify(manifestEvent));
+        assert(
+            Math.abs(manifestClosedAt - responseFinishedAt) < 500,
+            `manifest closedAt should use response finish time; got ${manifestClosedAt}, finish ${responseFinishedAt}`,
+        );
 
         console.log('request flush timing OK');
     } finally {