@reproapp/node-sdk 0.0.17 → 0.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.17",
+  "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/request-manifest-priority.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/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;
             }
         },