@reproapp/node-sdk 0.0.54 → 0.0.56

package/dist/capture-work-budget.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.yieldCaptureWork = void 0;
+exports.yieldCaptureWork = yieldCaptureWork;
 // Promise-only recursion never yields to HTTP sockets. Share a small time slice
 // across asynchronous capture walkers, including the worker-unavailable fallback.
 let deadline = 0;
@@ -22,4 +22,3 @@ function yieldCaptureWork() {
     }));
     return pendingYield;
 }
-exports.yieldCaptureWork = yieldCaptureWork;

package/dist/index.d.ts

@@ -1,28 +1,3 @@
-/// <reference types="mongoose/types/aggregate" />
-/// <reference types="mongoose/types/callback" />
-/// <reference types="mongoose/types/collection" />
-/// <reference types="mongoose/types/connection" />
-/// <reference types="mongoose/types/cursor" />
-/// <reference types="mongoose/types/document" />
-/// <reference types="mongoose/types/error" />
-/// <reference types="mongoose/types/expressions" />
-/// <reference types="mongoose/types/helpers" />
-/// <reference types="mongoose/types/middlewares" />
-/// <reference types="mongoose/types/indexes" />
-/// <reference types="mongoose/types/models" />
-/// <reference types="mongoose/types/mongooseoptions" />
-/// <reference types="mongoose/types/pipelinestage" />
-/// <reference types="mongoose/types/populate" />
-/// <reference types="mongoose/types/query" />
-/// <reference types="mongoose/types/schemaoptions" />
-/// <reference types="mongoose/types/session" />
-/// <reference types="mongoose/types/types" />
-/// <reference types="mongoose/types/utility" />
-/// <reference types="mongoose/types/validation" />
-/// <reference types="mongoose/types/virtuals" />
-/// <reference types="mongoose/types/schematypes" />
-/// <reference types="mongoose/types/inferschematype" />
-/// <reference types="mongoose/types/inferrawdoctype" />
 import type { Request, Response, NextFunction } from 'express';
 import type { Schema } from 'mongoose';
 import { type IngestClientConfig } from './ingest/client';
@@ -485,7 +460,7 @@ export declare const __reproTestHooks: {
     shareRuntimePrivacyStateForTest: typeof shareRuntimePrivacyState;
     setFullValueCaptureEnabledForTest(enabled: boolean): void;
     scheduleSdkBackgroundWorkForTest(work: () => Promise<void> | void, options?: {
-        priority?: 'high' | 'normal';
+        priority?: "high" | "normal";
     }): void;
     drainSdkBackgroundQueueForTest(): Promise<void>;
     resetSdkBackgroundQueuesForTest(): void;

package/dist/index.js

@@ -1,6 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__reproTestHooks = exports.initRepro = exports.patchSendgridMail = exports.patchMongoDb = exports.patchPostgreSql = exports.patchRedis = exports.patchAmqplib = exports.patchKafkaJs = exports.reproMongoosePlugin = exports.reproMiddleware = exports.__materializePendingTraceEventsForWorker = exports.isReproTracingEnabled = exports.initReproTracing = exports.disableReproTraceLogs = exports.enableReproTraceLogs = exports.setReproTraceLogsEnabled = exports.setDisabledTraceFiles = exports.setDisabledFunctionTypes = exports.setDisabledFunctionTraces = void 0;
+exports.__reproTestHooks = void 0;
+exports.setDisabledFunctionTraces = setDisabledFunctionTraces;
+exports.setDisabledFunctionTypes = setDisabledFunctionTypes;
+exports.setDisabledTraceFiles = setDisabledTraceFiles;
+exports.setReproTraceLogsEnabled = setReproTraceLogsEnabled;
+exports.enableReproTraceLogs = enableReproTraceLogs;
+exports.disableReproTraceLogs = disableReproTraceLogs;
+exports.initReproTracing = initReproTracing;
+exports.isReproTracingEnabled = isReproTracingEnabled;
+exports.__materializePendingTraceEventsForWorker = __materializePendingTraceEventsForWorker;
+exports.reproMiddleware = reproMiddleware;
+exports.reproMongoosePlugin = reproMongoosePlugin;
+exports.patchKafkaJs = patchKafkaJs;
+exports.patchAmqplib = patchAmqplib;
+exports.patchRedis = patchRedis;
+exports.patchPostgreSql = patchPostgreSql;
+exports.patchMongoDb = patchMongoDb;
+exports.patchSendgridMail = patchSendgridMail;
+exports.initRepro = initRepro;
 const mongoose = require("mongoose");
 const async_hooks_1 = require("async_hooks");
 const crypto_1 = require("crypto");
@@ -514,11 +532,9 @@ function setDisabledFunctionTraces(rules) {
     }
     refreshDisabledFunctionTraceRules();
 }
