@reproapp/node-sdk 0.0.13 → 0.0.15

package/dist/index.js

@@ -783,6 +783,40 @@ function attachSpanContext(target, span) {
     }
     return target;
 }
+function createRequestCaptureScope(requestRid, transport) {
+    return {
+        requestRid,
+        transport,
+        backendRequestCount: 0,
+        traceBatchCount: 0,
+        dbChangeCount: 0,
+        emailEventCount: 0,
+    };
+}
+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,
+        transport: scope.transport,
+        expected: {
+            backendRequest: scope.backendRequestCount,
+            traceBatch: expectedTraceBatches,
+            dbChange: scope.dbChangeCount,
+            emailEvent: scope.emailEventCount,
+        },
+        traceBatch: expectedTraceBatches > 0
+            ? {
+                from: 0,
+                to: expectedTraceBatches - 1,
+            }
+            : undefined,
+        closedAt,
+    };
+}
 const als = new async_hooks_1.AsyncLocalStorage();
 const getCtx = () => als.getStore() || {};
 function currentClockSkewMs() {
@@ -3879,6 +3913,7 @@ function reproMiddleware(cfg) {
         const clockSkewMs = headerTs !== null ? headerTs - requestStartRaw : 0;
         const requestEpochMs = headerTs !== null ? headerTs : requestStartRaw + clockSkewMs;
         const rid = nextRequestId(requestEpochMs);
+        const captureScope = createRequestCaptureScope(rid, 'http');
         const t0 = requestStartRaw;
         const url = req.originalUrl || req.url || '/';
         const urlPathOnly = (url || '/').split('?')[0] || '/';
@@ -3919,7 +3954,7 @@ function reproMiddleware(cfg) {
             }
             return fn();
         };
-        runInTrace(() => als.run({ sid, aid, rid, clockSkewMs, excludedSpanIds: new Set(), maskReq }, () => {
+        runInTrace(() => als.run({ sid, aid, rid, clockSkewMs, excludedSpanIds: new Set(), maskReq, captureScope }, () => {
             const events = [];
             let endpointTrace = null;
             let preferredAppTrace = null;
@@ -3928,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;
@@ -4190,6 +4226,7 @@ function reproMiddleware(cfg) {
                                 t: requestEpochMs,
                             }]
                     });
+                    captureScope.backendRequestCount += 1;
                 }
                 catch {
                     // never break user code
@@ -4280,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])
@@ -4304,6 +4342,7 @@ function reproMiddleware(cfg) {
                                 : 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);
@@ -4322,6 +4361,17 @@ function reproMiddleware(cfg) {
                                     });
                                 }
                             }
