@reproapp/node-sdk 0.0.2 → 0.0.4

package/test/promise-map.test.js

@@ -0,0 +1,72 @@
+process.env.TRACE_RELOAD_CACHE = '0';
+require('../tracer/register');
+const assert = require('assert');
+const { trace } = require('../tracer/runtime');
+
+const wait = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+const handlers = [
+    {
+        getRecipients: async () => { await wait(10); return ['a']; },
+        getTemplate: () => 'tmpl1',
+    },
+    {
+        getRecipients: async () => { await wait(1); return ['b']; },
+        getTemplate: () => 'tmpl2',
+    },
+];
+
+async function handlerWorker(handler) {
+    const recipients = await handler.getRecipients();
+    const template = await handler.getTemplate();
+    return { recipients, template };
+}
+
+async function runScenario() {
+    const results = handlers.map(handler => handlerWorker(handler));
+    return Promise.all(results);
+}
+
+async function main() {
+    const events = [];
+    const off = trace.on(ev => { if (ev && ev.traceId === 'map-loop') events.push(ev); });
+
+    await trace.withTrace('map-loop', async () => {
+        await runScenario();
+    });
+
+    // Give any pending promise callbacks a moment to emit their exits.
+    await wait(10);
+    off();
+
+    const enters = (name) => events.filter(ev => ev && ev.type === 'enter' && ev.fn === name);
+
+    const workerEnters = enters('handlerWorker');
+    const recipientsEnters = enters('handler.getRecipients');
+    const templateEnters = enters('handler.getTemplate');
+
+    const uniq = (arr) => Array.from(new Set(arr));
+
+    const workerSpanIds = uniq(workerEnters.map(ev => ev.spanId).filter(Boolean));
+    const recipientSpanIds = new Set(recipientsEnters.map(ev => ev.spanId).filter(Boolean));
+    const templateParentIds = uniq(templateEnters.map(ev => ev.parentSpanId).filter(Boolean));
+
+    assert(workerSpanIds.length >= 2, 'expected at least two handlerWorker spans');
+    assert(recipientsEnters.length >= 2, 'expected two getRecipients entries');
+    assert(templateEnters.length >= 2, 'expected two getTemplate entries');
+    assert.strictEqual(templateParentIds.length, 2, 'expected templates to attach to two distinct handler spans');
+
+    templateEnters.forEach(ev => {
+        assert(workerSpanIds.includes(ev.parentSpanId),
+            'getTemplate should be parented to its map callback (handlerWorker)');
+        assert(!recipientSpanIds.has(ev.parentSpanId),
+            'getTemplate should not be nested under getRecipients span');
+    });
+
+    console.log('promise map + Promise.all trace parenting OK');
+}
+
+main().catch(err => {
+    console.error(err);
+    process.exitCode = 1;
+});

package/test/unawaited.test.js

