@reproapp/node-sdk 0.0.16 → 0.0.18

package/dist/index.js

@@ -1513,10 +1513,10 @@ function resolveCollectionOrWarn(source, type) {
     }
     return name;
 }
-function post(cfg, sessionId, body) {
+function post(cfg, sessionId, body, options) {
     try {
         const entries = Array.isArray(body?.entries) ? body.entries : [];
-        (0, client_1.enqueueIngestEntries)(cfg, sessionId, entries);
+        (0, client_1.enqueueIngestEntries)(cfg, sessionId, entries, options);
     }
     catch { /* swallow in SDK */ }
 }
@@ -3969,6 +3969,7 @@ function reproMiddleware(cfg) {
             let hardStopTimer = null;
             let flushPayload = null;
             let requestCaptureScheduled = false;
+            let requestCaptureManifestScheduled = false;
             let sessionDrainWait = null;
             const activeSpans = new Set();
             let anonymousSpanDepth = 0;
@@ -4232,6 +4233,19 @@ function reproMiddleware(cfg) {
                     // never break user code
                 }
             };
+            const emitRequestCaptureManifest = (traceBatchTotal) => {
+                if (requestCaptureManifestScheduled)
+                    return;
+                requestCaptureManifestScheduled = true;
+                post(cfg, sid, {
+                    entries: [{
+                            actionId: aid,
+                            requestRid: rid,
+                            requestCaptureManifest: buildRequestCaptureManifestPayload(captureScope, traceBatchTotal, finishedAtAligned),
+                            t: finishedAtAligned ?? alignedNow(),
+                        }],
+                }, { priority: 'high' });
+            };
             try {
                 if (__TRACER__?.tracer?.on) {
                     const getTid = __TRACER__?.getCurrentTraceId;
@@ -4328,6 +4342,7 @@ function reproMiddleware(cfg) {
                 void emitRequestCaptureAsync();
                 if (!flushPayload) {
                     flushPayload = async () => {
+                        let traceBatches = [];
                         try {
                             const pendingEvents = preparePendingTraceEventsForFlush(events.slice());
                             const materializedEvents = await materializePendingTraceEventsAsync(pendingEvents, {
@@ -4340,38 +4355,39 @@ function reproMiddleware(cfg) {
                             const orderedEvents = TRACE_ORDER_MODE === 'tree'
                                 ? reorderTraceEvents(baseEvents)
                                 : sortTraceEventsChronologically(baseEvents);
-                            const traceBatches = chunkTraceEventsForTransport(orderedEvents, rid, aid);
+                            traceBatches = chunkTraceEventsForTransport(orderedEvents, rid, aid);
                             if (traceBatches.length) {
                                 captureScope.traceBatchCount = traceBatches.length;
-                                for (let i = 0; i < traceBatches.length; i++) {
-                                    const batch = traceBatches[i];
-                                    const traceValues = collectBatchTraceValueEntries(batch, i);
-                                    post(cfg, sid, {
-                                        entries: [{
-                                                actionId: aid,
-                                                trace: batch,
-                                                traceValues: traceValues.length ? traceValues : undefined,
-                                                traceBatch: {
-                                                    rid,
-                                                    index: i,
-                                                    total: traceBatches.length,
-                                                },
-                                                t: alignedNow(),
-                                            }],
-                                    });
-                                }
                             }
                             else {
                                 captureScope.traceBatchCount = 0;
                             }
-                            post(cfg, sid, {
-                                entries: [{
-                                        actionId: aid,
-                                        requestRid: rid,
-                                        requestCaptureManifest: buildRequestCaptureManifestPayload(captureScope, traceBatches.length, finishedAtAligned),
-                                        t: finishedAtAligned ?? alignedNow(),
-                                    }],
-                            });
+                        }
+                        catch {
+                            captureScope.traceBatchCount = 0;
+                            traceBatches = [];
+                        }
+                        finally {
+                            emitRequestCaptureManifest(traceBatches.length);
+                        }
+                        try {
+                            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

package/dist/ingest/client.d.ts

@@ -1,10 +1,13 @@
 import type { IngestClientConfig, LegacyEntry } from './types';
+export type EnqueueIngestOptions = {
+    priority?: 'normal' | 'high';
+};
 export declare const configureIngestQueueDrain: (options: {
     shouldDefer?: (() => boolean) | null;
     deferMs?: number;
 }) => void;
 export declare const kickIngestQueueDrain: () => void;
 export declare const postIngestEntries: (config: IngestClientConfig, sessionId: string, entries: LegacyEntry[]) => Promise<void>;
-export declare const enqueueIngestEntries: (config: IngestClientConfig, sessionId: string, entries: LegacyEntry[]) => void;
+export declare const enqueueIngestEntries: (config: IngestClientConfig, sessionId: string, entries: LegacyEntry[], options?: EnqueueIngestOptions) => void;
 export declare const flushIngestQueue: () => Promise<void>;
 export type { IngestClientConfig, LegacyEntry } from './types';

package/dist/ingest/client.js

@@ -171,18 +171,41 @@ const drainIngestQueue = async () => {
         }
     }
 };
-const enqueueIngestEntries = (config, sessionId, entries) => {
+const enqueueIngestEntries = (config, sessionId, entries, options = {}) => {
     if (!sessionId || !Array.isArray(entries) || entries.length === 0) {
         return;
     }
-    ingestQueue.push({
+    const priority = options.priority === 'high' ? 'high' : 'normal';
+    const batch = {
         config: { ...config },
         sessionId,
         entries: entries.slice(),
         attempts: 0,
-    });
+        priority,
+    };
+    if (priority === 'high') {
+        const firstNormalIndex = ingestQueue.findIndex((queued) => queued.priority !== 'high');
+        if (firstNormalIndex === -1) {
+            ingestQueue.push(batch);
+        }
+        else {
+            ingestQueue.splice(firstNormalIndex, 0, batch);
+        }
+    }
+    else {
+        ingestQueue.push(batch);
+    }
     if (DEFAULT_QUEUE_MAX_ITEMS > 0 && ingestQueue.length > DEFAULT_QUEUE_MAX_ITEMS) {
-        ingestQueue.splice(0, ingestQueue.length - DEFAULT_QUEUE_MAX_ITEMS);
+        while (ingestQueue.length > DEFAULT_QUEUE_MAX_ITEMS) {
+            let removeIndex = ingestQueue.length - 1;
+            for (let index = ingestQueue.length - 1; index >= 0; index -= 1) {
+                if (ingestQueue[index]?.priority !== 'high') {
+                    removeIndex = index;
+                    break;
+                }
+            }
+            ingestQueue.splice(removeIndex, 1);
+        }
     }
     scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,8 @@
     "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 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"
+    "test": "npm run build && node test/unawaited.test.js && node test/integration-unawaited.js && node test/request-flush-timing.test.js && node test/request-manifest-priority.test.js && node test/runtime-no-double-invoke.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",
+    "test:containers": "npm run build && node test/runtime-no-double-invoke.testcontainers.test.js"
   },
   "peerDependencies": {
     "express": "^5.1.0",

package/src/index.ts

@@ -9,6 +9,7 @@ import {
     configureIngestQueueDrain,
     enqueueIngestEntries,
     kickIngestQueueDrain,
+    type EnqueueIngestOptions,
     type IngestClientConfig,
     type LegacyEntry,
 } from './ingest/client';
@@ -1908,10 +1909,11 @@ function post(
     cfg: IngestClientConfig,
     sessionId: string,
     body: any,
+    options?: EnqueueIngestOptions,
 ) {
     try {
         const entries = Array.isArray(body?.entries) ? (body.entries as LegacyEntry[]) : [];
-        enqueueIngestEntries(cfg, sessionId, entries);
+        enqueueIngestEntries(cfg, sessionId, entries, options);
     } catch { /* swallow in SDK */ }
 }
 
@@ -4856,6 +4858,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
             let hardStopTimer: NodeJS.Timeout | null = null;
             let flushPayload: null | (() => Promise<void>) = null;
             let requestCaptureScheduled = false;
+            let requestCaptureManifestScheduled = false;
             let sessionDrainWait: Promise<void> | null = null;
             const activeSpans = new Set<string>();
             let anonymousSpanDepth = 0;
@@ -5150,6 +5153,23 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                 }
             };
 
+            const emitRequestCaptureManifest = (traceBatchTotal: number): void => {
+                if (requestCaptureManifestScheduled) return;
+                requestCaptureManifestScheduled = true;
+                post(cfg, sid, {
+                    entries: [{
+                        actionId: aid,
+                        requestRid: rid,
+                        requestCaptureManifest: buildRequestCaptureManifestPayload(
+                            captureScope,
+                            traceBatchTotal,
+                            finishedAtAligned,
+                        ),
+                        t: finishedAtAligned ?? alignedNow(),
+                    }],
+                }, { priority: 'high' });
+            };
+
             try {
                 if (__TRACER__?.tracer?.on) {
                     const getTid = __TRACER__?.getCurrentTraceId;
@@ -5250,6 +5270,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
 
                 if (!flushPayload) {
                     flushPayload = async () => {
+                        let traceBatches: TraceEventRecord[][] = [];
                         try {
                             const pendingEvents = preparePendingTraceEventsForFlush(events.slice());
                             const materializedEvents = await materializePendingTraceEventsAsync(pendingEvents, {
@@ -5262,7 +5283,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                             const orderedEvents = TRACE_ORDER_MODE === 'tree'
                                 ? reorderTraceEvents(baseEvents)
                                 : sortTraceEventsChronologically(baseEvents);
-                            const traceBatches = chunkTraceEventsForTransport(
+                            traceBatches = chunkTraceEventsForTransport(
                                 orderedEvents,
                                 rid,
                                 aid,
@@ -5270,40 +5291,36 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
 
                             if (traceBatches.length) {
                                 captureScope.traceBatchCount = traceBatches.length;
-                                for (let i = 0; i < traceBatches.length; i++) {
-                                    const batch = traceBatches[i];
-                                    const traceValues = collectBatchTraceValueEntries(batch, i);
-
-                                    post(cfg, sid, {
-                                        entries: [{
-                                            actionId: aid,
-                                            trace: batch,
-                                            traceValues: traceValues.length ? traceValues : undefined,
-                                            traceBatch: {
-                                                rid,
-                                                index: i,
-                                                total: traceBatches.length,
-                                            },
-                                            t: alignedNow(),
-                                        }],
-                                    });
-                                }
                             } else {
                                 captureScope.traceBatchCount = 0;
                             }
 
-                            post(cfg, sid, {
-                                entries: [{
-                                    actionId: aid,
-                                    requestRid: rid,
-                                    requestCaptureManifest: buildRequestCaptureManifestPayload(
-                                        captureScope,
-                                        traceBatches.length,
-                                        finishedAtAligned,
-                                    ),
-                                    t: finishedAtAligned ?? alignedNow(),
-                                }],
-                            });
+                        } catch {
+                            captureScope.traceBatchCount = 0;
+                            traceBatches = [];
+                        } finally {
+                            emitRequestCaptureManifest(traceBatches.length);
+                        }
+
+                        try {
+                            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
                         }

package/src/ingest/client.ts

@@ -26,6 +26,11 @@ type QueuedIngestBatch = {
     sessionId: string;
     entries: LegacyEntry[];
     attempts: number;
+    priority: 'normal' | 'high';
+};
+
+export type EnqueueIngestOptions = {
+    priority?: 'normal' | 'high';
 };
 
 const ingestQueue: QueuedIngestBatch[] = [];
@@ -205,18 +210,40 @@ export const enqueueIngestEntries = (
     config: IngestClientConfig,
     sessionId: string,
     entries: LegacyEntry[],
+    options: EnqueueIngestOptions = {},
 ): void => {
     if (!sessionId || !Array.isArray(entries) || entries.length === 0) {
         return;
     }
-    ingestQueue.push({
+    const priority = options.priority === 'high' ? 'high' : 'normal';
+    const batch: QueuedIngestBatch = {
         config: { ...config },
         sessionId,
         entries: entries.slice(),
         attempts: 0,
-    });
+        priority,
+    };
+    if (priority === 'high') {
+        const firstNormalIndex = ingestQueue.findIndex((queued) => queued.priority !== 'high');
+        if (firstNormalIndex === -1) {
+            ingestQueue.push(batch);
+        } else {
+            ingestQueue.splice(firstNormalIndex, 0, batch);
+        }
+    } else {
+        ingestQueue.push(batch);
+    }
     if (DEFAULT_QUEUE_MAX_ITEMS > 0 && ingestQueue.length > DEFAULT_QUEUE_MAX_ITEMS) {
-        ingestQueue.splice(0, ingestQueue.length - DEFAULT_QUEUE_MAX_ITEMS);
+        while (ingestQueue.length > DEFAULT_QUEUE_MAX_ITEMS) {
+            let removeIndex = ingestQueue.length - 1;
+            for (let index = ingestQueue.length - 1; index >= 0; index -= 1) {
+                if (ingestQueue[index]?.priority !== 'high') {
+                    removeIndex = index;
+                    break;
+                }
+            }
+            ingestQueue.splice(removeIndex, 1);
+        }
     }
     scheduleDrain(shouldDeferDrain?.() ? deferDrainMs : 0);
 };

package/test/request-manifest-priority.test.js

@@ -0,0 +1,147 @@
+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 { EventEmitter } = require('events');
+const { initReproTracing, reproMiddleware } = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitFor(predicate, timeoutMs = 1500) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate()) return;
+        await sleep(20);
+    }
+    assert(predicate(), 'timed out waiting for expected condition');
+}
+
+function makeTaggedReqRes(sessionId, actionId) {
+    const req = new EventEmitter();
+    req.method = 'GET';
+    req.url = '/manifest-priority';
+    req.headers = {
+        'x-bug-session-id': sessionId,
+        'x-bug-action-id': actionId,
+        'x-bug-request-start': String(Date.now()),
+    };
+    req.body = undefined;
+    req.params = {};
+    req.query = {};
+
+    const res = new EventEmitter();
+    res.statusCode = 200;
+    res.getHeader = () => undefined;
+    res.setHeader = () => {};
+    res.json = function (body) { this.body = body; this.emit('finish'); return body; };
+    res.send = function (body) { this.body = body; this.emit('finish'); return body; };
+    res.write = () => true;
+    res.end = () => { res.emit('finish'); return true; };
+
+    return { req, res };
+}
+
+function flattenEvents(posts) {
+    return posts.flatMap((body) => Array.isArray(body?.events) ? body.events : []);
+}
+
+async function tracedHandler() {
+    return {
+        ok: true,
+        payload: 'x'.repeat(16_000),
+    };
+}
+
+async function main() {
+    const capturedBodies = [];
+    const originalFetch = global.fetch;
+    global.fetch = async (_url, init = {}) => {
+        const body = JSON.parse(String(init.body || '{}'));
+        capturedBodies.push(body);
+        const hasTraceBatch = Array.isArray(body.events) &&
+            body.events.some((event) => event?.event_type === 'trace_batch');
+        if (hasTraceBatch) {
+            return new Promise((_resolve, reject) => {
+                const signal = init.signal;
+                if (signal?.aborted) {
+                    reject(new Error('aborted'));
+                    return;
+                }
+                signal?.addEventListener?.('abort', () => reject(new Error('aborted')), { once: true });
+            });
+        }
+        return {
+            ok: true,
+            status: 202,
+            json: async () => ({ ok: true }),
+            text: async () => '{"ok":true}',
+        };
+    };
+
+    try {
+        initReproTracing({ instrument: false, logFunctionCalls: false });
+        const cfg = {
+            tenantId: 'TENANT_test',
+            appId: 'APP_test',
+            appSecret: 'secret',
+            captureHeaders: false,
+            privacy: { environment: 'dev' },
+            ingestBase: 'http://127.0.0.1:65535',
+        };
+        const { req, res } = makeTaggedReqRes('S_manifest_priority', 'A_manifest_priority');
+
+        await new Promise((resolve, reject) => {
+            void reproMiddleware(cfg)(req, res, async (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+
+                try {
+                    await global.__repro_call(
+                        tracedHandler,
+                        null,
+                        [],
+                        'app',
+                        1,
+                        'tracedHandler',
+                        true,
+                    );
+                    res.json({ ok: true });
+                    resolve();
+                } catch (error) {
+                    reject(error);
+                }
+            });
+        });
+
+        await waitFor(() => flattenEvents(capturedBodies)
+            .some((event) => event?.event_type === 'request_capture_manifest'));
+
+        const eventTypes = flattenEvents(capturedBodies).map((event) => event?.event_type);
+        const manifestIndex = eventTypes.indexOf('request_capture_manifest');
+        const traceIndex = eventTypes.indexOf('trace_batch');
+
+        assert(manifestIndex >= 0, JSON.stringify(eventTypes));
+        assert(traceIndex >= 0, JSON.stringify(eventTypes));
+        assert(
+            manifestIndex < traceIndex,
+            `request_capture_manifest must be sent before trace_batch; got ${JSON.stringify(eventTypes)}`,
+        );
+
+        console.log('request manifest priority OK');
+    } finally {
+        global.fetch = originalFetch;
+        await flushIngestQueue();
+    }
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/test/runtime-no-double-invoke.test.js

@@ -0,0 +1,68 @@
+const assert = require('assert');
+
+const { trace, SYM_BODY_TRACED } = require('../tracer/runtime');
+
+function assertSyncThrowsOnceWithNoActiveTrace() {
+    let calls = 0;
+    function throwsOnce() {
+        calls += 1;
+        throw new Error('app failure');
+    }
+
+    assert.throws(
+        () => global.__repro_call(throwsOnce, null, [], __filename, 10, 'throwsOnce', false),
+        /app failure/,
+    );
+    assert.strictEqual(calls, 1);
+}
+
+function assertSyncThrowsOnceWithActiveTrace() {
+    let calls = 0;
+    function throwsOnce() {
+        calls += 1;
+        throw new Error('traced app failure');
+    }
+
+    assert.throws(
+        () => trace.withTrace('runtime-no-double-invoke', () => (
+            global.__repro_call(throwsOnce, null, [], __filename, 25, 'throwsOnce', false)
+        )),
+        /traced app failure/,
+    );
+    assert.strictEqual(calls, 1);
+}
+
+function assertBodyTracedThrowsOnceWithActiveTrace() {
+    let calls = 0;
+    function bodyTracedThrowsOnce() {
+        calls += 1;
+        throw new Error('body traced app failure');
+    }
+    Object.defineProperty(bodyTracedThrowsOnce, SYM_BODY_TRACED, {
+        value: true,
+        configurable: true,
+    });
+
+    assert.throws(
+        () => trace.withTrace('runtime-no-double-invoke-body', () => (
+            global.__repro_call(bodyTracedThrowsOnce, null, [], __filename, 45, 'bodyTracedThrowsOnce', false)
+        )),
+        /body traced app failure/,
+    );
+    assert.strictEqual(calls, 1);
+}
+
+async function main() {
+    assertSyncThrowsOnceWithNoActiveTrace();
+    assertSyncThrowsOnceWithActiveTrace();
+    assertBodyTracedThrowsOnceWithActiveTrace();
+
+    // eslint-disable-next-line no-console
+    console.log('runtime no double invoke OK');
+}
+
+main().catch((error) => {
+    // eslint-disable-next-line no-console
+    console.error(error);
+    process.exitCode = 1;
+});

package/test/runtime-no-double-invoke.testcontainers.test.js

@@ -0,0 +1,70 @@
+const assert = require('assert');
+const mongoose = require('mongoose');
+const { GenericContainer, Wait } = require('testcontainers');
+
+const { trace } = require('../tracer/runtime');
+
+async function startMongo() {
+    return new GenericContainer('mongo:7')
+        .withExposedPorts(27017)
+        .withTmpFs({ '/data/db': 'rw,noexec,nosuid,size=256m' })
+        .withCommand(['mongod', '--bind_ip_all', '--setParameter', 'diagnosticDataCollectionEnabled=false'])
+        .withWaitStrategy(Wait.forListeningPorts())
+        .start();
+}
+
+async function main() {
+    let container;
+    let connection;
+
+    try {
+        container = await startMongo();
+        const uri = `mongodb://${container.getHost()}:${container.getMappedPort(27017)}/repro_node_sdk_test`;
+        connection = await mongoose.createConnection(uri).asPromise();
+
+        const SideEffect = connection.model('SideEffect', new mongoose.Schema({
+            name: { type: String, required: true },
+        }));
+
+        let calls = 0;
+        async function writeThenThrow(name) {
+            calls += 1;
+            await SideEffect.create({ name });
+            throw new Error('intentional app failure');
+        }
+
+        await assert.rejects(
+            () => trace.withTrace('runtime-no-double-invoke-container', () => (
+                global.__repro_call(
+                    writeThenThrow,
+                    null,
+                    ['single-write'],
+                    __filename,
+                    35,
+                    'writeThenThrow',
+                    false,
+                )
+            )),
+            /intentional app failure/,
+        );
+
+        assert.strictEqual(calls, 1);
+        assert.strictEqual(await SideEffect.countDocuments({ name: 'single-write' }), 1);
+
+        // eslint-disable-next-line no-console
+        console.log('runtime no double invoke testcontainers OK');
+    } finally {
+        if (connection) {
+            await connection.close().catch(() => {});
+        }
+        if (container) {
+            await container.stop().catch(() => {});
+        }
+    }
+}
+
+main().catch((error) => {
+    // eslint-disable-next-line no-console
+    console.error(error);
+    process.exitCode = 1;
+});

package/tracer/runtime.js

@@ -505,9 +505,14 @@ function forkAlsStoreForUnawaited(baseStore) {
 if (!global.__repro_call) {
     Object.defineProperty(global, '__repro_call', {
         value: function __repro_call(fn, thisArg, args, callFile, callLine, label, isUnawaitedCall) {
+            let didInvokeTarget = false;
+            const invokeTarget = (targetThis, targetArgs) => {
+                didInvokeTarget = true;
+                return fn.apply(targetThis, targetArgs);
+            };
             try {
                 if (typeof fn !== 'function' || fn[SYM_SKIP_WRAP]) {
-                    return fn.apply(thisArg, args);
+                    return invokeTarget(thisArg, args);
                 }
 
                 const currentStore = als.getStore();
@@ -516,13 +521,9 @@ if (!global.__repro_call) {
                 // If no tracing context is active, bail out quickly to avoid touching app semantics
                 // during module initialization or other untracked code paths.
                 if (!currentStore) {
-                    try {
-                        const out = fn.apply(thisArg, args);
-                        if (isUnawaitedCall && isThenable(out)) markPromiseUnawaited(out);
-                        return out;
-                    } catch {
-                        return fn ? fn.apply(thisArg, args) : undefined;
-                    }
+                    const out = invokeTarget(thisArg, args);
+                    if (isUnawaitedCall && isThenable(out)) markPromiseUnawaited(out);
+                    return out;
                 }
 
                 const sourceFile = fn[SYM_SRC_FILE];
@@ -643,7 +644,7 @@ if (!global.__repro_call) {
                     const shouldWrap = !isAsyncLocalContextSetter(fn, thisArg);
                     const argsForCall = shouldWrap ? wrapArgsWithStore(args, snapshotForArgs) : args;
                     try {
-                        const out = fn.apply(thisArg, argsForCall);
+                        const out = invokeTarget(thisArg, argsForCall);
 
                         const isThenableValue = isThenable(out);
                         const isQuery = isMongooseQuery(out);
@@ -755,10 +756,10 @@ if (!global.__repro_call) {
 	                            let out;
 	                            if (isolatedStore) {
 	                                als.run(isolatedStore, () => {
-	                                    out = fn.apply(thisArg, argsForCall);
+	                                    out = invokeTarget(thisArg, argsForCall);
 	                                });
                             } else {
-                                out = fn.apply(thisArg, argsForCall);
+                                out = invokeTarget(thisArg, argsForCall);
                             }
                             if (isUnawaitedCall && isThenable(out)) markPromiseUnawaited(out);
                             return out;
@@ -775,7 +776,10 @@ if (!global.__repro_call) {
                     }
                     return invokeWithTrace(forcedParentSpanId, callStoreForArgs);
                 });
-            } catch {
+            } catch (error) {
+                if (didInvokeTarget) {
+                    throw error;
+                }
                 return fn ? fn.apply(thisArg, args) : undefined;
             }
         },