+                            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
@@ -4786,6 +4836,12 @@ function dehydrateComplexValue(value) {
 }
 function emitDbQuery(cfg, sid, aid, payload) {
     const ctx = getCtx();
+    const spanContext = payload?.spanContext ?? captureSpanContextFromTracer();
+    if (!shouldCaptureDbSpan(spanContext))
+        return;
+    if (ctx.captureScope) {
+        ctx.captureScope.dbChangeCount += 1;
+    }
     const runCtx = {
         sid: ctx.sid,
         aid: ctx.aid,
@@ -4793,6 +4849,7 @@ function emitDbQuery(cfg, sid, aid, payload) {
         clockSkewMs: ctx.clockSkewMs,
         maskReq: ctx.maskReq,
         excludedSpanIds: ctx.excludedSpanIds ? new Set(ctx.excludedSpanIds) : undefined,
+        captureScope: ctx.captureScope,
     };
     scheduleSdkBackgroundWork(async () => {
         await als.run(runCtx, async () => {
@@ -5575,9 +5632,9 @@ function buildKafkaTraceEntries(actionId, requestRid, events) {
         t: alignedNow(),
     }));
 }
-function scheduleKafkaTraceFlush(cfg, kafkaCtx, actionId, requestRid, rawTraceEvents, maskReq) {
+function scheduleKafkaTraceFlush(cfg, kafkaCtx, actionId, requestRid, rawTraceEvents, maskReq, captureScope) {
     const sid = kafkaCtx.sid;
-    if (!sid || !rawTraceEvents.length)
+    if (!sid)
         return;
     const rawEvents = rawTraceEvents.slice();
     scheduleSdkBackgroundWork(async () => {
@@ -5600,9 +5657,22 @@ function scheduleKafkaTraceFlush(cfg, kafkaCtx, actionId, requestRid, rawTraceEv
                 resolvePrivacy: () => getRuntimePrivacyState(cfg).policy ?? null,
             });
             const entries = buildKafkaTraceEntries(actionId, requestRid, materializedEvents);
+            if (captureScope) {
+                captureScope.traceBatchCount = entries.length;
+            }
             if (entries.length) {
                 post(cfg, sid, { entries });
             }
+            if (captureScope) {
+                post(cfg, sid, {
+                    entries: [{
+                            actionId: actionId ?? null,
+                            requestRid,
+                            requestCaptureManifest: buildRequestCaptureManifestPayload(captureScope, entries.length),
+                            t: alignedNow(),
+                        }],
+                });
+            }
         });
     }, { priority: 'high' });
 }
@@ -5619,6 +5689,7 @@ function patchKafkaProducerInstance(producer, cfg) {
             const aid = ctx.aid ?? fallback.aid ?? null;
             const span = captureSpanContextFromTracer();
             const publishRid = nextRequestId(alignedNow());
+            const captureScope = createRequestCaptureScope(publishRid, 'kafka');
             const payloadObj = payload && typeof payload === 'object' ? payload : {};
             const topic = sanitizeKafkaTopic(payloadObj.topic);
             const rawMessages = Array.isArray(payloadObj.messages) ? payloadObj.messages : [];
@@ -5705,6 +5776,15 @@ function patchKafkaProducerInstance(producer, cfg) {
                         },
                     ],
                 });
+                captureScope.backendRequestCount += 1;
+                post(cfg, sid, {
+                    entries: [{
+                            actionId: aid ?? null,
+                            requestRid: publishRid,
+                            requestCaptureManifest: buildRequestCaptureManifestPayload(captureScope, 0),
+                            t: alignedNow(),
+                        }],
+                });
             }
         };
     }
@@ -5717,6 +5797,7 @@ function patchKafkaProducerInstance(producer, cfg) {
             const aid = ctx.aid ?? fallback.aid ?? null;
             const span = captureSpanContextFromTracer();
             const publishRid = nextRequestId(alignedNow());
+            const captureScope = createRequestCaptureScope(publishRid, 'kafka');
             const payloadObj = payload && typeof payload === 'object' ? payload : {};
             const topicMessages = Array.isArray(payloadObj.topicMessages)
                 ? payloadObj.topicMessages
@@ -5834,6 +5915,15 @@ function patchKafkaProducerInstance(producer, cfg) {
                         },
                     ],
                 });
+                captureScope.backendRequestCount += 1;
+                post(cfg, sid, {
+                    entries: [{
+                            actionId: aid ?? null,
+                            requestRid: publishRid,
+                            requestCaptureManifest: buildRequestCaptureManifestPayload(captureScope, 0),
+                            t: alignedNow(),
+                        }],
+                });
             }
         };
     }
@@ -5848,6 +5938,7 @@ function wrapKafkaEachMessageHandler(eachMessage, cfg, consumer) {
         const aid = runtime.aid;
         const consumeRid = nextRequestId(`${topic}-${message?.offset ?? alignedNow()}`);
         const traceId = consumeRid;
+        const captureScope = createRequestCaptureScope(consumeRid, 'kafka');
         const rawTraceEvents = [];
         const maskReq = {
             method: 'KAFKA_CONSUME',
@@ -5862,6 +5953,7 @@ function wrapKafkaEachMessageHandler(eachMessage, cfg, consumer) {
             excludedSpanIds: new Set(),
             maskReq,
             privacyTasks: new Set(),
+            captureScope,
         };
         let unsubscribe;
         const invoke = async () => {
@@ -5944,7 +6036,8 @@ function wrapKafkaEachMessageHandler(eachMessage, cfg, consumer) {
                         t: alignedNow(),
                     }],
             });