-exports.setDisabledFunctionTraces = setDisabledFunctionTraces;
 function setDisabledFunctionTypes(patterns) {
     disabledFunctionTypePatterns = normalizePatternArray(patterns);
 }
-exports.setDisabledFunctionTypes = setDisabledFunctionTypes;
 function flattenTraceFilePatterns(config) {
     if (config === null || config === undefined)
         return [];
@@ -541,7 +557,6 @@ function setDisabledTraceFiles(config) {
     const items = Array.isArray(config) ? config : [config];
     disabledTraceFilePatterns = items.flatMap(entry => flattenTraceFilePatterns(entry)).filter(Boolean);
 }
-exports.setDisabledTraceFiles = setDisabledTraceFiles;
 function applyTraceLogPreference(tracer) {
     if (__TRACE_LOG_PREF === null)
         return;
@@ -554,11 +569,8 @@ function setReproTraceLogsEnabled(enabled) {
     __TRACE_LOG_PREF = !!enabled;
     applyTraceLogPreference(__TRACER__);
 }
-exports.setReproTraceLogsEnabled = setReproTraceLogsEnabled;
 function enableReproTraceLogs() { setReproTraceLogsEnabled(true); }
-exports.enableReproTraceLogs = enableReproTraceLogs;
 function disableReproTraceLogs() { setReproTraceLogsEnabled(false); }
-exports.disableReproTraceLogs = disableReproTraceLogs;
 function summarizeEndpointFromEvents(events) {
     let endpointTrace = null;
     let preferredAppTrace = null;
@@ -665,10 +677,8 @@ function initReproTracing(opts) {
     }
     return __TRACER__;
 }
-exports.initReproTracing = initReproTracing;
 /** Optional helper if users want to check it. */
 function isReproTracingEnabled() { return __TRACER_READY; }
-exports.isReproTracingEnabled = isReproTracingEnabled;
 function captureSpanContextFromTracer(source) {
     try {
         // Prefer a preserved store captured at the call-site for thenables (e.g., Mongoose Query),
@@ -3127,7 +3137,6 @@ async function __materializePendingTraceEventsForWorker(payload) {
         __FULL_VALUE_CAPTURE_ENABLED = prevFullValueCapture;
     }
 }
-exports.__materializePendingTraceEventsForWorker = __materializePendingTraceEventsForWorker;
 function sanitizeRequestSnapshot(value) {
     if (value === undefined)
         return undefined;
@@ -5527,7 +5536,6 @@ function reproMiddleware(cfg) {
         }));
     };
 }
-exports.reproMiddleware = reproMiddleware;
 // ===================================================================
 // reproMongoosePlugin — stable + NON-intrusive query logs
 //   - NO prototype monkey-patching of Mongoose
@@ -5937,7 +5945,6 @@ function reproMongoosePlugin(cfg) {
         });
     };
 }
-exports.reproMongoosePlugin = reproMongoosePlugin;
 function summarizeQueryResult(op, res) {
     const resultPreview = sanitizeResultForMeta(res, { preserveLongStrings: true });
     if (op === 'find' ||
@@ -7504,7 +7511,6 @@ function patchKafkaJs(cfg) {
         }
     }
 }
