@reproapp/node-sdk 0.0.44 → 0.0.46

package/dist/index.d.ts

@@ -52,6 +52,7 @@ export type TraceEventForFilter = {
     fn?: string;
     wrapperClass?: string | null;
     file?: string | null;
+    sourceFile?: string | null;
     line?: number | null;
     depth?: number;
     library?: string | null;

package/dist/index.js

@@ -332,6 +332,7 @@ function refreshDisabledFunctionTraceRules() {
 let disabledFunctionTraceRules = computeDisabledFunctionTraceRules();
 let disabledFunctionTypePatterns = [];
 let disabledTraceFilePatterns = [];
+let excludedInstrumentationFilePatterns = [];
 let __TRACE_LOG_PREF = null;
 let __FULL_VALUE_CAPTURE_ENABLED = true;
 function setInterceptorTracingEnabled(enabled) {
@@ -415,7 +416,7 @@ function matchesRule(rule, event) {
     const wrapperPattern = rule.wrapper ?? rule.wrapperClass ?? rule.className ?? rule.owner;
     if (!matchesPattern(event.wrapperClass, wrapperPattern))
         return false;
-    if (!matchesPattern(event.file, rule.file))
+    if (!matchesTraceFile(event, rule.file))
         return false;
     if (!matchesPattern(event.line == null ? null : String(event.line), rule.line))
         return false;
@@ -430,9 +431,23 @@ function matchesRule(rule, event) {
         return false;
     return true;
 }
+function matchesTraceFile(event, pattern, defaultWhenEmpty = true) {
+    if (pattern === undefined || pattern === null)
+        return defaultWhenEmpty;
+    const candidates = [event.file, event.sourceFile].filter((value) => typeof value === 'string' && value.length > 0);
+    if (!candidates.length) {
+        return matchesPattern(null, pattern, defaultWhenEmpty);
+    }
+    return candidates.some((value) => matchesPattern(value, pattern, false));
+}
 function shouldDropTraceEvent(event) {
     if (disabledTraceFilePatterns.length) {
-        if (matchesPattern(event.file, disabledTraceFilePatterns, false)) {
+        if (matchesTraceFile(event, disabledTraceFilePatterns, false)) {
+            return true;
+        }
+    }
+    if (excludedInstrumentationFilePatterns.length) {
+        if (matchesTraceFile(event, excludedInstrumentationFilePatterns, false)) {
             return true;
         }
     }
@@ -599,6 +614,9 @@ function initReproTracing(opts) {
     if (hasOwn(options, 'disableTraceFiles')) {
         setDisabledTraceFiles(options.disableTraceFiles ?? null);
     }
+    if (hasOwn(options, 'exclude')) {
+        excludedInstrumentationFilePatterns = normalizePatternArray(options.exclude);
+    }
     if (hasOwn(options, 'logFunctionCalls') && typeof options.logFunctionCalls === 'boolean') {
         setReproTraceLogsEnabled(options.logFunctionCalls);
     }
@@ -611,7 +629,17 @@ function initReproTracing(opts) {
         __TRACER__ = tracerPkg;
         applyTraceLogPreference(tracerPkg);
         const { disableFunctionTraces: _disableFunctionTraces, disableFunctionTypes: _disableFunctionTypes, disableTraceFiles: _disableTraceFiles, fullValueCapture: _fullValueCapture, logFunctionCalls: _logFunctionCalls, traceInterceptors: _traceInterceptors, ...rest } = options;
-        const initOpts = { ...defaultTracerInitOpts(), ...rest };
+        const defaults = defaultTracerInitOpts();
+        const overrides = rest;
+        const initOpts = {
+            ...defaults,
+            ...overrides,
+            include: overrides.include ?? defaults.include,
+            exclude: [
+                ...(defaults.exclude ?? []),
+                ...(overrides.exclude ?? []),
+            ],
+        };
         tracerPkg.init?.(initOpts);
         tracerPkg.patchHttp?.();
         applyTraceLogPreference(tracerPkg);
@@ -736,6 +764,7 @@ function traceEventCandidateFromRecord(event) {
         fn: event.fn,
         wrapperClass: inferWrapperClassFromFn(event.fn),
         file: event.file ?? null,
+        sourceFile: sourceFileForLibrary,
         line: event.line ?? null,
         depth: event.depth,
         library: inferLibraryNameFromFile(sourceFileForLibrary ?? event.file),
@@ -4875,11 +4904,11 @@ function reproMiddleware(cfg) {
                         ?? await materializeInlinePrivacyValueAsync('response.body', sanitizeRequestSnapshot(capturedBody), captureCfg, maskReq, endpointTraceCtx, masking, activePrivacy);
                 const responseBody = responseBodyMaterialization.value;
                 const requestValueEntries = [];
-                const bodyValueCapture = requestBodyMaterialization.skipped
+                const bodyValueCapture = requestBodyRaw === undefined
                     ? undefined
                     : await maybeCaptureRequestValueAsync({
                         target: 'request.body',
-                        rawValue: req.body,
+                        rawValue: requestBodyRaw,
                         previewValue: requestBody,
                         capture: {
                             runtimeConfig: captureCfg,
@@ -4929,7 +4958,7 @@ function reproMiddleware(cfg) {
                         privacy: activePrivacy,
                     },
                 }, requestValueEntries);
-                const respBodyValueCapture = responseBodyMaterialization.skipped
+                const respBodyValueCapture = capturedBody === undefined
                     ? undefined
                     : await maybeCaptureRequestValueAsync({
                         target: 'response.body',
@@ -6336,6 +6365,7 @@ function recordKafkaTraceEvent(raw, sink, cfg, maskReq) {
         fn: raw.fn,
         wrapperClass: inferWrapperClassFromFn(raw.fn),
         file: raw.file ?? null,
+        sourceFile: sourceFileForLibrary,
         line: typeof raw.line === 'number' ? raw.line : null,
         depth: typeof raw.depth === 'number' ? raw.depth : undefined,
         library: inferLibraryNameFromFile(sourceFileForLibrary ?? raw.file),
@@ -6441,6 +6471,7 @@ function buildPendingKafkaTraceEvent(raw) {
         fn: raw.fn,
         wrapperClass: inferWrapperClassFromFn(raw.fn),
         file: raw.file ?? null,
+        sourceFile: sourceFileForLibrary,
         line: typeof raw.line === 'number' ? raw.line : null,
         depth: typeof raw.depth === 'number' ? raw.depth : undefined,
         library: inferLibraryNameFromFile(sourceFileForLibrary ?? raw.file),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,7 @@
     "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-capture-background.test.js && node test/init-auto-http-server.test.js && node test/backend-live-mode.test.js && node test/client-performance-regression.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/runtime-service-registration.test.js && node test/ingest-queue-retention.test.js && node test/ingest-high-priority-retention.test.js && node test/ingest-critical-retention.test.js && node test/ingest-critical-retry-retention.test.js && node test/ingest-batching.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-service-scope.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js && node test/amqplib-integration.test.js && node test/mongodb-integration.test.js && node test/mongodb-esm-import-hook.test.js && node test/mongodb-suppression-cleanup.test.js && node test/postgresql-integration.test.js",
+    "test": "npm run build && node test/trace-source-exclude.test.js && 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/init-auto-http-server.test.js && node test/backend-live-mode.test.js && node test/client-performance-regression.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/runtime-service-registration.test.js && node test/ingest-queue-retention.test.js && node test/ingest-high-priority-retention.test.js && node test/ingest-critical-retention.test.js && node test/ingest-critical-retry-retention.test.js && node test/ingest-batching.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-service-scope.test.js && node test/privacy-runtime-policy.test.js && node test/runtime-privacy-materialization.test.js && node test/kafka-runtime-privacy-policy.test.js && node test/amqplib-integration.test.js && node test/mongodb-integration.test.js && node test/mongodb-esm-import-hook.test.js && node test/mongodb-suppression-cleanup.test.js && node test/postgresql-integration.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 && node test/mongodb-mongoose-native-suppression.testcontainers.test.js && node test/postgresql-integrations.testcontainers.test.js"
   },
   "peerDependencies": {

package/src/index.ts

@@ -341,6 +341,7 @@ export type TraceEventForFilter = {
     fn?: string;
     wrapperClass?: string | null;
     file?: string | null;
+    sourceFile?: string | null;
     line?: number | null;
     depth?: number;
     library?: string | null;
@@ -606,6 +607,7 @@ function refreshDisabledFunctionTraceRules() {
 let disabledFunctionTraceRules: DisableFunctionTraceConfig[] = computeDisabledFunctionTraceRules();
 let disabledFunctionTypePatterns: Array<string | number | RegExp> = [];
 let disabledTraceFilePatterns: Array<string | number | RegExp> = [];
+let excludedInstrumentationFilePatterns: Array<string | number | RegExp> = [];
 let __TRACE_LOG_PREF: boolean | null = null;
 let __FULL_VALUE_CAPTURE_ENABLED = true;
 
@@ -684,7 +686,7 @@ function matchesRule(rule: DisableFunctionTraceRule, event: TraceEventForFilter)
     const wrapperPattern = rule.wrapper ?? rule.wrapperClass ?? rule.className ?? rule.owner;
     if (!matchesPattern(event.wrapperClass, wrapperPattern)) return false;
 
-    if (!matchesPattern(event.file, rule.file)) return false;
+    if (!matchesTraceFile(event, rule.file)) return false;
     if (!matchesPattern(event.line == null ? null : String(event.line), rule.line)) return false;
 
     const libPattern = rule.lib ?? rule.library;
@@ -699,9 +701,29 @@ function matchesRule(rule: DisableFunctionTraceRule, event: TraceEventForFilter)
     return true;
 }
 
+function matchesTraceFile(
+    event: Pick<TraceEventForFilter, 'file' | 'sourceFile'>,
+    pattern?: TraceRulePattern,
+    defaultWhenEmpty: boolean = true,
+): boolean {
+    if (pattern === undefined || pattern === null) return defaultWhenEmpty;
+    const candidates = [event.file, event.sourceFile].filter(
+        (value): value is string => typeof value === 'string' && value.length > 0,
+    );
+    if (!candidates.length) {
+        return matchesPattern(null, pattern, defaultWhenEmpty);
+    }
+    return candidates.some((value) => matchesPattern(value, pattern, false));
+}
+
 function shouldDropTraceEvent(event: TraceEventForFilter): boolean {
     if (disabledTraceFilePatterns.length) {
-        if (matchesPattern(event.file, disabledTraceFilePatterns, false)) {
+        if (matchesTraceFile(event, disabledTraceFilePatterns, false)) {
+            return true;
+        }
+    }
+    if (excludedInstrumentationFilePatterns.length) {
+        if (matchesTraceFile(event, excludedInstrumentationFilePatterns, false)) {
             return true;
         }
     }
@@ -948,6 +970,9 @@ export function initReproTracing(opts?: ReproTracingInitOptions) {
     if (hasOwn(options, 'disableTraceFiles')) {
         setDisabledTraceFiles(options.disableTraceFiles ?? null);
     }
+    if (hasOwn(options, 'exclude')) {
+        excludedInstrumentationFilePatterns = normalizePatternArray(options.exclude);
+    }
     if (hasOwn(options, 'logFunctionCalls') && typeof options.logFunctionCalls === 'boolean') {
         setReproTraceLogsEnabled(options.logFunctionCalls);
     }
@@ -971,7 +996,17 @@ export function initReproTracing(opts?: ReproTracingInitOptions) {
             traceInterceptors: _traceInterceptors,
             ...rest
         } = options;
-        const initOpts = { ...defaultTracerInitOpts(), ...(rest as TracerInitOpts) };
+        const defaults = defaultTracerInitOpts();
+        const overrides = rest as TracerInitOpts;
+        const initOpts = {
+            ...defaults,
+            ...overrides,
+            include: overrides.include ?? defaults.include,
+            exclude: [
+                ...(defaults.exclude ?? []),
+                ...(overrides.exclude ?? []),
+            ],
+        };
         tracerPkg.init?.(initOpts);
         tracerPkg.patchHttp?.();
         applyTraceLogPreference(tracerPkg);
@@ -1094,6 +1129,7 @@ function traceEventCandidateFromRecord(event: PendingTraceEventRecord): TraceEve
         fn: event.fn,
         wrapperClass: inferWrapperClassFromFn(event.fn),
         file: event.file ?? null,
+        sourceFile: sourceFileForLibrary,
         line: event.line ?? null,
         depth: event.depth,
         library: inferLibraryNameFromFile(sourceFileForLibrary ?? event.file),
@@ -6036,11 +6072,11 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         );
                 const responseBody = responseBodyMaterialization.value;
                 const requestValueEntries: TraceValueBatchEntry[] = [];
-                const bodyValueCapture = requestBodyMaterialization.skipped
+                const bodyValueCapture = requestBodyRaw === undefined
                     ? undefined
                     : await maybeCaptureRequestValueAsync({
                         target: 'request.body',
-                        rawValue: (req as any).body,
+                        rawValue: requestBodyRaw,
                         previewValue: requestBody,
                         capture: {
                             runtimeConfig: captureCfg,
@@ -6090,7 +6126,7 @@ export function reproMiddleware(cfg: ReproMiddlewareConfig) {
                         privacy: activePrivacy,
                     },
                 }, requestValueEntries);
-                const respBodyValueCapture = responseBodyMaterialization.skipped
+                const respBodyValueCapture = capturedBody === undefined
                     ? undefined
                     : await maybeCaptureRequestValueAsync({
                         target: 'response.body',
@@ -7595,6 +7631,7 @@ function recordKafkaTraceEvent(
         fn: raw.fn,
         wrapperClass: inferWrapperClassFromFn(raw.fn),
         file: raw.file ?? null,
+        sourceFile: sourceFileForLibrary,
         line: typeof raw.line === 'number' ? raw.line : null,
         depth: typeof raw.depth === 'number' ? raw.depth : undefined,
         library: inferLibraryNameFromFile(sourceFileForLibrary ?? raw.file),
@@ -7727,6 +7764,7 @@ function buildPendingKafkaTraceEvent(raw: any): PendingTraceEventRecord | null {
         fn: raw.fn,
         wrapperClass: inferWrapperClassFromFn(raw.fn),
         file: raw.file ?? null,
+        sourceFile: sourceFileForLibrary,
         line: typeof raw.line === 'number' ? raw.line : null,
         depth: typeof raw.depth === 'number' ? raw.depth : undefined,
         library: inferLibraryNameFromFile(sourceFileForLibrary ?? raw.file),

package/test/client-performance-regression.test.js

@@ -142,6 +142,8 @@ async function main() {
         }
 
         const large = makeReqRes('S_perf_large_payload', 'A_perf_large_payload', '/large-payload');
+        large.req.method = 'POST';
+        large.req.body = largePayload();
         await invokeMiddleware(middleware, large.req, large.res, async () => {
             const traced = global.__repro_call(
                 largeTraceReturn,
@@ -160,12 +162,48 @@ async function main() {
 
         const backendRequest = eventsOf(capturedBodies, 'backend_request')[0]?.payload?.request;
         assert(backendRequest, JSON.stringify(capturedBodies));
+        assert.equal(backendRequest.body, undefined, JSON.stringify(backendRequest));
+        assert.equal(
+            backendRequest.bodyMaterialization?.reason,
+            'inline-size-limit',
+            JSON.stringify(backendRequest),
+        );
+        assert.equal(
+            backendRequest.bodyValueCapture?.status,
+            'stored',
+            JSON.stringify(backendRequest),
+        );
         assert.equal(backendRequest.respBody, undefined, JSON.stringify(backendRequest));
         assert.equal(
             backendRequest.respBodyMaterialization?.reason,
             'inline-size-limit',
             JSON.stringify(backendRequest),
         );
+        assert.equal(
+            backendRequest.respBodyValueCapture?.status,
+            'stored',
+            JSON.stringify(backendRequest),
+        );
+
+        const requestValues = eventsOf(capturedBodies, 'backend_request')
+            .flatMap((event) => Array.isArray(event?.payload?.requestValues) ? event.payload.requestValues : []);
+        const capturedRequestBody = requestValues.find((entry) =>
+            entry?.id === backendRequest.bodyValueCapture.valueId &&
+            entry?.target === 'request.body'
+        );
+        const capturedResponseBody = requestValues.find((entry) =>
+            entry?.id === backendRequest.respBodyValueCapture.valueId &&
+            entry?.target === 'response.body'
+        );
+        assert(capturedRequestBody, JSON.stringify(requestValues));
+        assert(capturedResponseBody, JSON.stringify(requestValues));
+        assert.equal(capturedRequestBody.value?.rows?.length, 400, JSON.stringify(capturedRequestBody));
+        assert.equal(capturedResponseBody.value?.rows?.length, 400, JSON.stringify(capturedResponseBody));
+        assert.equal(
+            capturedResponseBody.value.rows[399].depot,
+            'depot-399',
+            JSON.stringify(capturedResponseBody),
+        );
 
         const traceEvents = eventsOf(capturedBodies, 'trace_batch')
             .flatMap((event) => Array.isArray(event?.payload?.trace) ? event.payload.trace : []);

package/test/kafka-runtime-privacy-policy.test.js

@@ -307,7 +307,7 @@ async function testKafkaTraceFlushIsNotBlockedForeverByActiveHttpRequest() {
     }
 }
 
-async function testLargeHttpResponseBodyKeepsRequestMetadataWithoutInlineBody() {
+async function testLargeHttpResponseBodyKeepsFullValueOutOfBand() {
     const marker = 'OVERSIZED_HTTP_RESPONSE_MARKER';
     const capturedBodies = [];
     const originalFetch = global.fetch;
@@ -344,13 +344,28 @@ async function testLargeHttpResponseBodyKeepsRequestMetadataWithoutInlineBody()
             return text.includes('"event_type":"backend_request"') &&
                 text.includes('"reason":"inline-size-limit"');
         }));
-        const text = JSON.stringify(capturedBodies);
-        assert(!text.includes(marker), text);
-        assert(text.includes('respBodyMaterialization'), text);
-        assert(text.includes('"target":"response.body"'), text);
-        assert(!text.includes('__type":"json-string'), text);
-        assert(!text.includes('__truncatedKeys'), text);
-        assert(!text.includes('more chars'), text);
+        const backendEvent = capturedBodies
+            .flatMap((body) => Array.isArray(body?.events) ? body.events : [])
+            .find((event) => event?.event_type === 'backend_request');
+        const request = backendEvent?.payload?.request;
+        const requestValues = backendEvent?.payload?.requestValues;
+        assert(request, JSON.stringify(capturedBodies));
+        assert.strictEqual(request.respBody, undefined, JSON.stringify(request));
+        assert.strictEqual(request.respBodyMaterialization?.reason, 'inline-size-limit');
+        assert.strictEqual(request.respBodyValueCapture?.status, 'stored');
+        assert(!JSON.stringify(request).includes(marker), JSON.stringify(request));
+        const capturedResponse = requestValues?.find((entry) =>
+            entry?.id === request.respBodyValueCapture.valueId &&
+            entry?.target === 'response.body'
+        );
+        assert(capturedResponse, JSON.stringify(requestValues));
+        assert.strictEqual(
+            capturedResponse.value?.payload,
+            `${marker}:${'x'.repeat(12 * 1024)}`,
+        );
+        assert(!JSON.stringify(request).includes('__type":"json-string'), JSON.stringify(request));
+        assert(!JSON.stringify(request).includes('__truncatedKeys'), JSON.stringify(request));
+        assert(!JSON.stringify(request).includes('more chars'), JSON.stringify(request));
     } finally {
         await flushIngestQueue();
         global.fetch = originalFetch;
@@ -746,7 +761,7 @@ async function main() {
     await testKafkaConsumerTraceUsesConsumeTraceId();
     await testKafkaProducerCapturesFullPublishedMessageValue();
     await testKafkaTraceFlushIsNotBlockedForeverByActiveHttpRequest();
-    await testLargeHttpResponseBodyKeepsRequestMetadataWithoutInlineBody();
+    await testLargeHttpResponseBodyKeepsFullValueOutOfBand();
     await testJsonBuiltinTracePayloadsAreOmitted();
     await testLargeStringTraceValuesStayIngestibleAndCaptureFullValueOutOfBand();
     await testLargeStructuredTraceValuesStayIngestibleAndCaptureFullValueOutOfBand();

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) {