-            scheduleKafkaTraceFlush(cfg, kafkaCtx, aid, consumeRid, rawTraceEvents, maskReq);
+            captureScope.backendRequestCount += 1;
+            scheduleKafkaTraceFlush(cfg, kafkaCtx, aid, consumeRid, rawTraceEvents, maskReq, captureScope);
         }
     };
 }
@@ -5959,6 +6052,7 @@ function wrapKafkaEachBatchHandler(eachBatch, cfg, consumer) {
         const aid = runtime.aid;
         const consumeRid = nextRequestId(`${topic}-batch-${alignedNow()}`);
         const traceId = consumeRid;
+        const captureScope = createRequestCaptureScope(consumeRid, 'kafka');
         const rawTraceEvents = [];
         const maskReq = {
             method: 'KAFKA_CONSUME_BATCH',
@@ -5973,6 +6067,7 @@ function wrapKafkaEachBatchHandler(eachBatch, cfg, consumer) {
             excludedSpanIds: new Set(),
             maskReq,
             privacyTasks: new Set(),
+            captureScope,
         };
         let unsubscribe;
         const invoke = async () => {
@@ -6053,7 +6148,8 @@ function wrapKafkaEachBatchHandler(eachBatch, cfg, consumer) {
                         t: alignedNow(),
                     }],
             });
-            scheduleKafkaTraceFlush(cfg, kafkaCtx, aid, consumeRid, rawTraceEvents, maskReq);
+            captureScope.backendRequestCount += 1;
+            scheduleKafkaTraceFlush(cfg, kafkaCtx, aid, consumeRid, rawTraceEvents, maskReq, captureScope);
         }
     };
 }
