@reproapp/node-sdk 0.0.19 → 0.0.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,8 +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/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"
+    "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/function-arg-identity.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 && node test/function-arg-identity.testcontainers.test.js"
   },
   "peerDependencies": {
     "express": "^5.1.0",

package/test/function-arg-identity.test.js

@@ -0,0 +1,94 @@
+const assert = require('assert');
+const vm = require('vm');
+const babel = require('@babel/core');
+const makeWrapPlugin = require('../tracer/wrap-plugin');
+const { trace, setFunctionLogsEnabled } = require('../tracer/runtime');
+
+setFunctionLogsEnabled(false);
+
+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, extraContext = {}) {
+    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,
+        ...extraContext,
+    };
+
+    vm.runInNewContext(code, context, { filename });
+    return { exports: module.exports, code };
+}
+
+async function main() {
+    const filename = `${process.cwd()}/node-sdk/test/fixtures/ioc-container.fixture.js`;
+    const external = {
+        readDepNames(comp) {
+            return comp.depList.map((dep) => dep.name);
+        },
+    };
+    const { exports: mod } = loadInstrumentedModule(`
+        class Leaf {}
+        Leaf.depList = [];
+
+        class Root {}
+        Root.depList = [Leaf];
+
+        function recurseDeps(comp) {
+            const names = [comp.name];
+            for (const dep of comp.depList) {
+                names.push(...recurseDeps(dep));
+            }
+            return names;
+        }
+
+        function getDeps(comp) {
+            return recurseDeps(comp);
+        }
+
+        function runAppToApp() {
+            return getDeps(Root);
+        }
+
+        function runThroughExternal() {
+            return external.readDepNames(Root);
+        }
+
+        module.exports = { runAppToApp, runThroughExternal, Root, Leaf };
+    `, filename, { external });
+
+    assert.deepStrictEqual(
+        Array.from(trace.withTrace('function-arg-app-to-app', () => mod.runAppToApp())),
+        ['Root', 'Leaf'],
+    );
+    assert.deepStrictEqual(
+        Array.from(trace.withTrace('function-arg-external', () => mod.runThroughExternal())),
+        ['Leaf'],
+    );
+    assert.strictEqual(mod.Root.depList[0], mod.Leaf);
+
+    console.log('function argument identity OK');
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/test/function-arg-identity.testcontainers.test.js

@@ -0,0 +1,114 @@
+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');
+const { trace, setFunctionLogsEnabled } = require('../tracer/runtime');
+
+setFunctionLogsEnabled(false);
+
+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, extraContext = {}) {
+    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,
+        ...extraContext,
+    };
+
+    vm.runInNewContext(code, context, { filename });
+    return { exports: module.exports, code };
+}
+
+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_identity_test`;
+        connection = await mongoose.createConnection(uri).asPromise();
+        const SeenDependency = connection.model('SeenDependency', new mongoose.Schema({
+            root: { type: String, required: true },
+            dep: { type: String, required: true },
+        }));
+
+        const external = {
+            async persistDepNames(comp) {
+                const docs = comp.depList.map((dep) => ({
+                    root: comp.name,
+                    dep: dep.name,
+                }));
+                await SeenDependency.insertMany(docs);
+                return docs.length;
+            },
+        };
+
+        const filename = `${process.cwd()}/node-sdk/test/fixtures/ioc-container-container.fixture.js`;
+        const { exports: mod } = loadInstrumentedModule(`
+            class Leaf {}
+            Leaf.depList = [];
+
+            class Root {}
+            Root.depList = [Leaf];
+
+            async function runThroughExternal() {
+                return external.persistDepNames(Root);
+            }
+
+            module.exports = { runThroughExternal };
+        `, filename, { external });
+
+        const inserted = await trace.withTrace('function-arg-container', () => mod.runThroughExternal());
+
+        assert.strictEqual(inserted, 1);
+        assert.deepStrictEqual(
+            await SeenDependency.find({}, { _id: 0, root: 1, dep: 1 }).lean(),
+            [{ root: 'Root', dep: 'Leaf' }],
+        );
+
+        console.log('function argument identity 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

@@ -312,6 +312,59 @@ const SYM_SKIP_WRAP= Symbol.for('__repro_skip_wrap'); // guard to avoid wrapping
 const SYM_BODY_TRACED = Symbol.for('__repro_body_traced'); // set on functions whose bodies already emit trace enter/exit
 const SYM_UNAWAITED = Symbol.for('__repro_unawaited');
 const SYM_PROMISE_STORE = Symbol.for('__repro_promise_store');
+const REPRO_FUNCTION_SYMBOLS = new Set([
+    SYM_SRC_FILE,
+    SYM_IS_APP,
+    SYM_SKIP_WRAP,
+    SYM_BODY_TRACED,
+    SYM_UNAWAITED,
+    SYM_PROMISE_STORE,
+]);
+const FUNCTION_IDENTITY_BUILTINS = new Set([
+    'length',
+    'name',
+    'prototype',
+    'arguments',
+    'caller',
+]);
+
+function isClassLikeFunction(fn) {
+    if (!fn || typeof fn !== 'function') return false;
+    try {
+        const src = Function.prototype.toString.call(fn);
+        if (/^class\s/.test(src)) return true;
+    } catch {}
+    try {
+        const proto = fn.prototype;
+        if (proto && typeof proto === 'object') {
+            const props = Object.getOwnPropertyNames(proto);
+            if (props.some((name) => name !== 'constructor')) return true;
+        }
+    } catch {}
+    return false;
+}
+
+function hasCustomFunctionMetadata(fn) {
+    if (!fn || typeof fn !== 'function') return false;
+    try {
+        for (const name of Object.getOwnPropertyNames(fn)) {
+            if (FUNCTION_IDENTITY_BUILTINS.has(name)) continue;
+            if (name.startsWith('__repro')) continue;
+            return true;
+        }
+    } catch {}
+    try {
+        for (const sym of Object.getOwnPropertySymbols(fn)) {
+            if (REPRO_FUNCTION_SYMBOLS.has(sym)) continue;
+            return true;
+        }
+    } catch {}
+    return false;
+}
+
+function shouldPreserveFunctionArgumentIdentity(fn) {
+    return isClassLikeFunction(fn) || hasCustomFunctionMetadata(fn);
+}
 
 function emit(ev){
     if (EMITTING) return;
@@ -562,6 +615,7 @@ if (!global.__repro_call) {
                 const wrapArgWithStore = (arg, baseStoreSnapshot) => {
                     if (typeof arg !== 'function') return arg;
                     if (arg[SYM_SKIP_WRAP] || arg.__repro_arg_wrapper) return arg;
+                    if (shouldPreserveFunctionArgumentIdentity(arg)) return arg;
                     const hasContext = baseStoreSnapshot
                         && (baseStoreSnapshot.traceId != null
                             || (Array.isArray(baseStoreSnapshot.__repro_span_stack) && baseStoreSnapshot.__repro_span_stack.length));
@@ -601,6 +655,13 @@ if (!global.__repro_call) {
                     return false;
                 };
 
+                const shouldWrapFunctionArgsForCallee = (targetFn, targetThis) => {
+                    if (isAsyncLocalContextSetter(targetFn, targetThis)) return false;
+                    if (isApp || instrumented || bodyTraced) return false;
+                    if (targetFn && targetFn[SYM_IS_APP] === true) return false;
+                    return true;
+                };
+
                 const runWithCallStore = (fnToRun) => {
                     const callStore = makeCallStore();
                     const parentSpanId = callStore.__repro_span_stack.length
@@ -641,7 +702,7 @@ if (!global.__repro_call) {
                     // After entering, snapshot a clean store that captures the parent + this call’s span,
                     // so callbacks invoked during the callee run are isolated per invocation.
                     const snapshotForArgs = cloneStore(als.getStore());
-                    const shouldWrap = !isAsyncLocalContextSetter(fn, thisArg);
+                    const shouldWrap = shouldWrapFunctionArgsForCallee(fn, thisArg);
                     const argsForCall = shouldWrap ? wrapArgsWithStore(args, snapshotForArgs) : args;
                     try {
                         const out = invokeTarget(thisArg, argsForCall);
@@ -743,7 +804,7 @@ if (!global.__repro_call) {
                             ? (forkAlsStoreForUnawaited(callStoreForArgs || ctx) || cloneStore(callStoreForArgs || ctx))
                             : null;
 	                        try {
-	                            const shouldWrap = !isAsyncLocalContextSetter(fn, thisArg);
+	                            const shouldWrap = shouldWrapFunctionArgsForCallee(fn, thisArg);
 	                            const argsForCall = shouldWrap ? wrapArgsWithStore(args, callStoreForArgs || ctx) : args;
 	                            const normalizedCallFile = callFile ? String(callFile).trim() : '';
 	                            const callsiteFile = normalizedCallFile ? normalizedCallFile : null;