@reproapp/node-sdk 0.0.54 → 0.0.55

package/dist/index.js

@@ -7870,7 +7870,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 +7890,7 @@ function scheduleAmqpPublishCapture(params) {
             entries: [{
                     actionId: params.aid ?? null,
                     request: requestPayload,
-                    t: alignedNow(),
+                    t: params.completedAt,
                 }],
         });
         post(params.cfg, params.sid, {
@@ -7952,6 +7952,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 +7970,8 @@ function patchAmqplibPublishMethod(channel, cfg, methodName) {
                 content,
                 options: nextOptions,
                 span,
-                t0,
+                durationMs,
+                completedAt,
                 status,
                 error,
                 result,
@@ -8100,6 +8104,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 +8135,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 +8146,7 @@ function wrapAmqplibConsumeHandler(onMessage, cfg, queue) {
                     entries: [{
                             actionId: aid ?? null,
                             request: requestPayload,
-                            t: alignedNow(),
+                            t: completedAt,
                         }],
                 });
                 scheduleAmqpTraceFlush(cfg, amqpCtx, aid, consumeRid, rawTraceEvents, maskReq, captureScope);

package/package.json

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

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,