@@ -6705,10 +6801,14 @@ function patchSendgridFromModuleExports(sgMail, cfg) {
         const aid = ctx.aid ?? cfg.resolveContext?.()?.aid;
         if (!sid)
             return;
+        if (ctx.captureScope) {
+            ctx.captureScope.emailEventCount += 1;
+        }
         const norm = normalizeSendgridMessage(rawMsg);
         post(cfg, sid, {
             entries: [{
                     actionId: aid ?? null,
+                    requestRid: ctx.rid ?? null,
                     email: {
                         provider: 'sendgrid',
                         kind,

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/dist/ingest/mapper.js

@@ -6,6 +6,10 @@ const toIso = (timestamp) => {
     return new Date(numeric).toISOString();
 };
 const inferEventType = (entry) => {
+    if (entry.requestCaptureManifest !== undefined)
+        return 'request_capture_manifest';
+    if (entry.sessionCaptureManifest !== undefined)
+        return 'session_capture_manifest';
     if (entry.request !== undefined)
         return 'backend_request';
     if (entry.db !== undefined)

package/dist/ingest/types.d.ts

@@ -17,6 +17,8 @@ export interface LegacyEntry {
     requestRid?: string | null;
     request?: unknown;
     requestValues?: unknown[];
+    requestCaptureManifest?: unknown;
+    sessionCaptureManifest?: unknown;
     db?: unknown;
     dbValues?: unknown[];
     trace?: unknown[];

package/package.json

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

@@ -1152,7 +1152,63 @@ type Ctx = {
     excludedSpanIds?: Set<string>;
     maskReq?: MaskRequestContext;
     privacyTasks?: Set<Promise<void>>;
+    captureScope?: RequestCaptureScopeState;
 };
+
+type RequestCaptureScopeState = {
+    requestRid: string;
+    transport: 'http' | 'kafka' | 'background';
+    backendRequestCount: number;
+    traceBatchCount: number;
+    dbChangeCount: number;
+    emailEventCount: number;
+};
+
+function createRequestCaptureScope(
+    requestRid: string,
+    transport: RequestCaptureScopeState['transport'],
+): RequestCaptureScopeState {
+    return {
+        requestRid,
+        transport,
+        backendRequestCount: 0,
+        traceBatchCount: 0,
+        dbChangeCount: 0,
+        emailEventCount: 0,
+    };
+}
+
+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,
+        transport: scope.transport,
+        expected: {
+            backendRequest: scope.backendRequestCount,
+            traceBatch: expectedTraceBatches,
+            dbChange: scope.dbChangeCount,
+            emailEvent: scope.emailEventCount,
+        },
+        traceBatch:
+            expectedTraceBatches > 0
+                ? {
+                    from: 0,
+                    to: expectedTraceBatches - 1,
+                }
+                : undefined,
+        closedAt,
+    };
+}
+
 const als = new AsyncLocalStorage<Ctx>();
 const getCtx = () => als.getStore() || {};
 
@@ -4747,6 +4803,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
         const clockSkewMs = headerTs !== null ? headerTs - requestStartRaw : 0;
         const requestEpochMs = headerTs !== null ? headerTs : requestStartRaw + clockSkewMs;
         const rid = nextRequestId(requestEpochMs);
+        const captureScope = createRequestCaptureScope(rid, 'http');
         const t0 = requestStartRaw;
         const url = (req as any).originalUrl || req.url || '/';
         const urlPathOnly = (url || '/').split('?')[0] || '/';
@@ -4784,7 +4841,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
             return fn();
         };
 
-	        runInTrace(() => als.run({ sid, aid, rid, clockSkewMs, excludedSpanIds: new Set<string>(), maskReq }, () => {
+        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;
@@ -4793,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) {
@@ -5086,6 +5144,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                             t: requestEpochMs,
                         }]
                     });
+                    captureScope.backendRequestCount += 1;
                 } catch {
                     // never break user code
                 }
@@ -5178,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])
@@ -5190,47 +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) {
-                                    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(),
-                                            }],
-                                        });
-                                    }
+                        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(),
+                                        }],
+                                    });
                                 }
-                            } catch {
-                                // never break user code
+                            } 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
+                        }
                     };
                 }
 
@@ -5697,6 +5773,11 @@ function dehydrateComplexValue(value: any) {
 
 function emitDbQuery(cfg: any, sid?: string, aid?: string, payload?: any) {
     const ctx = getCtx() as Ctx;
+    const spanContext = payload?.spanContext ?? captureSpanContextFromTracer();
+    if (!shouldCaptureDbSpan(spanContext)) return;
+    if (ctx.captureScope) {
+        ctx.captureScope.dbChangeCount += 1;
+    }
     const runCtx: Ctx = {
         sid: ctx.sid,
         aid: ctx.aid,
@@ -5704,6 +5785,7 @@ function emitDbQuery(cfg: any, sid?: string, aid?: string, payload?: any) {
         clockSkewMs: ctx.clockSkewMs,
         maskReq: ctx.maskReq,
         excludedSpanIds: ctx.excludedSpanIds ? new Set(ctx.excludedSpanIds) : undefined,
+        captureScope: ctx.captureScope,
     };
     scheduleSdkBackgroundWork(async () => {
         await als.run(runCtx, async () => {
@@ -6588,9 +6670,10 @@ function scheduleKafkaTraceFlush(
     requestRid: string,
     rawTraceEvents: any[],
     maskReq: MaskRequestContext,
+    captureScope?: RequestCaptureScopeState,
 ): void {
     const sid = kafkaCtx.sid;
-    if (!sid || !rawTraceEvents.length) return;
+    if (!sid) return;
     const rawEvents = rawTraceEvents.slice();
 
     scheduleSdkBackgroundWork(async () => {
@@ -6611,9 +6694,25 @@ function scheduleKafkaTraceFlush(
                 resolvePrivacy: () => getRuntimePrivacyState(cfg).policy ?? null,
             });
             const entries = buildKafkaTraceEntries(actionId, requestRid, materializedEvents);
+            if (captureScope) {
+                captureScope.traceBatchCount = entries.length;
+            }
             if (entries.length) {
                 post(cfg, sid, { entries });
             }
+            if (captureScope) {
+                post(cfg, sid, {
+                    entries: [{
+                        actionId: actionId ?? null,
+                        requestRid,
+                        requestCaptureManifest: buildRequestCaptureManifestPayload(
+                            captureScope,
+                            entries.length,
+                        ),
+                        t: alignedNow(),
+                    }],
+                });
+            }
         });
     }, { priority: 'high' });
 }
@@ -6631,6 +6730,7 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
             const aid = ctx.aid ?? fallback.aid ?? null;
             const span = captureSpanContextFromTracer();
             const publishRid = nextRequestId(alignedNow());
+            const captureScope = createRequestCaptureScope(publishRid, 'kafka');
             const payloadObj = payload && typeof payload === 'object' ? payload : {};
             const topic = sanitizeKafkaTopic((payloadObj as any).topic);
             const rawMessages = Array.isArray((payloadObj as any).messages) ? (payloadObj as any).messages : [];
@@ -6719,6 +6819,18 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
                         },
                     ],
                 });