-exports.patchKafkaJs = patchKafkaJs;
 const AMQP_INTERNAL_PUBLISH_DEPTH = Symbol.for('repro.amqplib.internalPublishDepth');
 function decodeAmqpHeaderValue(value) {
     if (value === null || value === undefined)
@@ -7870,7 +7876,7 @@ function scheduleAmqpPublishCapture(params) {
             url: params.path,
             path: params.path,
             status: params.status,
-            durMs: Date.now() - params.t0,
+            durMs: params.durationMs,
             key: params.key,
             headers: {
                 transport: 'amqp',
@@ -7890,7 +7896,7 @@ function scheduleAmqpPublishCapture(params) {
             entries: [{
                     actionId: params.aid ?? null,
                     request: requestPayload,
-                    t: alignedNow(),
+                    t: params.completedAt,
                 }],
         });
         post(params.cfg, params.sid, {
@@ -7952,6 +7958,9 @@ function patchAmqplibPublishMethod(channel, cfg, methodName) {
             if (finished)
                 return;
             finished = true;
+            // Capture queue and privacy processing time are not broker latency.
+            const durationMs = Math.max(0, Date.now() - t0);
+            const completedAt = alignedNow();
             scheduleAmqpPublishCapture({
                 cfg,
                 sid,
@@ -7967,7 +7976,8 @@ function patchAmqplibPublishMethod(channel, cfg, methodName) {
                 content,
                 options: nextOptions,
                 span,
-                t0,
+                durationMs,
+                completedAt,
                 status,
                 error,
                 result,
@@ -8100,6 +8110,8 @@ function wrapAmqplibConsumeHandler(onMessage, cfg, queue) {
             finished = true;
             if (!sid)
                 return;
+            const durationMs = Math.max(0, Date.now() - t0);
+            const completedAt = alignedNow();
             const fields = message?.fields ?? {};
             const messagePayload = buildAmqpMessagePayload(message?.content, properties);
             const body = {
@@ -8129,7 +8141,7 @@ function wrapAmqplibConsumeHandler(onMessage, cfg, queue) {
                     url: `amqp://queue/${queueName}`,
                     path: `amqp://queue/${queueName}`,
                     status: threw ? 500 : 200,
-                    durMs: Date.now() - t0,
+                    durMs: durationMs,
                     key: `AMQP_CONSUME ${queueName}`,
                     headers: normalizeAmqpHeadersForPayload(headers),
                     body: bodyMaterialization.value,
@@ -8140,7 +8152,7 @@ function wrapAmqplibConsumeHandler(onMessage, cfg, queue) {
                     entries: [{
                             actionId: aid ?? null,
                             request: requestPayload,
-                            t: alignedNow(),
+                            t: completedAt,
                         }],
                 });
                 scheduleAmqpTraceFlush(cfg, amqpCtx, aid, consumeRid, rawTraceEvents, maskReq, captureScope);
@@ -8304,7 +8316,6 @@ function patchAmqplib(cfg) {
         patchAmqplibModule(amqpModule, cfg);
     }
 }
-exports.patchAmqplib = patchAmqplib;
 const redisPatchConfigs = [];
 let redisRequireHookInstalled = false;
 const REDIS_KEYLESS_COMMANDS = new Set([
@@ -8594,7 +8605,6 @@ function patchRedis(cfg) {
         patchRedisFromModuleExports(redisModule, cfg);
     }
 }
-exports.patchRedis = patchRedis;
 const postgresSqlPatchConfigs = [];
 const postgresSqlSourceAls = new async_hooks_1.AsyncLocalStorage();
 const pgPoolQueryAls = new async_hooks_1.AsyncLocalStorage();
@@ -9152,7 +9162,6 @@ function patchPostgreSql(cfg) {
     for (const loaded of typeOrmModules)
         patchTypeOrmFromModuleExports(loaded);
 }
-exports.patchPostgreSql = patchPostgreSql;
 const mongoDbPatchConfigs = [];
 let mongoDbRequireHookInstalled = false;
 let mongoDbImportHookInstalled = false;
@@ -9735,7 +9744,6 @@ function patchMongoDb(cfg) {
         patchMongoDbFromModuleExports(mongoModule, cfg);
     }
 }
-exports.patchMongoDb = patchMongoDb;
 // ===================================================================
 // Auto init helpers
 // ===================================================================
@@ -10203,7 +10211,6 @@ function patchSendgridMail(cfg) {
         }
     }
 }
-exports.patchSendgridMail = patchSendgridMail;
 /**
  * Datadog-style one-time init.
  * Enables tracing, auto-patches integrations, auto-registers mongoose plugin,
@@ -10251,7 +10258,6 @@ async function initRepro(cfg) {
     enqueueRuntimeServiceRegistration(reproAutoMiddlewareConfig);
     await initializeRuntimePrivacyPolicyAtStartup(reproAutoMiddlewareConfig);
 }
-exports.initRepro = initRepro;
 /** @internal Test hooks for runtime privacy policy wiring. */
 exports.__reproTestHooks = {
     shareRuntimePrivacyStateForTest: shareRuntimePrivacyState,

package/dist/ingest/client.d.ts

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

package/dist/integrations/sendgrid.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.patchSendgridMail = exports.getCtx = void 0;
+exports.getCtx = void 0;
+exports.patchSendgridMail = patchSendgridMail;
 // repro-node/src/integrations/sendgrid.ts
 const async_hooks_1 = require("async_hooks");
 const client_1 = require("../ingest/client");
@@ -164,4 +165,3 @@ function patchSendgridMail(cfg) {
         return undefined;
     }
 }
-exports.patchSendgridMail = patchSendgridMail;

package/dist/live-capture-limits.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.limitLiveArguments = exports.collectCaptureOmissions = exports.limitLiveCapture = exports.LIVE_CAPTURE_LIMITS = void 0;
+exports.LIVE_CAPTURE_LIMITS = void 0;
+exports.limitLiveCapture = limitLiveCapture;
+exports.collectCaptureOmissions = collectCaptureOmissions;
+exports.limitLiveArguments = limitLiveArguments;
 const http_1 = require("http");
 const semantic_serialization_1 = require("./semantic-serialization");
 exports.LIVE_CAPTURE_LIMITS = Object.freeze({ maxDepth: 10, maxKeys: 100, maxEntries: 100 });
@@ -170,7 +173,6 @@ function limitLiveCapture(value, rootPath = '$') {
         return { value: omit({ reason: 'uninspectable', path: rootPath, capturedCount: 0 }), omissions };
     }
 }
-exports.limitLiveCapture = limitLiveCapture;
 function collectCaptureOmissions(value) {
     const result = [];
     const seen = new WeakSet();
@@ -193,7 +195,6 @@ function collectCaptureOmissions(value) {
     }
     return result;
 }
-exports.collectCaptureOmissions = collectCaptureOmissions;
 function limitLiveArguments(args) {
     const values = args.slice(0, 100).map((arg, index) => limitLiveCapture(arg, `$[${index}]`).value);
     if (args.length > 100) {
@@ -204,4 +205,3 @@ function limitLiveArguments(args) {
     }
     return values;
 }
-exports.limitLiveArguments = limitLiveArguments;

package/dist/privacy-fallback.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitizeUnknownBoundaryTextWithDetectors = void 0;
+exports.sanitizeUnknownBoundaryTextWithDetectors = sanitizeUnknownBoundaryTextWithDetectors;
 const SANITIZED_TEXT_CACHE = new Map();
 const SANITIZED_TEXT_CACHE_MAX = 500;
 async function sanitizeUnknownBoundaryTextWithDetectors(value) {
@@ -14,7 +14,6 @@ async function sanitizeUnknownBoundaryTextWithDetectors(value) {
     rememberSanitizedText(value, value);
     return value;
 }
-exports.sanitizeUnknownBoundaryTextWithDetectors = sanitizeUnknownBoundaryTextWithDetectors;
 function rememberSanitizedText(input, output) {
     SANITIZED_TEXT_CACHE.set(input, output);
     if (SANITIZED_TEXT_CACHE.size <= SANITIZED_TEXT_CACHE_MAX) {

package/dist/privacy-redaction.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectEmailsInText = exports.redactEmailsInText = exports.redactEmailDeterministic = void 0;
+exports.redactEmailDeterministic = redactEmailDeterministic;
+exports.redactEmailsInText = redactEmailsInText;
+exports.collectEmailsInText = collectEmailsInText;
 const crypto_1 = require("crypto");
 const EMAIL_PATTERN = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
 const EMAIL_TOKEN_PREFIX = 'email_tok_';
@@ -13,14 +15,12 @@ function redactEmailDeterministic(value) {
     const token = (0, crypto_1.createHash)('sha256').update(normalized).digest('hex').slice(0, EMAIL_TOKEN_LENGTH);
     return `${EMAIL_TOKEN_PREFIX}${token}`;
 }
-exports.redactEmailDeterministic = redactEmailDeterministic;
 function redactEmailsInText(value) {
     if (!value) {
         return value;
     }
     return value.replace(EMAIL_PATTERN, (match) => isAlreadyMaskedEmail(match) ? match : redactEmailDeterministic(match));
 }
-exports.redactEmailsInText = redactEmailsInText;
 function collectEmailsInText(value) {
     if (!value) {
         return [];
@@ -28,7 +28,6 @@ function collectEmailsInText(value) {
     const matches = value.match(EMAIL_PATTERN);
     return Array.isArray(matches) ? matches : [];
 }
-exports.collectEmailsInText = collectEmailsInText;
 function isAlreadyMaskedEmail(value) {
     if (/^email_tok_[a-z0-9]+$/i.test(value)) {
         return true;

package/dist/privacy.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyRuntimePrivacyPolicyAsync = exports.applyRuntimePrivacyPolicy = exports.normalizeRuntimePrivacyPolicy = exports.fetchApprovedRuntimePrivacyPolicy = exports.resolvePrivacyApiBase = exports.normalizePrivacyEnvironment = exports.clearRuntimePrivacyProvenance = void 0;
+exports.clearRuntimePrivacyProvenance = clearRuntimePrivacyProvenance;
+exports.normalizePrivacyEnvironment = normalizePrivacyEnvironment;
+exports.resolvePrivacyApiBase = resolvePrivacyApiBase;
+exports.fetchApprovedRuntimePrivacyPolicy = fetchApprovedRuntimePrivacyPolicy;
+exports.normalizeRuntimePrivacyPolicy = normalizeRuntimePrivacyPolicy;
+exports.applyRuntimePrivacyPolicy = applyRuntimePrivacyPolicy;
+exports.applyRuntimePrivacyPolicyAsync = applyRuntimePrivacyPolicyAsync;
 const crypto_1 = require("crypto");
 const capture_work_budget_1 = require("./capture-work-budget");
 const privacy_fallback_1 = require("./privacy-fallback");
@@ -21,7 +27,6 @@ function clearRuntimePrivacyProvenance() {
     objectRuntimePrivacyProvenance = new WeakMap();
     serializedRuntimePrivacyProvenance.clear();
 }
-exports.clearRuntimePrivacyProvenance = clearRuntimePrivacyProvenance;
 const ALL_SURFACES = [
     'db.pk',
     'db.before',
@@ -79,7 +84,6 @@ function normalizePrivacyEnvironment(input) {
         return 'qa';
     return normalized || 'dev';
 }
-exports.normalizePrivacyEnvironment = normalizePrivacyEnvironment;
 function resolvePrivacyApiBase(cfg) {
     const value = cfg?.apiBase ||
         process.env.REPRO_PRIVACY_API_BASE ||
@@ -90,7 +94,6 @@ function resolvePrivacyApiBase(cfg) {
     }
     return String(value).replace(/\/+$/, '');
 }
-exports.resolvePrivacyApiBase = resolvePrivacyApiBase;
 const DEFAULT_RUNTIME_PRIVACY_FETCH_TIMEOUT_MS = 10000;
 function resolveRuntimePrivacyFetchTimeoutMs(value) {
     if (!Number.isFinite(value)) {
@@ -162,7 +165,6 @@ async function fetchApprovedRuntimePrivacyPolicy(params) {
         }
     }
 }
-exports.fetchApprovedRuntimePrivacyPolicy = fetchApprovedRuntimePrivacyPolicy;
 function normalizeRuntimePrivacyPolicy(raw) {
     if (!raw || typeof raw !== 'object') {
         return null;
@@ -189,21 +191,18 @@ function normalizeRuntimePrivacyPolicy(raw) {
     runtimePrivacyStatementIndexes.set(normalizedPolicy, buildRuntimePrivacyStatementIndex(statements));
     return normalizedPolicy;
 }
-exports.normalizeRuntimePrivacyPolicy = normalizeRuntimePrivacyPolicy;
 function applyRuntimePrivacyPolicy(policy, surface, value, context) {
     if (value === undefined) {
         return value;
     }
     return transformValue(policy ?? EMPTY_RUNTIME_PRIVACY_POLICY, surface, value, context, []);
 }
-exports.applyRuntimePrivacyPolicy = applyRuntimePrivacyPolicy;
 async function applyRuntimePrivacyPolicyAsync(policy, surface, value, context) {
     if (value === undefined) {
         return value;
     }
     return transformValueAsync(policy ?? EMPTY_RUNTIME_PRIVACY_POLICY, surface, value, context, []);
 }
-exports.applyRuntimePrivacyPolicyAsync = applyRuntimePrivacyPolicyAsync;
 function flattenStatements(policy) {
     const fromGroups = Array.isArray(policy.groups)
         ? policy.groups.flatMap((group) => Array.isArray(group?.statements) ? group.statements : [])

package/dist/semantic-serialization.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectSemanticInfrastructureValue = exports.mongooseDocumentData = void 0;
+exports.mongooseDocumentData = mongooseDocumentData;
+exports.projectSemanticInfrastructureValue = projectSemanticInfrastructureValue;
 function constructorName(value) {
     if (!value || typeof value !== 'object')
         return '';
@@ -55,7 +56,6 @@ function mongooseDocumentData(value) {
         return null;
     return method(value, '$__init') && method(value, '$toObject') ? doc : null;
 }
-exports.mongooseDocumentData = mongooseDocumentData;
 function primitiveStateValue(value) {
     if (value === null)
         return null;
@@ -200,4 +200,3 @@ function projectSemanticInfrastructureValue(value) {
         projectPostgres(value, className) ||
         projectTypeOrm(value, className));
 }
-exports.projectSemanticInfrastructureValue = projectSemanticInfrastructureValue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.54",
+  "version": "0.0.56",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,6 +13,7 @@
     "test:latency": "npm run build && node test/privacy-fetch-timeout.test.js && node test/capture-latency.testcontainers.test.js",
     "test:live-capture": "npm run build && node test/twelve-element-capture.testcontainers.test.js && node test/live-capture-limits.test.js && node test/ingest-throttle-retention.test.js && node test/live-capture-limits.testcontainers.test.js",
     "test:live-brokers": "npm run build && node test/live-broker-limits.testcontainers.test.js",
+    "test:amqp-timing": "npm run build && node test/amqplib-integration.test.js && node test/amqplib-timing.testcontainers.test.js",
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
     "prepublishOnly": "npm run build",
@@ -24,6 +25,7 @@
     "mongoose": ">=6"
   },
   "devDependencies": {
+    "typescript": "^5.7.3",
     "@nestjs/typeorm": "^11.0.0",
     "@testcontainers/kafka": "^11.8.1",
     "@types/express": "^5.0.3",

package/src/index.ts

@@ -9498,7 +9498,8 @@ function scheduleAmqpPublishCapture(params: {
     content: any;
     options: any;
     span: SpanContext | null;
-    t0: number;
+    durationMs: number;
+    completedAt: number;
     status: number;
     error?: any;
     result?: any;
@@ -9540,7 +9541,7 @@ function scheduleAmqpPublishCapture(params: {
             url: params.path,
             path: params.path,
             status: params.status,
-            durMs: Date.now() - params.t0,
+            durMs: params.durationMs,
             key: params.key,
             headers: {
                 transport: 'amqp',
@@ -9561,7 +9562,7 @@ function scheduleAmqpPublishCapture(params: {
             entries: [{
                 actionId: params.aid ?? null,
                 request: requestPayload,
-                t: alignedNow(),
+                t: params.completedAt,
             }],
         });
         post(params.cfg, params.sid!, {
@@ -9634,6 +9635,9 @@ function patchAmqplibPublishMethod(
         const finish = (status: number, error?: any, result?: any) => {
             if (finished) return;
             finished = true;
+            // Capture queue and privacy processing time are not broker latency.
+            const durationMs = Math.max(0, Date.now() - t0);
+            const completedAt = alignedNow();
             scheduleAmqpPublishCapture({
                 cfg,
                 sid,
@@ -9649,7 +9653,8 @@ function patchAmqplibPublishMethod(
                 content,
                 options: nextOptions,
                 span,
-                t0,
+                durationMs,
+                completedAt,
                 status,
                 error,
                 result,
@@ -9779,6 +9784,8 @@ function wrapAmqplibConsumeHandler(onMessage: any, cfg: AmqplibPatchConfig, queu
             if (finished) return;
             finished = true;
             if (!sid) return;
+            const durationMs = Math.max(0, Date.now() - t0);
+            const completedAt = alignedNow();
             const fields = message?.fields ?? {};
             const messagePayload = buildAmqpMessagePayload(message?.content, properties);
             const body = {
@@ -9814,7 +9821,7 @@ function wrapAmqplibConsumeHandler(onMessage: any, cfg: AmqplibPatchConfig, queu
                     url: `amqp://queue/${queueName}`,
                     path: `amqp://queue/${queueName}`,
                     status: threw ? 500 : 200,
-                    durMs: Date.now() - t0,
+                    durMs: durationMs,
                     key: `AMQP_CONSUME ${queueName}`,
                     headers: normalizeAmqpHeadersForPayload(headers),
                     body: bodyMaterialization.value,
@@ -9826,7 +9833,7 @@ function wrapAmqplibConsumeHandler(onMessage: any, cfg: AmqplibPatchConfig, queu
                     entries: [{
                         actionId: aid ?? null,
                         request: requestPayload,
-                        t: alignedNow(),
+                        t: completedAt,
                     }],
                 });
                 scheduleAmqpTraceFlush(cfg, amqpCtx, aid, consumeRid, rawTraceEvents, maskReq, captureScope);

package/test/amqplib-timing.testcontainers.test.js

@@ -0,0 +1,198 @@
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+process.env.TRACE_IDLE_FLUSH_MS = '0';
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const { once } = require('node:events');
+const { GenericContainer, Wait } = require('testcontainers');
+const amqp = require('amqplib');
+const { __reproTestHooks: hooks } = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+const deferred = () => {
+    let resolve;
+    const promise = new Promise(done => { resolve = done; });
+    return { promise, resolve };
+};
+async function within(promise, label) {
+    let timer;
+    try {
+        return await Promise.race([promise, new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`Timed out: ${label}`)), 10000);
+        })]);
+    } finally { clearTimeout(timer); }
+}
+
+async function main() {
+    const events = [], channels = [];
+    let rabbit, connection, release;
+    const sink = http.createServer(async (req, res) => {
+        const buffers = [];
+        for await (const chunk of req) buffers.push(chunk);
+        events.push(...(JSON.parse(Buffer.concat(buffers)).events || []));
+        res.writeHead(202); res.end('{}');
+    });
+    sink.listen(0, '127.0.0.1'); await once(sink, 'listening');
+    try {
+        rabbit = await new GenericContainer('rabbitmq:3.13-alpine')
+            .withEnvironment({ RABBITMQ_DEFAULT_USER: 'repro', RABBITMQ_DEFAULT_PASS: 'test' })
+            .withExposedPorts(5672).withWaitStrategy(Wait.forLogMessage('Server startup complete')).start();
+        connection = await amqp.connect(`amqp://repro:test@${rabbit.getHost()}:${rabbit.getMappedPort(5672)}`);
+        for (const mode of ['live', 'staging']) {
+            const sid = `S_amqp_timing_${mode}`;
+            const cfg = { tenantId: 'TENANT_timing', appId: 'APP_timing', appSecret: 'test',
+                privacy: { captureRaw: true, environment: 'dev' },
+                ingestBase: `http://127.0.0.1:${sink.address().port}`,
+                resolveContext: () => ({ sid, aid: `A_${mode}` }) };
+            const channel = await connection.createConfirmChannel(); channels.push(channel);
+            hooks.patchAmqplibChannelForTest(channel, cfg);
+            const queue = `timing-${mode}`;
+            await channel.assertQueue(queue, { durable: false });
+            const handled = deferred(), acknowledged = deferred(), gate = deferred(), started = deferred();
+            release = gate.resolve;
+            // Hold the real capture queue, not the broker or application callback.
+            hooks.scheduleSdkBackgroundWorkForTest(async () => {
+                started.resolve(); await gate.promise;
+            }, { priority: 'high' });
+            await within(started.promise, 'capture queue blocker');
+            let handlerStart, handlerEnd, publishEnd;
+            const input = { orderId: `order-${mode}`, lines: [{ sku: 'item', quantity: 3 }] };
+            const consumer = await channel.consume(queue, async message => {
+                handlerStart = Date.now();
+                assert.deepEqual(JSON.parse(message.content.toString()), input);
+                assert.equal(message.properties.headers['x-bug-session-id'], sid);
+                assert.equal(message.properties.headers['x-repro-capture-mode'], mode);
+                await sleep(60);
+                channel.ack(message);
+                handlerEnd = Date.now(); handled.resolve();
+            });
+            const publishStart = Date.now();
+            const options = { headers: { 'x-repro-capture-mode': mode }, persistent: false };
+            const result = hooks.runWithRequestContextForTest({ sid, aid: `A_${mode}`, captureScope: { liveCapture: mode === 'live' } },
+                () => channel.sendToQueue(queue, Buffer.from(JSON.stringify(input)), options, error => {
+                    assert.ifError(error); publishEnd = Date.now(); acknowledged.resolve();
+                }));
+            assert.equal(typeof result, 'boolean', 'publish must preserve amqplib backpressure contract');
+            await within(Promise.all([handled.promise, acknowledged.promise]), 'broker confirm and consumer acknowledgement');
+            assert.equal(options.headers['x-bug-session-id'], undefined, 'caller options stay unchanged');
+            assert.equal(events.filter(e => e.session_id === sid && e.event_type === 'backend_request').length, 0);
+            await sleep(450);
+            const releasedAt = Date.now(); gate.resolve(); release = null;
+            const deadline = Date.now() + 10000;
+            let requests;
+            do {
+                await hooks.drainSdkBackgroundQueueForTest(); await flushIngestQueue();
+                requests = events.filter(e => e.session_id === sid && e.event_type === 'backend_request');
+                if (requests.length === 2) break;
+                await sleep(20);
+            } while (Date.now() < deadline);
+            assert.equal(requests.length, 2, 'exactly one publish and one consume, despite sendToQueue delegating to publish');
+            for (const [method, start, end] of [
+                ['AMQP_SEND_TO_QUEUE', publishStart, publishEnd],
+                ['AMQP_CONSUME', handlerStart, handlerEnd],
+            ]) {
+                const event = requests.find(e => e.payload.request.method === method);
+                assert(event, `${mode}: missing ${method}`);
+                const request = event.payload.request;
+                assert(request.durMs <= end - start + 30,
+                    `${mode} ${method}: ${request.durMs}ms includes capture queue time; business took ${end - start}ms`);
+                assert(request.durMs >= end - start - 10, 'duration must still include the async business handler');
+                const timestamp = Date.parse(event.event_ts);
+                assert(timestamp <= end + 30 && timestamp >= start,
+                    `event time must be operation completion, not background delivery: ${timestamp}, ${end}`);
+                assert(timestamp < releasedAt - 400);
+                assert.deepEqual(request.body.value, input, 'timing correction must not lose payload');
+            }
+            await channel.cancel(consumer.consumerTag);
+            console.log(`${mode}: broker confirms and async handler finish before capture drain; timings and payload exact`);
+        }
+        // Exercise failure/return contracts with real delivered envelopes. The
+        // adapter catches deliberate handler failures just as an application would.
+        const sid = 'S_amqp_failures';
+        const cfg = { tenantId: 'TENANT_timing', appId: 'APP_timing', appSecret: 'test',
+            privacy: { captureRaw: true, environment: 'dev' },
+            ingestBase: `http://127.0.0.1:${sink.address().port}`,
+            resolveContext: () => ({ sid, aid: 'A_failures' }) };
+        const raw = await connection.createChannel(); channels.push(raw);
+        await raw.assertQueue('timing-contracts', { durable: false });
+        const gate = deferred(), started = deferred(); release = gate.resolve;
+        hooks.scheduleSdkBackgroundWorkForTest(async () => { started.resolve(); await gate.promise; }, { priority: 'high' });
+        await within(started.promise, 'failure capture queue blocker');
+        const observations = new Map(), completed = deferred();
+        const identity = { result: 'unchanged' }, failure = new Error('application failure');
+        const wrapped = hooks.wrapAmqplibConsumeHandlerForTest(message => {
+            const { scenario } = JSON.parse(message.content.toString());
+            const observation = { start: Date.now(), calls: 1, scenario };
+            observations.set(scenario, observation);
+            const finish = () => {
+                observation.end = Date.now();
+                if (scenario.endsWith('error')) throw failure;
+                return identity;
+            };
+            return scenario.startsWith('async') ? sleep(60).then(finish) : finish();
+        }, cfg, 'timing-contracts');
+        let handled = 0;
+        const consumer = await raw.consume('timing-contracts', message => {
+            const { scenario } = JSON.parse(message.content.toString());
+            const complete = () => { raw.ack(message); if (++handled === 4) completed.resolve(); };
+            try {
+                const value = wrapped(message);
+                if (scenario.startsWith('async')) {
+                    assert.equal(typeof value.then, 'function');
+                    value.then(result => {
+                        assert.strictEqual(result, identity); complete();
+                    }, error => { assert.strictEqual(error, failure); complete(); });
+                } else { assert.strictEqual(value, identity); complete(); }
+            } catch (error) { assert.strictEqual(error, failure); complete(); }
+        });
+        for (const scenario of ['sync-success', 'async-success', 'sync-error', 'async-error']) {
+            raw.sendToQueue('timing-contracts', Buffer.from(JSON.stringify({ scenario })), { headers: {
+                'x-bug-session-id': sid, 'x-bug-action-id': 'A_failures', 'x-repro-capture-mode': 'live',
+            } });
+        }
+        await within(completed.promise, 'handler return and error contracts');
+        const invalid = await connection.createConfirmChannel(); channels.push(invalid);
+        invalid.on('error', () => {});
+        hooks.patchAmqplibChannelForTest(invalid, cfg);
+        const rejected = deferred();
+        const rejectStart = Date.now(); let rejectEnd;
+        invalid.publish('missing-exchange-timing', 'route', Buffer.from('message'), {}, error => {
+            assert(error, 'broker must reject the nonexistent exchange');
+            rejectEnd = Date.now(); rejected.resolve();
+        });
+        await within(rejected.promise, 'broker rejection');
+        await sleep(450); gate.resolve(); release = null;
+        const deadline = Date.now() + 10000;
+        let requests;
+        do {
+            await hooks.drainSdkBackgroundQueueForTest(); await flushIngestQueue();
+            requests = events.filter(e => e.session_id === sid && e.event_type === 'backend_request');
+            if (requests.length === 5) break;
+            await sleep(20);
+        } while (Date.now() < deadline);
+        assert.equal(requests.length, 5, 'no retries/double captures on exceptions or broker channel close');
+        for (const event of requests) {
+            const request = event.payload.request;
+            const observation = request.method === 'AMQP_PUBLISH'
+                ? { start: rejectStart, end: rejectEnd, scenario: 'broker-error' }
+                : observations.get(request.body.value.scenario);
+            assert(observation);
+            assert.equal(request.status, observation.scenario.endsWith('error') ? 500 : 200);
+            assert(request.durMs <= observation.end - observation.start + 30);
+            assert(Date.parse(event.event_ts) <= observation.end + 30);
+        }
+        await raw.cancel(consumer.consumerTag);
+        console.log('sync/async return and error identity preserved; broker rejection and failure timestamps exclude capture drain');
+    } finally {
+        release?.();
+        for (const channel of channels) await channel.close().catch(() => {});
+        if (connection) await connection.close();
+        await hooks.drainSdkBackgroundQueueForTest(); await flushIngestQueue();
+        sink.closeAllConnections(); await new Promise(resolve => sink.close(resolve));
+        if (rabbit) await rabbit.stop();
+    }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/test/capture-latency.testcontainers.test.js

@@ -25,7 +25,9 @@ async function main() {
     const results = [];
     try {
         mongo = await new GenericContainer('mongo:7').withExposedPorts(27017).withWaitStrategy(Wait.forListeningPorts()).start();
-        for (const variant of ['off', 'live-raw', 'staging-raw', 'live-policy', 'staging-policy', 'live-policy-fallback', 'staging-policy-fallback', 'staging-policy-fault']) {
+        const variants = ['off', 'live-raw', 'staging-raw', 'live-policy', 'staging-policy', 'live-policy-fallback', 'staging-policy-fallback', 'staging-policy-fault']
+            .filter(variant => !process.argv.includes('--raw-only') || !variant.includes('policy'));
+        for (const variant of variants) {
             const mode = variant.split('-')[0];
             child = fork(require.resolve('./fixtures/capture-latency-server'), [], {
                 env: { ...process.env, CAPTURE_TEST_MODE: mode,