@reproapp/node-sdk 0.0.17 → 0.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "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/wrap-plugin-super-call.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 && node test/wrap-plugin-super-call.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=1g' })
+        .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/test/wrap-plugin-super-call.test.js

@@ -0,0 +1,80 @@
+const assert = require('assert');
+const vm = require('vm');
+const babel = require('@babel/core');
+const makeWrapPlugin = require('../tracer/wrap-plugin');
+require('../tracer/runtime');
+
+function transform(source, filename) {
+    return babel.transformSync(source, {
+        filename,
+        plugins: [makeWrapPlugin(filename, {})],
+        parserOpts: { sourceType: 'script', plugins: ['typescript'] },
+        generatorOpts: { retainLines: true },
+    }).code;
+}
+
+function loadInstrumentedModule(source, filename) {
+    const code = transform(source, filename);
+    const module = { exports: {} };
+    const context = {
+        module,
+        exports: module.exports,
+        require,
+        console,
+        __trace: global.__trace,
+        __repro_call: global.__repro_call,
+        Promise,
+        Buffer,
+        setTimeout,
+        clearTimeout,
+        setImmediate,
+        clearImmediate,
+    };
+
+    vm.runInNewContext(code, context, { filename });
+    return { exports: module.exports, code };
+}
+
+function toPlainJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+
+async function main() {
+    const filename = '/tmp/wrap-plugin-super-call.fixture.js';
+    const { exports: mod, code } = loadInstrumentedModule(`
+        class BaseNotificationGenerator {
+            async resolveNotificationConfig(params) {
+                return { source: 'base', params };
+            }
+        }
+
+        class SubjectNotificationGenerator extends BaseNotificationGenerator {
+            async resolveNotificationConfig(params, preloaded) {
+                return preloaded
+                    ? Promise.resolve(preloaded)
+                    : super.resolveNotificationConfig(params);
+            }
+        }
+
+        module.exports = { SubjectNotificationGenerator };
+    `, filename);
+
+    assert(!code.includes('= super'), `transformed code must not assign super into a temp:\n${code}`);
+
+    const generator = new mod.SubjectNotificationGenerator();
+    assert.deepStrictEqual(
+        toPlainJson(await generator.resolveNotificationConfig({ id: 'S_1' }, null)),
+        { source: 'base', params: { id: 'S_1' } },
+    );
+    assert.deepStrictEqual(
+        toPlainJson(await generator.resolveNotificationConfig({ id: 'S_2' }, { source: 'preloaded' })),
+        { source: 'preloaded' },
+    );
+
+    console.log('wrap-plugin super call OK');
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/test/wrap-plugin-super-call.testcontainers.test.js

@@ -0,0 +1,116 @@
+const assert = require('assert');
+const vm = require('vm');
+const babel = require('@babel/core');
+const mongoose = require('mongoose');
+const { GenericContainer, Wait } = require('testcontainers');
+
+const makeWrapPlugin = require('../tracer/wrap-plugin');
+require('../tracer/runtime');
+
+function transform(source, filename) {
+    return babel.transformSync(source, {
+        filename,
+        plugins: [makeWrapPlugin(filename, {})],
+        parserOpts: { sourceType: 'script', plugins: ['typescript'] },
+        generatorOpts: { retainLines: true },
+    }).code;
+}
+
+function loadInstrumentedModule(source, filename) {
+    const code = transform(source, filename);
+    const module = { exports: {} };
+    const context = {
+        module,
+        exports: module.exports,
+        require,
+        console,
+        __trace: global.__trace,
+        __repro_call: global.__repro_call,
+        Promise,
+        Buffer,
+        setTimeout,
+        clearTimeout,
+        setImmediate,
+        clearImmediate,
+    };
+
+    vm.runInNewContext(code, context, { filename });
+    return module.exports;
+}
+
+function toPlainJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+
+async function startMongo() {
+    return new GenericContainer('mongo:7')
+        .withExposedPorts(27017)
+        .withTmpFs({ '/data/db': 'rw,noexec,nosuid,size=1g' })
+        .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_super_test`;
+        connection = await mongoose.createConnection(uri).asPromise();
+        const Notification = connection.model('Notification', new mongoose.Schema({
+            name: { type: String, required: true },
+        }));
+
+        const { SubjectNotificationGenerator } = loadInstrumentedModule(`
+            class BaseNotificationGenerator {
+                constructor(model) {
+                    this.model = model;
+                }
+
+                async resolveNotificationConfig(params) {
+                    await this.model.create({ name: params.name });
+                    return { source: 'base', name: params.name };
+                }
+            }
+
+            class SubjectNotificationGenerator extends BaseNotificationGenerator {
+                async resolveNotificationConfig(params, preloaded) {
+                    return preloaded
+                        ? Promise.resolve(preloaded)
+                        : super.resolveNotificationConfig(params);
+                }
+            }
+
+            module.exports = { SubjectNotificationGenerator };
+        `, '/tmp/wrap-plugin-super-call-container.fixture.js');
+
+        const generator = new SubjectNotificationGenerator(Notification);
+        assert.deepStrictEqual(
+            toPlainJson(await generator.resolveNotificationConfig({ name: 'created-through-super' }, null)),
+            { source: 'base', name: 'created-through-super' },
+        );
+        assert.deepStrictEqual(
+            toPlainJson(await generator.resolveNotificationConfig({ name: 'not-created' }, { source: 'preloaded' })),
+            { source: 'preloaded' },
+        );
+
+        assert.strictEqual(await Notification.countDocuments({ name: 'created-through-super' }), 1);
+        assert.strictEqual(await Notification.countDocuments({ name: 'not-created' }), 0);
+
+        console.log('wrap-plugin super call testcontainers OK');
+    } finally {
+        if (connection) {
+            await connection.close().catch(() => {});
+        }
+        if (container) {
+            await container.stop().catch(() => {});
+        }
+    }
+}
+
+main().catch((error) => {
+    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;
             }
         },

package/tracer/wrap-plugin.js

@@ -49,6 +49,13 @@ module.exports = function makeWrapPlugin(filenameForMeta, opts = {}) {
             return '';
         }
 
+        function isSuperMemberCall(callee) {
+            if (!callee) return false;
+            if (t.isMemberExpression(callee) && t.isSuper(callee.object)) return true;
+            if (t.isOptionalMemberExpression && t.isOptionalMemberExpression(callee) && t.isSuper(callee.object)) return true;
+            return false;
+        }
+
         const obj = kv => t.objectExpression(
             Object.entries(kv)
                 .filter(([, v]) => v != null)
@@ -451,6 +458,7 @@ module.exports = function makeWrapPlugin(filenameForMeta, opts = {}) {
             if (t.isIdentifier(n.callee, { name: '__awaiter' })) return;
             if (t.isIdentifier(n.callee, { name: '__generator' })) return;
             if (t.isSuper(n.callee)) return;
+            if (isSuperMemberCall(n.callee)) return;
             if (t.isImport(n.callee)) return;
 
             if (t.isMemberExpression(n.callee) && t.isIdentifier(n.callee.object, { name: '__trace' })) {
@@ -559,6 +567,7 @@ module.exports = function makeWrapPlugin(filenameForMeta, opts = {}) {
             if (t.isIdentifier(n.callee, { name: '__awaiter' })) return;
             if (t.isIdentifier(n.callee, { name: '__generator' })) return;
             if (t.isSuper(n.callee)) return;
+            if (isSuperMemberCall(n.callee)) return;
             if (t.isImport(n.callee)) return;
 
             const loc = n.loc?.start || null;