+                captureScope.backendRequestCount += 1;
+                post(cfg, sid, {
+                    entries: [{
+                        actionId: aid ?? null,
+                        requestRid: publishRid,
+                        requestCaptureManifest: buildRequestCaptureManifestPayload(
+                            captureScope,
+                            0,
+                        ),
+                        t: alignedNow(),
+                    }],
+                });
             }
         };
     }
@@ -6732,6 +6844,7 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
             const aid = ctx.aid ?? fallback.aid ?? null;
             const span = captureSpanContextFromTracer();
             const publishRid = nextRequestId(alignedNow());
+            const captureScope = createRequestCaptureScope(publishRid, 'kafka');
 
             const payloadObj = payload && typeof payload === 'object' ? payload : {};
             const topicMessages = Array.isArray((payloadObj as any).topicMessages)
@@ -6854,6 +6967,18 @@ function patchKafkaProducerInstance(producer: any, cfg: KafkaJsPatchConfig) {
                         },
                     ],
                 });
+                captureScope.backendRequestCount += 1;
+                post(cfg, sid, {
+                    entries: [{
+                        actionId: aid ?? null,
+                        requestRid: publishRid,
+                        requestCaptureManifest: buildRequestCaptureManifestPayload(
+                            captureScope,
+                            0,
+                        ),
+                        t: alignedNow(),
+                    }],
+                });
             }
         };
     }
@@ -6869,6 +6994,7 @@ function wrapKafkaEachMessageHandler(eachMessage: any, cfg: KafkaJsPatchConfig,
         const aid = runtime.aid;
         const consumeRid = nextRequestId(`${topic}-${message?.offset ?? alignedNow()}`);
         const traceId = consumeRid;
+        const captureScope = createRequestCaptureScope(consumeRid, 'kafka');
         const rawTraceEvents: any[] = [];
         const maskReq: MaskRequestContext = {
             method: 'KAFKA_CONSUME',
@@ -6883,6 +7009,7 @@ function wrapKafkaEachMessageHandler(eachMessage: any, cfg: KafkaJsPatchConfig,
             excludedSpanIds: new Set<string>(),
             maskReq,
             privacyTasks: new Set<Promise<void>>(),
+            captureScope,
         };
         let unsubscribe: undefined | (() => void);
 
@@ -6960,7 +7087,8 @@ function wrapKafkaEachMessageHandler(eachMessage: any, cfg: KafkaJsPatchConfig,
                     t: alignedNow(),
                 }],
             });
