@reproapp/node-sdk 0.0.2 → 0.0.4

package/src/trace-materializer-worker.ts

@@ -0,0 +1,39 @@
+import { parentPort } from 'node:worker_threads';
+import { __materializePendingTraceEventsForWorker } from './index';
+
+type TraceMaterializationWorkerRequest = {
+    taskId: number;
+    type: 'materialize-trace-events';
+    payload: any;
+};
+
+function isTraceMaterializationWorkerRequest(value: unknown): value is TraceMaterializationWorkerRequest {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const message = value as TraceMaterializationWorkerRequest;
+    return Number.isFinite(message.taskId) && message.type === 'materialize-trace-events' && !!message.payload;
+}
+
+parentPort?.on('message', (message: unknown) => {
+    if (!isTraceMaterializationWorkerRequest(message)) {
+        return;
+    }
+
+    void (async () => {
+        try {
+            const events = await __materializePendingTraceEventsForWorker(message.payload);
+            parentPort?.postMessage({
+                taskId: message.taskId,
+                ok: true,
+                events,
+            });
+        } catch (err) {
+            parentPort?.postMessage({
+                taskId: message.taskId,
+                ok: false,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    })();
+});

package/test/circular-capture.test.js

@@ -0,0 +1,111 @@
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+process.env.TRACE_IDLE_FLUSH_MS = '25';
+process.env.SESSION_DRAIN_TIMEOUT_MS = '0';
+
+const assert = require('assert');
+const { EventEmitter } = require('events');
+const { initReproTracing, reproMiddleware } = require('../dist');
+
+function makeReqRes() {
+    const req = new EventEmitter();
+    req.method = 'POST';
+    req.url = '/circular';
+    req.headers = {
+        'content-type': 'application/json',
+        'x-bug-session-id': 'sid-circular',
+        'x-bug-action-id': 'aid-circular',
+        'x-bug-request-start': String(Date.now()),
+    };
+    req.body = { ok: true };
+    req.params = {};
+    req.query = {};
+
+    const res = new EventEmitter();
+    res.statusCode = 200;
+    res.getHeader = () => undefined;
+    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 readTraceArray(value) {
+    if (Array.isArray(value)) return value;
+    if (typeof value !== 'string') return [];
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : [];
+    } catch {
+        return [];
+    }
+}
+
+function collectTraceEvents(posts) {
+    const events = [];
+    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 : []) {
+            events.push(...readTraceArray(entry?.trace));
+            events.push(...readTraceArray(entry?.request?.trace));
+        }
+        for (const event of Array.isArray(payload?.events) ? payload.events : []) {
+            events.push(...readTraceArray(event?.payload?.trace));
+            events.push(...readTraceArray(event?.payload?.request?.trace));
+        }
+    }
+    return events;
+}
+
+async function circularFn() {
+    const subject = { name: 'Avery Debugson' };
+    const root = { subject, copy: subject };
+    subject.parent = root;
+    return root;
+}
+
+async function main() {
+    const posts = [];
+    global.fetch = async (url, opts = {}) => {
+        posts.push({ url: String(url), body: opts.body });
+        return { ok: true, status: 200, json: async () => ({ ok: true }) };
+    };
+
+    initReproTracing({ instrument: false, logFunctionCalls: false });
+    const middleware = reproMiddleware({
+        appId: 'app',
+        tenantId: 'tenant',
+        appSecret: 'secret',
+        captureHeaders: false,
+    });
+    const { req, res } = makeReqRes();
+
+    await new Promise((resolve, reject) => {
+        middleware(req, res, async () => {
+            try {
+                await global.__repro_call(circularFn, null, [], 'app', 1, 'circularFn', false);
+                res.json({ ok: true });
+                resolve();
+            } catch (err) {
+                reject(err);
+            }
+        });
+    });
+    await new Promise((resolve) => setTimeout(resolve, 120));
+
+    const exitEvent = collectTraceEvents(posts).find((event) => event?.fn === 'circularFn' && event?.type === 'exit');
+    assert(exitEvent, 'expected circularFn exit trace');
+    assert.strictEqual(exitEvent.returnValue.copy.__reproCircularRef, '$.subject');
+    assert.strictEqual(exitEvent.returnValue.subject.parent.__reproCircularRef, '$');
+    assert(!JSON.stringify(exitEvent).includes('[Circular]'), 'expected path references instead of opaque [Circular] strings');
+
+    console.log('circular capture references OK');
+}
+
+main().catch((err) => {
+    console.error(err);
+    process.exitCode = 1;
+});

package/test/disable-subtree.test.js

@@ -0,0 +1,154 @@
+// Integration-style test: disabling a function trace should also suppress its descendants.
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+process.env.TRACE_IDLE_FLUSH_MS = '25';
+process.env.SESSION_DRAIN_TIMEOUT_MS = '0';
+
+const assert = require('assert');
+const { EventEmitter } = require('events');
+const { initReproTracing, reproMiddleware, setDisabledFunctionTraces } = require('../dist');
+
+global.fetch = async () => ({ ok: true, status: 200, json: async () => ({ ok: true }) });
+
+const childFn = async function childFn() {
+    return { ok: true };
+};
+
+const parentFn = async function parentFn() {
+    // Trace the child call so we can verify subtree suppression.
+    await global.__repro_call(childFn, null, [], 'app', 2, 'childFn', false);
+    return { ok: true };
+};
+
+function makeReqRes(sessionId, actionId) {
+    const req = new EventEmitter();
+    req.method = 'POST';
+    req.url = '/test';
+    req.headers = {
+        'content-type': 'application/json',
+        'x-bug-session-id': sessionId,
+        'x-bug-action-id': actionId,
+        'x-bug-request-start': String(Date.now()),
+    };
+    req.body = { ok: true };
+    req.params = {};
+    req.query = {};
+
+    const res = new EventEmitter();
+    res.statusCode = 200;
+    res.getHeader = () => undefined;
+    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 collectTraceFnsFromPosts(posts) {
+    const readTraceArray = (value) => {
+        if (Array.isArray(value)) return value;
+        if (typeof value !== 'string') return null;
+        try {
+            const parsed = JSON.parse(value);
+            return Array.isArray(parsed) ? parsed : null;
+        } catch {
+            return null;
+        }
+    };
+
+    const fns = [];
+    for (const post of posts) {
+        let payload;
+        try { payload = JSON.parse(String(post.body || '')); } catch { continue; }
+        const entries = Array.isArray(payload?.entries) ? payload.entries : [];
+        for (const entry of entries) {
+            const entryTrace = readTraceArray(entry?.trace);
+            if (entryTrace) {
+                entryTrace.forEach(ev => { if (ev && ev.fn) fns.push(String(ev.fn)); });
+            }
+
+            const requestTrace = readTraceArray(entry?.request?.trace);
+            if (requestTrace) {
+                requestTrace.forEach(ev => { if (ev && ev.fn) fns.push(String(ev.fn)); });
+            }
+        }
+
+        const events = Array.isArray(payload?.events) ? payload.events : [];
+        for (const event of events) {
+            const payloadTrace = readTraceArray(event?.payload?.trace);
+            if (payloadTrace) {
+                payloadTrace.forEach(ev => { if (ev && ev.fn) fns.push(String(ev.fn)); });
+            }
+
+            const payloadRequestTrace = readTraceArray(event?.payload?.request?.trace);
+            if (payloadRequestTrace) {
+                payloadRequestTrace.forEach(ev => { if (ev && ev.fn) fns.push(String(ev.fn)); });
+            }
+        }
+    }
+    return fns;
+}
+
+async function runScenario(disableRules) {
+    const posts = [];
+    global.fetch = async (url, opts = {}) => {
+        posts.push({ url: String(url), body: opts.body });
+        return { ok: true, status: 200, json: async () => ({ ok: true }) };
+    };
+
+    setDisabledFunctionTraces(disableRules ?? null);
+
+    const middleware = reproMiddleware({
+        appId: 'app',
+        tenantId: 'tenant',
+        appSecret: 'secret',
+        captureHeaders: false,
+    });
+
+    const { req, res } = makeReqRes('sid', disableRules ? 'aid-disabled' : 'aid-enabled');
+
+    await new Promise((resolve, reject) => {
+        middleware(req, res, async () => {
+            try {
+                await global.__repro_call(parentFn, null, [], 'app', 1, 'parentFn', false);
+                res.json({ ok: true });
+                resolve();
+            } catch (err) {
+                reject(err);
+            }
+        });
+    });
+
+    // Allow flush timers to send payloads.
+    await new Promise(r => setTimeout(r, 120));
+
+    return collectTraceFnsFromPosts(posts);
+}
+
+async function main() {
+    initReproTracing({ instrument: false, logFunctionCalls: false });
+
+    const enabled = await runScenario(null);
+    assert(
+        enabled.includes('parentFn') && enabled.includes('childFn'),
+        `expected parentFn + childFn traces when enabled, got: ${enabled.join(', ')}`
+    );
+
+    const disabled = await runScenario([{ fn: 'parentFn' }]);
+    assert(
+        !disabled.includes('parentFn'),
+        `expected parentFn trace to be disabled, got: ${disabled.join(', ')}`
+    );
+    assert(
+        !disabled.includes('childFn'),
+        `expected childFn trace to be disabled as descendant, got: ${disabled.join(', ')}`
+    );
+
+    console.log('disableFunctionTraces subtree suppression OK');
+}
+
+main().catch(err => {
+    console.error(err);
+    process.exitCode = 1;
+});

package/test/integration-unawaited.js

@@ -0,0 +1,183 @@
+// Integration test: unawaited async function traced through reproMiddleware + tracer.
+// Uses actual SDK middleware + tracer runtime, stubbing network posts.
+const assert = require('assert');
+const { EventEmitter } = require('events');
+const { initReproTracing, reproMiddleware } = require('../dist');
+const { trace } = require('../tracer/runtime');
+
+// Stub fetch to capture payloads sent by SDK (no real network).
+global.fetch = async (url, opts = {}) => {
+    return { ok: true, status: 200, json: async () => ({ ok: true }) };
+};
+
+// Fake services and functions that mirror user scenario.
+const studyConfigService = {
+    findNotificationModule: async (protocolId) => ({ id: protocolId, cfg: 'notif' }),
+    loadStudyModuleConfig: async (protocolId) => ({ id: protocolId, cfg: 'study' }),
+    loadStudyConfigUserModule: async (protocolId) => ({ id: protocolId, cfg: 'user' }),
+};
+
+const notifyAboutShipmentDispatch = async function notifyAboutShipmentDispatch(protocolId) {
+    const notificationConfig = await global.__repro_call(
+        studyConfigService.findNotificationModule,
+        studyConfigService,
+        [protocolId],
+        'app',
+        10,
+        'findNotificationModule',
+        false
+    );
+    const studyModuleConfig = await global.__repro_call(
+        studyConfigService.loadStudyModuleConfig,
+        studyConfigService,
+        [protocolId],
+        'app',
+        11,
+        'loadStudyModuleConfig',
+        false
+    );
+    const userModuleConfig = await global.__repro_call(
+        studyConfigService.loadStudyConfigUserModule,
+        studyConfigService,
+        [protocolId],
+        'app',
+        12,
+        'loadStudyConfigUserModule',
+        false
+    );
+    return { notificationConfig, studyModuleConfig, userModuleConfig };
+};
+
+const handleNotificationError = async function handleNotificationError(promise) {
+    try { await promise; } catch (err) { return { error: String(err) }; }
+    return { ok: true };
+};
+
+async function main() {
+    // Init tracer before defining app so ALS is ready.
+    initReproTracing({ instrument: false, logFunctionCalls: false });
+
+    const middleware = reproMiddleware({
+        appId: 'app',
+        appSecret: 'secret',
+        captureHeaders: false,
+    });
+    const handler = middleware;
+
+    const req = new EventEmitter();
+    req.method = 'POST';
+    req.url = '/notify';
+    req.headers = {
+        'content-type': 'application/json',
+        'x-bug-session-id': 'sid',
+        'x-bug-action-id': 'aid',
+        'x-bug-request-start': String(Date.now()),
+    };
+    req.body = { protocolId: 'proto-123' };
+    const rid = req.headers['x-bug-request-start'];
+
+    const emitted = [];
+    const unsub = trace.on(ev => { emitted.push(ev); });
+
+    const res = new EventEmitter();
+    res.statusCode = 200;
+    res.getHeader = () => undefined;
+    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 = function () { return true; };
+    res.end = function () { this.emit('finish'); return true; };
+
+    const route = async () => {
+        const protocolId = String((req.body && req.body.protocolId) || 'p1');
+        const p = global.__repro_call(
+            notifyAboutShipmentDispatch,
+            null,
+            [protocolId],
+            'app',
+            1,
+            'notifyAboutShipmentDispatch',
+            true // mark unawaited
+        );
+        handleNotificationError(p); // fire-and-forget
+        const snapshot = await studyConfigService.findNotificationModule(protocolId);
+        res.json({ ok: true, snapshot });
+    };
+
+    await new Promise((resolve, reject) => {
+        handler(req, res, async () => {
+            try { await route(); resolve(); } catch (err) { reject(err); }
+        });
+    });
+
+    await new Promise(r => setTimeout(r, 80)); // allow flush
+    unsub();
+
+    // Rebuild parent/child ordering similar to SDK reorder.
+    const interestingFns = new Set([
+        'notifyAboutShipmentDispatch',
+        'findNotificationModule',
+        'loadStudyModuleConfig',
+        'loadStudyConfigUserModule'
+    ]);
+    const filtered = emitted.filter(ev => interestingFns.has(ev.fn));
+
+    const normalizeId = v => (v === null || v === undefined ? null : String(v));
+    const nodes = new Map();
+    const roots = [];
+    filtered.forEach((ev, idx) => {
+        const sid = normalizeId(ev.spanId);
+        const pid = normalizeId(ev.parentSpanId);
+        if (!sid) {
+            roots.push({ order: idx, ev });
+            return;
+        }
+        let node = nodes.get(sid);
+        if (!node) {
+            node = { id: sid, parentId: pid, enter: null, exit: null, children: [], order: idx };
+            nodes.set(sid, node);
+        }
+        node.parentId = pid;
+        node.order = Math.min(node.order, idx);
+        if (ev.type === 'enter' && !node.enter) node.enter = ev;
+        if (ev.type === 'exit') node.exit = ev;
+    });
+
+    nodes.forEach(node => {
+        if (node.parentId && nodes.has(node.parentId)) {
+            nodes.get(node.parentId).children.push(node);
+        } else {
+            roots.push(node);
+        }
+    });
+    nodes.forEach(node => node.children.sort((a, b) => a.order - b.order));
+    roots.sort((a, b) => a.order - b.order);
+
+    const ordered = [];
+    const emitNode = n => {
+        if (n.enter) ordered.push(n.enter);
+        n.children.forEach(emitNode);
+        if (n.exit) ordered.push(n.exit);
+    };
+    roots.forEach(r => {
+        if (r.ev) ordered.push(r.ev); else emitNode(r);
+    });
+
+    const seq = ordered.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(seq, expected, `Trace order mismatch.\nGot: ${seq.join(' | ')}\nExpected: ${expected.join(' | ')}`);
+    console.log('integration unawaited trace OK');
+}
+
+main().catch(err => {
+    console.error(err);
+    process.exitCode = 1;
+});