@@ -0,0 +1,163 @@
+// Integration-style sanity check for unawaited async call ordering.
+const assert = require('assert');
+const { trace, SYM_IS_APP } = require('../tracer/runtime');
+
+function wrapFunction(name, fn, opts = {}) {
+    const { bodyTraced = false } = opts;
+    const wrapped = function wrappedFn(...args) {
+        trace.enter(name, { file: 'app', line: 1 });
+        let result;
+        let err = null;
+        let threw = false;
+        try {
+            result = fn.apply(this, args);
+            return result;
+        } catch (e) {
+            threw = true;
+            err = e;
+            throw e;
+        } finally {
+            trace.exit({ fn: name, file: 'app', line: 1 }, { returnValue: result, error: err, threw });
+        }
+    };
+    try {
+        wrapped[SYM_IS_APP] = true;
+        wrapped.__repro_instrumented = true;
+        if (bodyTraced) wrapped.__repro_body_traced = true;
+    } catch {}
+    return wrapped;
+}
+
+async function testUnawaitedOrdering() {
+    const events = [];
+    const unsubscribe = trace.on(ev => { if (ev && ev.traceId) events.push(ev); });
+
+    // Mock inner async functions.
+    const findNotificationModule = wrapFunction('findNotificationModule', async () => 'config');
+    const loadStudyModuleConfig = wrapFunction('loadStudyModuleConfig', async () => 'studyConfig');
+    const loadStudyConfigUserModule = wrapFunction('loadStudyConfigUserModule', async () => 'userConfig');
+
+    const notifyAboutShipmentDispatch = wrapFunction('notifyAboutShipmentDispatch', async () => {
+        await findNotificationModule();
+        await loadStudyModuleConfig();
+        await loadStudyConfigUserModule();
+        return 'done';
+    }, { bodyTraced: true });
+
+    await trace.withTrace('t1', async () => {
+        const p = global.__repro_call(
+            notifyAboutShipmentDispatch,
+            null,
+            [],
+            'app',
+            1,
+            'notifyAboutShipmentDispatch',
+            true // mark unawaited
+        );
+        // Simulate unawaited usage, but wait so events flush.
+        await p.catch(() => {});
+    });
+
+    unsubscribe();
+
+    const ordered = events.map(ev => `${ev.type}:${ev.fn}`);
+    const expected = [
+        'enter:notifyAboutShipmentDispatch',
+        'enter:findNotificationModule',
+        'exit:findNotificationModule',
+        'enter:loadStudyModuleConfig',
+        'exit:loadStudyModuleConfig',
+        'enter:loadStudyConfigUserModule',
+        'exit:loadStudyConfigUserModule',
+        'exit:notifyAboutShipmentDispatch',
+    ];
+
+    assert.deepStrictEqual(ordered, expected, `Trace order mismatch.\nGot: ${ordered.join(' | ')}\nExpected: ${expected.join(' | ')}`);
+    console.log('unawaited async trace order OK');
+}
+
+async function testUnawaitedSiblingParenting() {
+    const events = [];
+    const off = trace.on(ev => { if (ev && ev.traceId === 't2') events.push(ev); });
+
+    const wait = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+    const unawaitedChild = wrapFunction('unawaitedChild', async () => {
+        await wait(5);
+        return 'child';
+    });
+    const siblingWork = wrapFunction('siblingWork', async () => {
+        await wait(1);
+        return 'sibling';
+    });
+    const parent = wrapFunction('parent', async () => {
+        const childPromise = global.__repro_call(
+            unawaitedChild,
+            null,
+            [],
+            'app',
+            21,
+            'unawaitedChild',
+            true
+        );
+        await global.__repro_call(
+            siblingWork,
+            null,
+            [],
+            'app',
+            22,
+            'siblingWork',
+            false
+        );
+        return { childPromise };
+    });
+
+    const { childPromise } = await trace.withTrace('t2', async () => parent());
+    await childPromise.catch(() => {});
+    await wait(5);
+    off();
+
+    const enterByFn = {};
+    const exitByFn = {};
+    events.forEach(ev => {
+        if (!ev || !ev.fn) return;
+        if (ev.type === 'enter' && !enterByFn[ev.fn]) enterByFn[ev.fn] = ev;
+        if (ev.type === 'exit' && !exitByFn[ev.fn]) exitByFn[ev.fn] = ev;
+    });
+
+    const parentEnter = enterByFn.parent;
+    const childEnter = enterByFn.unawaitedChild;
+    const siblingEnter = enterByFn.siblingWork;
+    assert(parentEnter && childEnter && siblingEnter, 'Missing enter events for parent/child/sibling');
+
+    assert.strictEqual(
+        childEnter.parentSpanId,
+        parentEnter.spanId,
+        'Unawaited child should be parented to the caller span'
+    );
+    assert.strictEqual(
+        siblingEnter.parentSpanId,
+        parentEnter.spanId,
+        'Sibling after unawaited call should not inherit unawaited child as parent'
+    );
+
+    const parentExit = exitByFn.parent;
+    assert(parentExit, 'Missing exit event for parent');
+    assert.strictEqual(
+        parentExit.spanId,
+        parentEnter.spanId,
+        'Parent exit should retain its original span id'
+    );
+
+    console.log('unawaited sibling parenting OK');
+}
+
+async function main() {
+    await testUnawaitedOrdering();
+    await testUnawaitedSiblingParenting();
+}
+
+main().catch(err => {
+    console.error(err);
+    process.exitCode = 1;
+});

