@reproapp/node-sdk 0.0.19 → 0.0.21

package/dist/index.js

@@ -4175,13 +4175,16 @@ function reproMiddleware(cfg) {
                             privacy: activePrivacy,
                         },
                     }, requestValueEntries);
+                const responseDurationMs = finishedAt !== null && Number.isFinite(finishedAt)
+                    ? Math.max(0, finishedAt - t0)
+                    : Date.now() - t0;
                 const requestPayload = {
                     rid,
                     method: req.method,
                     url,
                     path,
                     status: res.statusCode,
-                    durMs: Date.now() - t0,
+                    durMs: responseDurationMs,
                     headers: maskedHeaders,
                     key,
                     respBody: responseBody,
@@ -4217,6 +4220,12 @@ function reproMiddleware(cfg) {
                     return;
                 requestCaptureScheduled = true;
                 try {
+                    if (capturedBody === undefined && chunks.length) {
+                        const buf = Buffer.isBuffer(chunks[0])
+                            ? Buffer.concat(chunks.map(c => (Buffer.isBuffer(c) ? c : Buffer.from(String(c)))))
+                            : Buffer.from(chunks.map(String).join(''));
+                        capturedBody = coerceBodyToStorable(buf, res.getHeader?.('content-type'));
+                    }
                     const { chosenEndpoint, hasTraceEvents } = chooseRequestEndpoint();
                     const { requestPayload, requestValueEntries } = await buildRequestCapturePayloadAsync(chosenEndpoint, hasTraceEvents);
                     post(cfg, sid, {
@@ -4333,13 +4342,7 @@ function reproMiddleware(cfg) {
                     finishedAt = Date.now();
                     finishedAtAligned = alignTimestamp(finishedAt);
                 }
-                if (capturedBody === undefined && chunks.length) {
-                    const buf = Buffer.isBuffer(chunks[0])
-                        ? Buffer.concat(chunks.map(c => (Buffer.isBuffer(c) ? c : Buffer.from(String(c)))))
-                        : Buffer.from(chunks.map(String).join(''));
-                    capturedBody = coerceBodyToStorable(buf, res.getHeader?.('content-type'));
-                }
-                void emitRequestCaptureAsync();
+                scheduleSdkBackgroundWork(emitRequestCaptureAsync, { priority: 'high' });
                 if (!flushPayload) {
                     flushPayload = async () => {
                         let traceBatches = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "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-capture-background.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/src/index.ts

@@ -5099,13 +5099,17 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         },
                     }, requestValueEntries);
 
+                const responseDurationMs =
+                    finishedAt !== null && Number.isFinite(finishedAt)
+                        ? Math.max(0, finishedAt - t0)
+                        : Date.now() - t0;
                 const requestPayload: Record<string, any> = {
                     rid,
                     method: req.method,
                     url,
                     path,
                     status: res.statusCode,
-                    durMs: Date.now() - t0,
+                    durMs: responseDurationMs,
                     headers: maskedHeaders,
                     key,
                     respBody: responseBody,
@@ -5134,6 +5138,13 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                 if (requestCaptureScheduled) return;
                 requestCaptureScheduled = true;
                 try {
+                    if (capturedBody === undefined && chunks.length) {
+                        const buf = Buffer.isBuffer(chunks[0])
+                            ? Buffer.concat(chunks.map(c => (Buffer.isBuffer(c) ? c : Buffer.from(String(c)))))
+                            : Buffer.from(chunks.map(String).join(''));
+                        capturedBody = coerceBodyToStorable(buf, res.getHeader?.('content-type'));
+                    }
+
                     const { chosenEndpoint, hasTraceEvents } = chooseRequestEndpoint();
                     const { requestPayload, requestValueEntries } = await buildRequestCapturePayloadAsync(
                         chosenEndpoint,
@@ -5259,14 +5270,8 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                     finishedAt = Date.now();
                     finishedAtAligned = alignTimestamp(finishedAt);
                 }
-                if (capturedBody === undefined && chunks.length) {
-                    const buf = Buffer.isBuffer(chunks[0])
-                        ? Buffer.concat(chunks.map(c => (Buffer.isBuffer(c) ? c : Buffer.from(String(c)))))
-                        : Buffer.from(chunks.map(String).join(''));
-                    capturedBody = coerceBodyToStorable(buf, res.getHeader?.('content-type'));
-                }
 
-                void emitRequestCaptureAsync();
+                scheduleSdkBackgroundWork(emitRequestCaptureAsync, { priority: 'high' });
 
                 if (!flushPayload) {
                     flushPayload = async () => {

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/test/request-capture-background.test.js

@@ -0,0 +1,131 @@
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '500';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '25';
+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('node:assert/strict');
+const { EventEmitter } = require('events');
+const { 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 makeReqRes(sessionId, actionId) {
+    const req = new EventEmitter();
+    req.method = 'GET';
+    req.url = sessionId ? '/captured' : '/held-open';
+    req.headers = sessionId && actionId
+        ? {
+            '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 = () => 'application/json';
+    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 : []);
+}
+
+function countEvents(posts, eventType) {
+    return flattenEvents(posts).filter((event) => event?.event_type === eventType).length;
+}
+
+async function invokeMiddleware(middleware, req, res, handler) {
+    await new Promise((resolve, reject) => {
+        void middleware(req, res, async (err) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            try {
+                await handler();
+                resolve();
+            } catch (error) {
+                reject(error);
+            }
+        });
+    });
+}
+
+async function main() {
+    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 {
+        const cfg = {
+            tenantId: 'TENANT_test',
+            appId: 'APP_test',
+            appSecret: 'secret',
+            captureHeaders: false,
+            privacy: { environment: 'dev' },
+            ingestBase: 'http://127.0.0.1:65535',
+        };
+        const middleware = reproMiddleware(cfg);
+
+        const held = makeReqRes(null, null);
+        await invokeMiddleware(middleware, held.req, held.res, async () => {
+            // Keep this request open to simulate another client endpoint still in flight.
+        });
+
+        const tagged = makeReqRes('S_request_capture_background', 'A_request_capture_background');
+        await invokeMiddleware(middleware, tagged.req, tagged.res, async () => {
+            tagged.res.json({ ok: true, rows: Array.from({ length: 50 }, (_, i) => ({ i, value: `row-${i}` })) });
+        });
+
+        await sleep(100);
+        assert.equal(
+            countEvents(capturedBodies, 'backend_request'),
+            0,
+            `request capture should defer while another client request is active: ${JSON.stringify(capturedBodies)}`,
+        );
+
+        held.res.emit('finish');
+        await waitFor(() => countEvents(capturedBodies, 'backend_request') === 1);
+        await flushIngestQueue();
+
+        assert.equal(countEvents(capturedBodies, 'backend_request'), 1, JSON.stringify(capturedBodies));
+        console.log('request capture background OK');
+    } finally {
+        global.fetch = originalFetch;
+        await flushIngestQueue();
+    }
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(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;