@reproapp/node-sdk 0.0.23 → 0.0.25

package/src/ingest/client.ts

@@ -211,9 +211,9 @@ export const enqueueIngestEntries = (
     sessionId: string,
     entries: LegacyEntry[],
     options: EnqueueIngestOptions = {},
-): void => {
+): boolean => {
     if (!sessionId || !Array.isArray(entries) || entries.length === 0) {
-        return;
+        return false;
     }
     const priority = options.priority === 'high' ? 'high' : 'normal';
     const batch: QueuedIngestBatch = {
@@ -246,6 +246,7 @@ export const enqueueIngestEntries = (
         }
     }
     scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
+    return ingestQueue.includes(batch);
 };
 
 export const flushIngestQueue = async (): Promise<void> => {

package/test/amqplib-integration.test.js

@@ -0,0 +1,340 @@
+process.env.REPRO_INGEST_REQUEST_TIMEOUT_MS = '50';
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '25';
+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 = '10';
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+
+const assert = require('assert');
+const { flushIngestQueue } = require('../dist/ingest/client');
+const { initReproTracing, __reproTestHooks } = require('../dist');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitFor(predicate, timeoutMs = 2000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate()) return;
+        await sleep(20);
+    }
+    assert(predicate(), 'timed out waiting for expected ingest payload');
+}
+
+function flattenEvents(posts) {
+    return posts.flatMap((body) => Array.isArray(body?.events) ? body.events : []);
+}
+
+async function drainSdk() {
+    await __reproTestHooks.drainSdkBackgroundQueueForTest();
+    await flushIngestQueue();
+}
+
+async function withCapturedFetch(fn) {
+    const capturedBodies = [];
+    const originalFetch = global.fetch;
+    global.fetch = async (_url, init) => {
+        capturedBodies.push(JSON.parse(String(init?.body ?? '{}')));
+        return {
+            ok: true,
+            status: 202,
+            json: async () => ({ ok: true }),
+            text: async () => '{"ok":true}',
+        };
+    };
+
+    try {
+        await fn(capturedBodies);
+    } finally {
+        await drainSdk();
+        global.fetch = originalFetch;
+    }
+}
+
+function makeConfig(sessionId, actionId) {
+    return {
+        tenantId: 'TENANT_test',
+        appId: 'APP_test',
+        appSecret: 'secret',
+        captureHeaders: false,
+        privacy: { environment: 'dev' },
+        ingestBase: 'http://127.0.0.1:65535',
+        resolveContext: () => ({ sid: sessionId, aid: actionId }),
+    };
+}
+
+async function testPublishInjectsHeadersWithoutMutatingOptions() {
+    await withCapturedFetch(async (capturedBodies) => {
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        let observedPublish = null;
+        const channel = {
+            publish(exchange, routingKey, content, options) {
+                observedPublish = { exchange, routingKey, content, options };
+                return false;
+            },
+        };
+        const cfg = makeConfig('S_amqp_publish', 'A_amqp_publish');
+        __reproTestHooks.patchAmqplibChannelForTest(channel, cfg);
+
+        const originalOptions = {
+            contentType: 'application/json',
+            persistent: true,
+            headers: { existing: 'yes' },
+        };
+        const result = channel.publish(
+            'orders',
+            'created',
+            Buffer.from(JSON.stringify({ orderId: 'ord-1', status: 'created' })),
+            originalOptions,
+        );
+
+        assert.strictEqual(result, false);
+        assert(observedPublish, 'expected original publish to run');
+        assert.notStrictEqual(observedPublish.options, originalOptions);
+        assert.strictEqual(originalOptions.headers['x-bug-session-id'], undefined);
+        assert.strictEqual(originalOptions.headers['x-repro-request-rid'], undefined);
+        assert.strictEqual(observedPublish.options.headers.existing, 'yes');
+        assert.strictEqual(observedPublish.options.headers['x-bug-session-id'], 'S_amqp_publish');
+        assert.strictEqual(observedPublish.options.headers['x-bug-action-id'], 'A_amqp_publish');
+        assert(observedPublish.options.headers['x-repro-request-rid']);
+
+        await waitFor(() => flattenEvents(capturedBodies)
+            .some((event) => event?.event_type === 'backend_request'));
+        await drainSdk();
+
+        const events = flattenEvents(capturedBodies);
+        const requestEvent = events.find((event) => event?.event_type === 'backend_request');
+        assert(requestEvent, 'expected AMQP publish backend request');
+        assert.strictEqual(requestEvent.payload.request.method, 'AMQP_PUBLISH');
+        assert.strictEqual(requestEvent.payload.request.path, 'amqp://orders/created');
+        assert.strictEqual(requestEvent.payload.request.headers.transport, 'amqp');
+        assert.strictEqual(requestEvent.payload.request.headers.backpressure, true);
+        assert.strictEqual(requestEvent.payload.request.body.message.value.orderId, 'ord-1');
+        assert.strictEqual(requestEvent.payload.request.body.message.value.status, 'created');
+        assert.strictEqual(requestEvent.payload.request.body.message.headers.existing, 'yes');
+
+        const manifestEvent = events.find((event) => event?.event_type === 'request_capture_manifest');
+        assert(manifestEvent, 'expected AMQP publish manifest');
+        assert.strictEqual(manifestEvent.payload.requestCaptureManifest.transport, 'amqp');
+        assert.strictEqual(manifestEvent.payload.requestCaptureManifest.expected.backendRequest, 1);
+        assert.strictEqual(manifestEvent.payload.requestCaptureManifest.expected.traceBatch, 0);
+    });
+}
+
+async function testConsumeCapturesRequestTraceAndManifest() {
+    await withCapturedFetch(async (capturedBodies) => {
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        const tracer = initReproTracing({ instrument: false, functionLogs: false });
+        let registeredHandler = null;
+        const channel = {
+            consume(queue, onMessage, options) {
+                registeredHandler = { queue, onMessage, options };
+                return Promise.resolve({ consumerTag: 'consumer-1' });
+            },
+        };
+        const cfg = makeConfig('S_unused_fallback', 'A_unused_fallback');
+        __reproTestHooks.patchAmqplibChannelForTest(channel, cfg);
+
+        const consumeResult = await channel.consume('jobs', async () => {
+            tracer.tracer.enter('amqpConsumerWork', { file: '/app/consumer.ts', line: 11 }, { args: ['ok'] });
+            tracer.tracer.exit(
+                { fn: 'amqpConsumerWork', file: '/app/consumer.ts', line: 11 },
+                { returnValue: 'done' },
+            );
+
+            tracer.withTrace('parent-amqp-trace', () => {
+                tracer.tracer.enter('parentHttpWork', { file: '/app/controller.ts', line: 20 }, { args: ['wrong'] });
+                tracer.tracer.exit(
+                    { fn: 'parentHttpWork', file: '/app/controller.ts', line: 20 },
+                    { returnValue: 'wrong' },
+                );
+            });
+
+            return 'handled';
+        }, { noAck: false });
+
+        assert.deepStrictEqual(consumeResult, { consumerTag: 'consumer-1' });
+        assert(registeredHandler, 'expected consume callback registration');
+        assert.strictEqual(registeredHandler.queue, 'jobs');
+        assert.deepStrictEqual(registeredHandler.options, { noAck: false });
+
+        const handlerResult = await registeredHandler.onMessage({
+            fields: {
+                consumerTag: 'consumer-1',
+                deliveryTag: 7,
+                exchange: 'orders',
+                routingKey: 'created',
+                redelivered: false,
+            },
+            properties: {
+                contentType: 'application/json',
+                messageId: 'msg-1',
+                correlationId: 'corr-1',
+                headers: {
+                    'x-bug-session-id': Buffer.from('S_amqp_consume'),
+                    'x-bug-action-id': Buffer.from('A_amqp_consume'),
+                    'x-repro-trace-id': Buffer.from('parent-amqp-trace'),
+                    'x-repro-request-rid': Buffer.from('parent-request-rid'),
+                    'x-repro-span-id': Buffer.from('217'),
+                },
+            },
+            content: Buffer.from(JSON.stringify({
+                eventId: 'evt-amqp-consumed',
+                payload: { marker: 'FULL_AMQP_CONSUMED_VALUE_MARKER' },
+            })),
+        });
+
+        assert.strictEqual(handlerResult, 'handled');
+        await waitFor(() => flattenEvents(capturedBodies)
+            .some((event) => event?.event_type === 'trace_batch'));
+        await drainSdk();
+
+        const events = flattenEvents(capturedBodies);
+        const consumeRequest = events.find((event) => event.event_type === 'backend_request');
+        assert(consumeRequest, 'expected AMQP consume request event');
+        assert.strictEqual(consumeRequest.payload.request.method, 'AMQP_CONSUME');
+        assert.strictEqual(consumeRequest.payload.request.path, 'amqp://queue/jobs');
+        assert.strictEqual(consumeRequest.payload.request.body.parentTraceId, 'parent-amqp-trace');
+        assert.strictEqual(consumeRequest.payload.request.body.parentRequestRid, 'parent-request-rid');
+        assert.strictEqual(consumeRequest.payload.request.body.value.eventId, 'evt-amqp-consumed');
+        assert.strictEqual(
+            consumeRequest.payload.request.body.value.payload.marker,
+            'FULL_AMQP_CONSUMED_VALUE_MARKER',
+        );
+        assert.strictEqual(consumeRequest.payload.request.body.properties.messageId, 'msg-1');
+
+        const traceFns = events
+            .filter((event) => event.event_type === 'trace_batch')
+            .flatMap((event) => Array.isArray(event.payload.trace) ? event.payload.trace : [])
+            .map((traceEvent) => traceEvent.fn);
+        assert(traceFns.includes('amqpConsumerWork'), traceFns.join(','));
+        assert(!traceFns.includes('parentHttpWork'), traceFns.join(','));
+
+        const manifestEvent = events.find((event) => event?.event_type === 'request_capture_manifest');
+        assert(manifestEvent, 'expected AMQP consume manifest');
+        assert.strictEqual(manifestEvent.payload.requestCaptureManifest.transport, 'amqp');
+        assert.strictEqual(manifestEvent.payload.requestCaptureManifest.expected.backendRequest, 1);
+        assert(manifestEvent.payload.requestCaptureManifest.expected.traceBatch >= 1);
+    });
+}
+
+async function testCallbackApiConnectAndConfirmChannelArePatched() {
+    await withCapturedFetch(async (capturedBodies) => {
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        let observedPublish = null;
+        const confirmChannel = {
+            publish(exchange, routingKey, content, options, callback) {
+                observedPublish = { exchange, routingKey, content, options };
+                setImmediate(() => callback(null, { ok: true }));
+                return true;
+            },
+        };
+        const connection = {
+            createConfirmChannel(callback) {
+                callback(null, confirmChannel);
+            },
+        };
+        const amqpModule = {
+            connect(_url, callback) {
+                callback(null, connection);
+            },
+        };
+        const cfg = makeConfig('S_amqp_callback', 'A_amqp_callback');
+        __reproTestHooks.patchAmqplibModuleForTest(amqpModule, cfg);
+
+        const channel = await new Promise((resolve, reject) => {
+            amqpModule.connect('amqp://localhost', (connectError, conn) => {
+                if (connectError) {
+                    reject(connectError);
+                    return;
+                }
+                conn.createConfirmChannel((channelError, ch) => {
+                    if (channelError) reject(channelError);
+                    else resolve(ch);
+                });
+            });
+        });
+
+        await new Promise((resolve, reject) => {
+            channel.publish(
+                'events',
+                'confirmed',
+                Buffer.from('hello'),
+                { headers: { existing: 'yes' } },
+                (error) => {
+                    if (error) reject(error);
+                    else resolve();
+                },
+            );
+        });
+
+        assert(observedPublish, 'expected confirm publish to run');
+        assert.strictEqual(observedPublish.options.headers.existing, 'yes');
+        assert.strictEqual(observedPublish.options.headers['x-bug-session-id'], 'S_amqp_callback');
+        assert.strictEqual(observedPublish.options.headers['x-bug-action-id'], 'A_amqp_callback');
+        assert(observedPublish.options.headers['x-repro-request-rid']);
+
+        await waitFor(() => flattenEvents(capturedBodies)
+            .some((event) => event?.event_type === 'backend_request'));
+        await drainSdk();
+
+        const requestEvent = flattenEvents(capturedBodies)
+            .find((event) => event?.event_type === 'backend_request');
+        assert(requestEvent, 'expected callback API AMQP publish event');
+        assert.strictEqual(requestEvent.payload.request.method, 'AMQP_PUBLISH');
+        assert.strictEqual(requestEvent.payload.request.path, 'amqp://events/confirmed');
+        assert.strictEqual(requestEvent.payload.request.body.message.value, 'hello');
+    });
+}
+
+async function testNullConsumeMessagePassesThrough() {
+    let received = 'not-called';
+    const wrapped = __reproTestHooks.wrapAmqplibConsumeHandlerForTest((message) => {
+        received = message;
+        return 'cancelled';
+    }, makeConfig('S_null', 'A_null'), 'jobs');
+
+    const result = wrapped(null);
+    assert.strictEqual(result, 'cancelled');
+    assert.strictEqual(received, null);
+}
+
+async function testSyncConsumeThrowIsNotRetried() {
+    initReproTracing({ instrument: false, functionLogs: false });
+    let calls = 0;
+    const expectedError = new Error('consume failed once');
+    const wrapped = __reproTestHooks.wrapAmqplibConsumeHandlerForTest(() => {
+        calls += 1;
+        throw expectedError;
+    }, {
+        tenantId: 'TENANT_test',
+        appId: 'APP_test',
+        appSecret: 'secret',
+        captureHeaders: false,
+        privacy: { environment: 'dev' },
+    }, 'jobs');
+
+    assert.throws(() => wrapped({
+        fields: { deliveryTag: 99 },
+        properties: {
+            headers: {
+                'x-repro-trace-id': Buffer.from('parent-trace'),
+            },
+        },
+        content: Buffer.from('hello'),
+    }), expectedError);
+    assert.strictEqual(calls, 1);
+}
+
+async function main() {
+    await testPublishInjectsHeadersWithoutMutatingOptions();
+    await testConsumeCapturesRequestTraceAndManifest();
+    await testCallbackApiConnectAndConfirmChannelArePatched();
+    await testNullConsumeMessagePassesThrough();
+    await testSyncConsumeThrowIsNotRetried();
+    console.log('amqplib integration OK');
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});