package/test/wrap-plugin-arrow-args.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');
+const { trace } = require('../tracer/runtime');
+
+function loadInstrumentedModule(source, filename) {
+    const transformed = babel.transformSync(source, {
+        filename,
+        plugins: [makeWrapPlugin(filename, {})],
+        parserOpts: { sourceType: 'script', plugins: ['typescript'] },
+        generatorOpts: { retainLines: true },
+    });
+
+    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(transformed.code, context, { filename });
+    return module.exports;
+}
+
+function toPlainJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+
+async function main() {
+    const filename = '/tmp/wrap-plugin-arrow-args.fixture.js';
+    const mod = loadInstrumentedModule(`
+        module.exports = {
+            consumerConfig: {
+                eachMessage: async ({ message }) => {
+                    return message.value;
+                },
+            },
+        };
+    `, filename);
+
+    const events = [];
+    const off = trace.on(ev => {
+        if (ev && ev.traceId === 'arrow-args' && ev.type === 'enter' && ev.functionType === 'arrow') {
+            events.push(ev);
+        }
+    });
+
+    const payload = {
+        topic: 'payments.events',
+        partition: 1,
+        message: { value: 'ok' },
+    };
+
+    await trace.withTrace('arrow-args', async () => {
+        const value = await mod.consumerConfig.eachMessage(payload);
+        assert.strictEqual(value, 'ok');
+    });
+
+    off();
+
+    assert.strictEqual(events.length, 1, `expected one arrow enter event, got ${events.length}`);
+    assert.deepStrictEqual(toPlainJson(events[0].args), [payload]);
+
+    console.log('wrap-plugin arrow destructured args OK');
+}
+
+main().catch(err => {
+    console.error(err);
+    process.exitCode = 1;
+});

package/tracer/cjs-hook.js