-            scheduleKafkaTraceFlush(cfg, kafkaCtx, aid, consumeRid, rawTraceEvents, maskReq);
+            captureScope.backendRequestCount += 1;
+            scheduleKafkaTraceFlush(cfg, kafkaCtx, aid, consumeRid, rawTraceEvents, maskReq, captureScope);
         }
     };
 }
@@ -6976,6 +7104,7 @@ function wrapKafkaEachBatchHandler(eachBatch: any, cfg: KafkaJsPatchConfig, cons
         const aid = runtime.aid;
         const consumeRid = nextRequestId(`${topic}-batch-${alignedNow()}`);
         const traceId = consumeRid;
+        const captureScope = createRequestCaptureScope(consumeRid, 'kafka');
         const rawTraceEvents: any[] = [];
         const maskReq: MaskRequestContext = {
             method: 'KAFKA_CONSUME_BATCH',
@@ -6990,6 +7119,7 @@ function wrapKafkaEachBatchHandler(eachBatch: any, cfg: KafkaJsPatchConfig, cons
             excludedSpanIds: new Set<string>(),
             maskReq,
             privacyTasks: new Set<Promise<void>>(),
+            captureScope,
         };
         let unsubscribe: undefined | (() => void);
 
@@ -7065,7 +7195,8 @@ function wrapKafkaEachBatchHandler(eachBatch: any, cfg: KafkaJsPatchConfig, cons
                     t: alignedNow(),
                 }],
             });
-            scheduleKafkaTraceFlush(cfg, kafkaCtx, aid, consumeRid, rawTraceEvents, maskReq);
+            captureScope.backendRequestCount += 1;
+            scheduleKafkaTraceFlush(cfg, kafkaCtx, aid, consumeRid, rawTraceEvents, maskReq, captureScope);
         }
     };
 }
@@ -7761,11 +7892,15 @@ function patchSendgridFromModuleExports(sgMail: any, cfg: SendgridPatchConfig) {
         const sid = ctx.sid ?? cfg.resolveContext?.()?.sid;
         const aid = ctx.aid ?? cfg.resolveContext?.()?.aid;
         if (!sid) return;
+        if (ctx.captureScope) {
+            ctx.captureScope.emailEventCount += 1;
+        }
 
         const norm = normalizeSendgridMessage(rawMsg);
 	        post(cfg, sid, {
 	            entries: [{
 	                actionId: aid ?? null,
+                    requestRid: ctx.rid ?? null,
 	                email: {
 	                    provider: 'sendgrid',
                     kind,

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/src/ingest/mapper.ts

@@ -7,6 +7,8 @@ const toIso = (timestamp: unknown): string => {
 };
 
 const inferEventType = (entry: LegacyEntry): string => {
+  if (entry.requestCaptureManifest !== undefined) return 'request_capture_manifest';
+  if (entry.sessionCaptureManifest !== undefined) return 'session_capture_manifest';
   if (entry.request !== undefined) return 'backend_request';
   if (entry.db !== undefined) return 'db_change';
   if (entry.trace !== undefined) return 'trace_batch';

package/src/ingest/types.ts

@@ -18,6 +18,8 @@ export interface LegacyEntry {
     requestRid?: string | null;
     request?: unknown;
     requestValues?: unknown[];
+    requestCaptureManifest?: unknown;
+    sessionCaptureManifest?: unknown;
     db?: unknown;
     dbValues?: unknown[];
     trace?: unknown[];

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) => {
@@ -109,6 +113,19 @@ async function main() {
 
         assert.strictEqual(countEvents(capturedBodies, 'backend_request'), 1, JSON.stringify(capturedBodies));
         assert(countEvents(capturedBodies, 'trace_batch') >= 1, JSON.stringify(capturedBodies));
+        assert.strictEqual(
+            countEvents(capturedBodies, 'request_capture_manifest'),
+            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 {