@reproapp/node-sdk 0.0.45 → 0.0.47

package/test/sdk-background-timeout-isolation.test.js

@@ -0,0 +1,39 @@
+process.env.REPRO_SDK_BACKGROUND_WORK_TIMEOUT_MS = '20';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+
+const assert = require('node:assert/strict');
+const { __reproTestHooks } = require('../dist');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function main() {
+    const hooks = __reproTestHooks;
+    hooks.resetSdkBackgroundQueuesForTest();
+    const order = [];
+
+    hooks.scheduleSdkBackgroundWorkForTest(async () => {
+        order.push('first-start');
+        await sleep(80);
+        order.push('first-end');
+    }, { priority: 'high' });
+    hooks.scheduleSdkBackgroundWorkForTest(() => {
+        order.push('second');
+    }, { priority: 'high' });
+
+    await hooks.drainSdkBackgroundQueueForTest();
+
+    assert.deepEqual(
+        order,
+        ['first-start', 'first-end', 'second'],
+        'a slow background capture must finish before the queue advances',
+    );
+
+    hooks.resetSdkBackgroundQueuesForTest();
+    console.log('sdk background timeout isolation OK');
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/test/trace-batch-size.test.js

@@ -43,6 +43,10 @@ function main() {
     );
 
     batches.forEach((batch, index) => {
+        assert(
+            batch.length <= 100,
+            `batch ${index} exceeded the 100-event transport limit: ${batch.length}`,
+        );
         const size = __reproTestHooks.estimateTraceBatchSerializedBytesForTest(
             batch,
             'RID_test_trace_batch_size',

package/test/trace-source-exclude.test.js

@@ -0,0 +1,222 @@
+'use strict';
+
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+process.env.TRACE_IDLE_FLUSH_MS = '25';
+process.env.SESSION_DRAIN_TIMEOUT_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '25';
+
+const assert = require('node:assert');
+const fs = require('node:fs');
+const path = require('node:path');
+const { EventEmitter } = require('node:events');
+const {
+    initReproTracing,
+    reproMiddleware,
+} = require('../dist');
+
+const excludeTenantModule =
+    /src[\\/]modules[\\/]core[\\/]database[\\/]modules[\\/]tenant[\\/]tenant-database\.module\.ts$/;
+
+function writeFixture(root) {
+    const distRoot = path.join(root, 'dist');
+    const tenantDistDir = path.join(
+        distRoot,
+        'modules/core/database/modules/tenant',
+    );
+    const tenantSourceFile = path.join(
+        root,
+        'src/modules/core/database/modules/tenant/tenant-database.module.ts',
+    );
+    const tenantDistFile = path.join(tenantDistDir, 'tenant-database.module.js');
+    const tenantMapFile = `${tenantDistFile}.map`;
+    const callerFile = path.join(distRoot, 'caller.js');
+
+    fs.mkdirSync(tenantDistDir, { recursive: true });
+    fs.writeFileSync(
+        tenantDistFile,
+        [
+            "'use strict';",
+            'function connectTenantDatabase() {',
+            "    return 'connected';",
+            '}',
+            'module.exports = { connectTenantDatabase };',
+            '//# sourceMappingURL=tenant-database.module.js.map',
+            '',
+        ].join('\n'),
+    );
+    fs.writeFileSync(
+        tenantMapFile,
+        JSON.stringify({
+            version: 3,
+            file: path.basename(tenantDistFile),
+            sourceRoot: '',
+            sources: [tenantSourceFile],
+            names: [],
+            mappings: '',
+        }),
+    );
+    fs.writeFileSync(
+        callerFile,
+        [
+            "'use strict';",
+            "const tenant = require('./modules/core/database/modules/tenant/tenant-database.module');",
+            'function invokeTenantDatabase() {',
+            '    return tenant.connectTenantDatabase();',
+            '}',
+            'module.exports = { invokeTenantDatabase, tenant };',
+            '',
+        ].join('\n'),
+    );
+
+    return { callerFile, tenantSourceFile };
+}
+
+function makeReqRes() {
+    const req = new EventEmitter();
+    req.method = 'GET';
+    req.url = '/source-exclude';
+    req.headers = {
+        'x-bug-session-id': 'S_trace_source_exclude',
+        'x-bug-action-id': 'A_trace_source_exclude',
+        'x-bug-request-start': String(Date.now()),
+    };
+    req.params = {};
+    req.query = {};
+
+    const res = new EventEmitter();
+    res.statusCode = 200;
+    res.getHeader = () => undefined;
+    res.setHeader = () => {};
+    res.json = function json(body) {
+        this.body = body;
+        this.emit('finish');
+        return body;
+    };
+    res.send = res.json;
+    res.write = () => true;
+    res.end = () => {
+        res.emit('finish');
+        return true;
+    };
+
+    return { req, res };
+}
+
+function traceEventsFromPosts(posts) {
+    const traces = [];
+    const append = (value) => {
+        if (Array.isArray(value)) {
+            traces.push(...value);
+            return;
+        }
+        if (typeof value !== 'string') return;
+        try {
+            const parsed = JSON.parse(value);
+            if (Array.isArray(parsed)) traces.push(...parsed);
+        } catch {}
+    };
+
+    for (const post of posts) {
+        let payload;
+        try {
+            payload = JSON.parse(String(post.body || ''));
+        } catch {
+            continue;
+        }
+        for (const entry of Array.isArray(payload.entries) ? payload.entries : []) {
+            append(entry?.trace);
+            append(entry?.request?.trace);
+        }
+        for (const event of Array.isArray(payload.events) ? payload.events : []) {
+            append(event?.payload?.trace);
+            append(event?.payload?.request?.trace);
+        }
+    }
+
+    return traces;
+}
+
+async function main() {
+    const fixtureRoot = fs.mkdtempSync(path.join(__dirname, '.tmp-source-exclude-'));
+    const posts = [];
+    const originalFetch = global.fetch;
+
+    try {
+        const fixture = writeFixture(fixtureRoot);
+        const includeFixture = new RegExp(
+            `^${fixtureRoot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`,
+        );
+
+        global.fetch = async (url, options = {}) => {
+            posts.push({ url: String(url), body: options.body });
+            return {
+                ok: true,
+                status: 200,
+                json: async () => ({ ok: true }),
+                text: async () => '{"ok":true}',
+            };
+        };
+
+        initReproTracing({
+            include: [includeFixture],
+            exclude: [excludeTenantModule],
+            logFunctionCalls: false,
+        });
+
+        const caller = require(fixture.callerFile);
+        assert.strictEqual(
+            caller.tenant.connectTenantDatabase.__repro_instrumented,
+            undefined,
+            'source-mapped excluded module must not be instrumented',
+        );
+        assert.strictEqual(
+            caller.invokeTenantDatabase.__repro_instrumented,
+            true,
+            'non-excluded caller must remain instrumented',
+        );
+
+        const middleware = reproMiddleware({
+            appId: 'APP_trace_source_exclude',
+            tenantId: 'TENANT_trace_source_exclude',
+            appSecret: 'secret',
+            captureHeaders: false,
+        });
+        const { req, res } = makeReqRes();
+        await new Promise((resolve, reject) => {
+            middleware(req, res, () => {
+                try {
+                    assert.strictEqual(caller.invokeTenantDatabase(), 'connected');
+                    res.json({ ok: true });
+                    resolve();
+                } catch (error) {
+                    reject(error);
+                }
+            });
+        });
+        await new Promise((resolve) => setTimeout(resolve, 500));
+
+        const traces = traceEventsFromPosts(posts);
+        assert(
+            traces.some((event) => event?.fn === 'invokeTenantDatabase'),
+            `expected caller trace, received ${JSON.stringify(traces)}`,
+        );
+        assert(
+            !traces.some(
+                (event) =>
+                    event?.fn === 'connectTenantDatabase' ||
+                    event?.sourceFile === fixture.tenantSourceFile,
+            ),
+            `excluded source leaked into trace payload: ${JSON.stringify(traces)}`,
+        );
+
+        console.log('source-mapped tracing exclusion OK');
+    } finally {
+        global.fetch = originalFetch;
+        fs.rmSync(fixtureRoot, { recursive: true, force: true });
+    }
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/tracer/cjs-hook.js

@@ -31,16 +31,19 @@ function tagExports(value, filename, seen = new WeakSet(), depth = 0, instrument
 
     if (typeof value === 'function') {
         try {
-            if (!value[SYM_SRC_FILE]) {
+            const existingSourceFile = value[SYM_SRC_FILE];
+            const belongsToCurrentModule =
+                !existingSourceFile || toPosix(existingSourceFile) === toPosix(filename);
+            if (!existingSourceFile) {
                 Object.defineProperty(value, SYM_SRC_FILE, { value: filename, configurable: true });
             }
-            if (value[SYM_IS_APP] !== isApp) {
+            if (belongsToCurrentModule && value[SYM_IS_APP] !== isApp) {
                 Object.defineProperty(value, SYM_IS_APP, { value: isApp, configurable: true });
             }
-            if (instrumented && value.__repro_instrumented !== true) {
+            if (instrumented && belongsToCurrentModule && value.__repro_instrumented !== true) {
                 Object.defineProperty(value, '__repro_instrumented', { value: true, configurable: true });
             }
-            if (instrumented && value[SYM_BODY_TRACED] !== true) {
+            if (instrumented && belongsToCurrentModule && value[SYM_BODY_TRACED] !== true) {
                 Object.defineProperty(value, SYM_BODY_TRACED, { value: true, configurable: true });
             }
         } catch {}
@@ -82,10 +85,24 @@ function installCJS({ include, exclude, parserPlugins } = {}) {
         : [ new RegExp('^' + escapeRx(CWD + '/')) ];
     const exc = Array.isArray(exclude) ? exclude : [];
 
-    const shouldHandle = (f) => {
-        const s = String(f || '').replace(/\\/g, '/');
-        if (exc.some(rx => rx.test(s))) return false;
-        return inc.some(rx => rx.test(s));
+    const matchesAny = (patterns, file) => {
+        const normalized = toPosix(file);
+        return patterns.some((rx) => {
+            try {
+                rx.lastIndex = 0;
+                const matched = rx.test(normalized);
+                rx.lastIndex = 0;
+                return matched;
+            } catch {
+                return false;
+            }
+        });
+    };
+
+    const shouldHandle = (physicalFile, sourceFile) => {
+        const candidates = [physicalFile, sourceFile].filter(Boolean);
+        if (candidates.some(file => matchesAny(exc, file))) return false;
+        return candidates.some(file => matchesAny(inc, file));
     };
 
     // ---- Global hook: intercept *all* compiles, regardless of how .ts was compiled ----
@@ -100,8 +117,7 @@ function installCJS({ include, exclude, parserPlugins } = {}) {
             if (transformedFiles.has(filename)) {
                 // Already transformed once; avoid double-transforming code that may already include __repro_call wrappers.
                 out = code;
-            } else if (shouldHandle(filename) && isAppFile(filename)) {
-                try { process.stderr.write(`[trace-debug] compile: ${filename}\n`); } catch {}
+            } else if (isAppFile(filename)) {
                 const sourceInfo = getSourceInfo(code, filename);
                 if (sourceInfo?.metaFilename) {
                     metaFilename = sourceInfo.metaFilename;
@@ -109,35 +125,38 @@ function installCJS({ include, exclude, parserPlugins } = {}) {
                 if (typeof sourceInfo?.mapOriginalPosition === 'function') {
                     mapOriginalPosition = sourceInfo.mapOriginalPosition;
                 }
-                // Transform the already-compiled JS (keeps Nest’s decorator metadata intact)
-                const res = babel.transformSync(code, {
-                    filename,
-                    sourceType: 'unambiguous',
-                    retainLines: true,
-                    sourceMaps: 'inline',
-                    parserOpts: {
+                if (shouldHandle(filename, metaFilename)) {
+                    try { process.stderr.write(`[trace-debug] compile: ${filename}\n`); } catch {}
+                    // Transform the already-compiled JS (keeps Nest’s decorator metadata intact).
+                    const res = babel.transformSync(code, {
+                        filename,
                         sourceType: 'unambiguous',
-                        // We’re parsing JS here; TS was compiled by ts-node/Nest.
-                        plugins: parserPlugins || [
-                            'jsx', 'classProperties', 'classPrivateProperties',
-                            'classPrivateMethods', 'dynamicImport', 'topLevelAwait',
-                            'optionalChaining', 'nullishCoalescingOperator',
+                        retainLines: true,
+                        sourceMaps: 'inline',
+                        parserOpts: {
+                            sourceType: 'unambiguous',
+                            // We’re parsing JS here; TS was compiled by ts-node/Nest.
+                            plugins: parserPlugins || [
+                                'jsx', 'classProperties', 'classPrivateProperties',
+                                'classPrivateMethods', 'dynamicImport', 'topLevelAwait',
+                                'optionalChaining', 'nullishCoalescingOperator',
+                            ],
+                        },
+                        // only the wrap plugin; do NOT run TS transform here
+                        plugins: [
+                            [ makeWrap(metaFilename, {
+                                mode: 'all',
+                                wrapGettersSetters: false,
+                                skipAnonymous: false,
+                                mapOriginalPosition,
+                            }) ],
                         ],
-                    },
-                    // only the wrap plugin; do NOT run TS transform here
-                    plugins: [
-                        [ makeWrap(metaFilename, {
-                            mode: 'all',
-                            wrapGettersSetters: false,
-                            skipAnonymous: false,
-                            mapOriginalPosition,
-                        }) ],
-                    ],
-                    compact: false,
-                    comments: true,
-                });
-                out = res?.code || code;
-                wasInstrumented = !!res?.code;
+                        compact: false,
+                        comments: true,
+                    });
+                    out = res?.code || code;
+                    wasInstrumented = !!res?.code;
+                }
                 transformedFiles.add(filename);
             }
         } catch (err) {