@@ -67,7 +67,6 @@ function tagExports(value, filename, seen = new WeakSet(), depth = 0, instrument
 
             if (typeof d.get === 'function') {
                 tagExports(d.get, filename, seen, depth + 1, instrumented);
-                try { tagExports(value[k], filename, seen, depth + 1, instrumented); } catch {}
             }
             if (typeof d.set === 'function') {
                 tagExports(d.set, filename, seen, depth + 1, instrumented);

package/tracer/wrap-plugin.js

@@ -155,6 +155,97 @@ module.exports = function makeWrapPlugin(filenameForMeta, opts = {}) {
             return argIndex === call.arguments.length - 1;
         }
 
+        function normalizeArrowParam(param, path) {
+            if (t.isIdentifier(param)) {
+                return {
+                    param: t.cloneNode(param, true),
+                    argExpr: t.cloneNode(param, true),
+                    prelude: null,
+                };
+            }
+
+            if (t.isRestElement(param)) {
+                if (t.isIdentifier(param.argument)) {
+                    return {
+                        param: t.cloneNode(param, true),
+                        argExpr: t.cloneNode(param.argument, true),
+                        prelude: null,
+                    };
+                }
+
+                const tempId = path.scope.generateUidIdentifier('arg');
+                return {
+                    param: t.restElement(t.cloneNode(tempId, true)),
+                    argExpr: t.cloneNode(tempId, true),
+                    prelude: t.variableDeclaration('const', [
+                        t.variableDeclarator(
+                            t.cloneNode(param.argument, true),
+                            t.cloneNode(tempId, true)
+                        )
+                    ]),
+                };
+            }
+
+            if (t.isAssignmentPattern(param)) {
+                if (t.isIdentifier(param.left)) {
+                    return {
+                        param: t.cloneNode(param, true),
+                        argExpr: t.cloneNode(param.left, true),
+                        prelude: null,
+                    };
+                }
+
+                const tempId = path.scope.generateUidIdentifier('arg');
+                return {
+                    param: t.assignmentPattern(
+                        t.cloneNode(tempId, true),
+                        t.cloneNode(param.right, true)
+                    ),
+                    argExpr: t.cloneNode(tempId, true),
+                    prelude: t.variableDeclaration('const', [
+                        t.variableDeclarator(
+                            t.cloneNode(param.left, true),
+                            t.cloneNode(tempId, true)
+                        )
+                    ]),
+                };
+            }
+
+            if (t.isObjectPattern(param) || t.isArrayPattern(param)) {
+                const tempId = path.scope.generateUidIdentifier('arg');
+                return {
+                    param: t.cloneNode(tempId, true),
+                    argExpr: t.cloneNode(tempId, true),
+                    prelude: t.variableDeclaration('const', [
+                        t.variableDeclarator(
+                            t.cloneNode(param, true),
+                            t.cloneNode(tempId, true)
+                        )
+                    ]),
+                };
+            }
+
+            return {
+                param: t.cloneNode(param, true),
+                argExpr: t.identifier('undefined'),
+                prelude: null,
+            };
+        }
+
+        function normalizeArrowParams(path) {
+            if (!path.isArrowFunctionExpression()) {
+                return { argExprs: [], preludes: [] };
+            }
+
+            const normalized = path.node.params.map(param => normalizeArrowParam(param, path));
+            path.node.params = normalized.map(item => item.param);
+
+            return {
+                argExprs: normalized.map(item => item.argExpr),
+                preludes: normalized.map(item => item.prelude).filter(Boolean),
+            };
+        }
+
         function wrap(path){
             const n = path.node;
             if (n.__repro_internal) return;
@@ -190,6 +281,10 @@ module.exports = function makeWrapPlugin(filenameForMeta, opts = {}) {
             const bodyPath = path.get('body');
             if (!bodyPath.isBlockStatement()) return;
             const body = bodyPath.node;
+            const arrowParams = normalizeArrowParams(path);
+            if (arrowParams.preludes.length) {
+                body.body.unshift(...arrowParams.preludes);
+            }
 
             const argsId = path.scope.generateUidIdentifier('args');
             const resultId = path.scope.generateUidIdentifier('result');
@@ -209,16 +304,7 @@ module.exports = function makeWrapPlugin(filenameForMeta, opts = {}) {
                     argsArray
                 )
                 : t.arrayExpression(
-                    n.params.map(param => {
-                        if (t.isIdentifier(param)) return t.cloneNode(param, true);
-                        if (t.isRestElement(param) && t.isIdentifier(param.argument)) {
-                            return t.cloneNode(param.argument, true);
-                        }
-                        if (t.isAssignmentPattern(param) && t.isIdentifier(param.left)) {
-                            return t.cloneNode(param.left, true);
-                        }
-                        return t.identifier('undefined');
-                    })
+                    arrowParams.argExprs.map(argExpr => t.cloneNode(argExpr, true))
                 );
 
             const argsDecl = t.variableDeclaration('const', [

package/dist/redaction.d.ts

@@ -1,44 +0,0 @@
-type RedactionStrategy = 'mask' | 'remove';
-export type RedactionRuleInput = string | RegExp | {
-    match?: string | RegExp;
-    field?: string | RegExp;
-    exact?: boolean;
-    strategy?: RedactionStrategy;
-    maskWith?: string;
-};
-type RedactionFieldMapKey = 'any' | 'headers' | 'body' | 'query' | 'params' | 'respBody' | 'response' | 'responseBody' | 'responseHeaders';
-export type TransportRedactionFields = Partial<Record<RedactionFieldMapKey, RedactionRuleInput[]>>;
-export interface TransportRedactionOptions {
-    /**
-     * Custom mask string for masked values. Default: "*****".
-     */
-    maskWith?: string;
-    /**
-     * Additional rules that apply to specific request/response sections.
-     * Provide field names (case-insensitive), dot-delimited paths, or
-     * regular expressions. Rules declared under `any` apply everywhere.
-     */
-    fields?: TransportRedactionFields;
-}
-type SectionKey = 'any' | 'headers' | 'body' | 'query' | 'params' | 'respBody' | 'responseHeaders';
-type NormalizedRule = {
-    kind: 'string';
-    needle: string;
-    exact: boolean;
-    action: RedactionStrategy;
-    maskWith?: string;
-} | {
-    kind: 'regex';
-    regex: RegExp;
-    action: RedactionStrategy;
-    maskWith?: string;
-};
-export type TransportRedactionState = {
-    maskWith: string;
-    rules: Record<SectionKey, NormalizedRule[]>;
-};
-export declare function configureTransportRedaction(options?: TransportRedactionOptions | null): TransportRedactionState;
-export declare function getTransportRedactionState(): TransportRedactionState;
-export declare function redactPayload<T>(payload: T, stateOverride?: TransportRedactionState | null): T;
-export declare function redactSection<T>(value: T, section: Exclude<SectionKey, 'any'>, stateOverride?: TransportRedactionState | null): T;
-export {};

package/dist/redaction.js

@@ -1,167 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.redactSection = exports.redactPayload = exports.getTransportRedactionState = exports.configureTransportRedaction = void 0;
-const SECTION_KEYS = ['any', 'headers', 'body', 'query', 'params', 'respBody', 'responseHeaders'];
-const DEFAULT_MASK = '*****';
-const DEFAULT_RULES = [
-    { match: /pass(word|phrase)?/i },
-    { match: /pwd/i },
-    { match: /secret/i },
-    { match: /token/i },
-    { match: /authorization/i },
-    { match: /api[_-]?key/i },
-];
-let CURRENT_STATE = buildState();
-function configureTransportRedaction(options) {
-    CURRENT_STATE = buildState(options);
-    return CURRENT_STATE;
-}
-exports.configureTransportRedaction = configureTransportRedaction;
-function getTransportRedactionState() {
-    return CURRENT_STATE;
-}
-exports.getTransportRedactionState = getTransportRedactionState;
-function redactPayload(payload, stateOverride) {
-    const state = stateOverride ?? CURRENT_STATE;
-    applyRules(payload, gatherRules('any', state), state.maskWith);
-    return payload;
-}
-exports.redactPayload = redactPayload;
-function redactSection(value, section, stateOverride) {
-    const state = stateOverride ?? CURRENT_STATE;
-    applyRules(value, gatherRules(section, state), state.maskWith);
-    return value;
-}
-exports.redactSection = redactSection;
-function buildState(options) {
-    const state = {
-        maskWith: typeof options?.maskWith === 'string' && options.maskWith ? options.maskWith : DEFAULT_MASK,
-        rules: SECTION_KEYS.reduce((acc, key) => {
-            acc[key] = [];
-            return acc;
-        }, {}),
-    };
-    appendRules(state.rules.any, DEFAULT_RULES);
-    if (!options?.fields) {
-        return state;
-    }
-    appendRules(state.rules.any, options.fields.any);
-    appendRules(state.rules.headers, options.fields.headers);
-    appendRules(state.rules.body, options.fields.body);
-    appendRules(state.rules.query, options.fields.query);
-    appendRules(state.rules.params, options.fields.params);
-    appendRules(state.rules.respBody, options.fields.respBody);
-    appendRules(state.rules.respBody, options.fields.response);
-    appendRules(state.rules.respBody, options.fields.responseBody);
-    appendRules(state.rules.responseHeaders, options.fields.responseHeaders);
-    return state;
-}
-function appendRules(bucket, inputs) {
-    if (!inputs || !Array.isArray(inputs))
-        return;
-    for (const entry of inputs) {
-        const normalized = normalizeRule(entry);
-        if (normalized)
-            bucket.push(normalized);
-    }
-}
-function normalizeRule(input) {
-    if (!input)
-        return null;
-    if (typeof input === 'string') {
-        const needle = input.trim().toLowerCase();
-        if (!needle)
-            return null;
-        return { kind: 'string', needle, exact: false, action: 'mask' };
-    }
-    if (input instanceof RegExp) {
-        return { kind: 'regex', regex: cloneRegex(input), action: 'mask' };
-    }
-    if (typeof input === 'object') {
-        const pattern = input.match ?? input.field;
-        const exact = !!input.exact;
-        const action = input.strategy === 'remove' ? 'remove' : 'mask';
-        const maskWith = typeof input.maskWith === 'string' && input.maskWith ? input.maskWith : undefined;
-        if (pattern instanceof RegExp) {
-            return { kind: 'regex', regex: cloneRegex(pattern), action, maskWith };
-        }
-        if (typeof pattern === 'string') {
-            const needle = pattern.trim().toLowerCase();
-            if (!needle)
-                return null;
-            return { kind: 'string', needle, exact, action, maskWith };
-        }
-    }
-    return null;
-}
-function cloneRegex(rx) {
-    const flags = rx.flags.includes('g') ? rx.flags.replace(/g/g, '') : rx.flags;
-    return new RegExp(rx.source, flags);
-}
-function gatherRules(section, state) {
-    if (section === 'any')
-        return state.rules.any;
-    return state.rules.any.concat(state.rules[section] ?? []);
-}
-function applyRules(value, rules, defaultMask) {
-    if (!rules.length)
-        return;
-    if (Array.isArray(value)) {
-        for (let i = 0; i < value.length; i++) {
-            const item = value[i];
-            if (item && typeof item === 'object') {
-                applyRules(item, rules, defaultMask);
-            }
-        }
-        return;
-    }
-    if (!isRedactableObject(value))
-        return;
-    for (const key of Object.keys(value)) {
-        const decision = pickDecision(key, rules, defaultMask);
-        if (!decision) {
-            const child = value[key];
-            if (child && typeof child === 'object') {
-                applyRules(child, rules, defaultMask);
-            }
-            continue;
-        }
-        if (decision === 'remove') {
-            delete value[key];
-        }
-        else {
-            value[key] = decision;
-        }
-    }
-}
-function isRedactableObject(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    if (Buffer.isBuffer(value))
-        return false;
-    if (ArrayBuffer.isView(value))
-        return false;
-    if (value instanceof Date || value instanceof RegExp)
-        return false;
-    if (value instanceof Map || value instanceof Set)
-        return false;
-    return true;
-}
-function pickDecision(key, rules, defaultMask) {
-    const lower = key.toLowerCase();
-    for (const rule of rules) {
-        if (rule.kind === 'string') {
-            const match = rule.exact ? lower === rule.needle : lower.includes(rule.needle);
-            if (!match)
-                continue;
-        }
-        else {
-            if (!rule.regex.test(key))
-                continue;
-        }
-        if (rule.action === 'remove')
-            return 'remove';
-        return rule.maskWith ?? defaultMask;
-    }
-    return null;
-}

package/dist/server.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("./index");
-const express = require('express');
-const mongoose = require('mongoose');
-(0, index_1.initReproTracing)();
-const app = express();
-(async () => {
-    await mongoose.connect('mongodb://127.0.0.1:27018', { dbName: 'trace_demo' });
-    const userSchema = new mongoose.Schema({
-        name: String, email: String, age: Number
-    }, { timestamps: true });
-    const User = mongoose.model('User', userSchema);
-    // seed some data
-    // @ts-ignore
-    app.get('/seed', async (_req, res) => {
-        await User.deleteMany({});
-        await User.insertMany([
-            { name: 'Ada', email: 'ada@example.com', age: 27 },
-            { name: 'Lin', email: 'lin@example.com', age: 35 },
-            { name: 'Sam', email: 'sam@example.com', age: 17 },
-        ]);
-        res.json({ ok: true, count: await User.countDocuments() });
-    });
-    app.listen(3000, () => process.stdout.write('listening on http://localhost:3000\n'));
-})();