@reproapp/node-sdk 0.0.47 → 0.0.49

package/test/content-addressed-trace-values.test.js

@@ -0,0 +1,264 @@
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '50';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS = '2048';
+process.env.REPRO_TRACE_BATCH_MAX_SERIALIZED_BYTES = '65536';
+process.env.TRACE_IDLE_FLUSH_MS = '10';
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+
+const assert = require('node:assert/strict');
+const { EventEmitter } = require('node:events');
+const { initReproTracing, reproMiddleware, __reproTestHooks } = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+const { normalizeRuntimePrivacyPolicy } = require('../dist/privacy');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function makeReqRes(sessionId, actionId) {
+    const req = new EventEmitter();
+    req.method = 'POST';
+    req.url = '/content-addressed-values';
+    req.originalUrl = req.url;
+    req.headers = {
+        'x-bug-session-id': sessionId,
+        'x-bug-action-id': actionId,
+        'x-bug-request-start': String(Date.now()),
+    };
+    req.body = {};
+    req.params = {};
+    req.query = {};
+
+    const res = new EventEmitter();
+    res.statusCode = 204;
+    res.getHeader = () => undefined;
+    res.getHeaders = () => ({});
+    res.setHeader = () => {};
+    res.write = () => true;
+    res.end = function end() {
+        this.emit('finish');
+        return this;
+    };
+    return { req, res };
+}
+
+function makePayload(changed = false, internalSecret) {
+    const payload = {
+        eventType: 'clinical.shipment.observed',
+        shipmentNumber: changed ? 'SHIP-CONTENT-CHANGED' : 'SHIP-CONTENT-STABLE',
+        rows: Array.from({ length: 300 }, (_, index) => ({
+            index,
+            depot: `DEPOT-${String(index).padStart(4, '0')}`,
+            site: {
+                number: `SITE-${index % 20}`,
+                country: { code: 'US', region: 'FDA' },
+            },
+            status: index % 2 === 0 ? 'available' : 'released',
+        })),
+    };
+    if (internalSecret !== undefined) {
+        payload.internalSecret = internalSecret;
+    }
+    return payload;
+}
+
+function observePayload(payload) {
+    return payload.shipmentNumber;
+}
+
+async function runRequest(config, sessionId, repeatedPayload, changedPayload = makePayload(true)) {
+    const posts = [];
+    const previousFetch = global.fetch;
+    global.fetch = async (_url, init = {}) => {
+        posts.push(JSON.parse(String(init.body || '{}')));
+        return {
+            ok: true,
+            status: 202,
+            json: async () => ({ ok: true }),
+            text: async () => '{"ok":true}',
+        };
+    };
+
+    const middleware = reproMiddleware(config);
+    const { req, res } = makeReqRes(sessionId, `A_${sessionId}`);
+    try {
+        await new Promise((resolve, reject) => {
+            middleware(req, res, async (error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                try {
+                    for (let index = 0; index < 60; index += 1) {
+                        const result = global.__repro_call(
+                            observePayload,
+                            null,
+                            [repeatedPayload],
+                            '/app/shipments.service.ts',
+                            70,
+                            'observePayload',
+                            false,
+                        );
+                        assert.equal(result, repeatedPayload.shipmentNumber);
+                    }
+                    const changedResult = global.__repro_call(
+                        observePayload,
+                        null,
+                        [changedPayload],
+                        '/app/shipments.service.ts',
+                        75,
+                        'observePayload',
+                        false,
+                    );
+                    assert.equal(changedResult, changedPayload.shipmentNumber);
+                    res.end();
+                    resolve();
+                } catch (traceError) {
+                    reject(traceError);
+                }
+            });
+        });
+
+        const deadline = Date.now() + 5000;
+        while (Date.now() < deadline) {
+            const events = posts.flatMap((post) => post.events || []);
+            if (events.some((event) => event.event_type === 'backend_request') &&
+                events.some((event) => event.event_type === 'trace_batch')) {
+                break;
+            }
+            await sleep(20);
+        }
+        await __reproTestHooks.drainSdkBackgroundQueueForTest();
+        await flushIngestQueue();
+        return posts;
+    } finally {
+        global.fetch = previousFetch;
+    }
+}
+
+function inspectCapture(posts) {
+    const ingestEvents = posts.flatMap((post) => post.events || []);
+    const traceBatches = ingestEvents.filter((event) => event.event_type === 'trace_batch');
+    const traceEvents = traceBatches.flatMap((event) => event.payload?.trace || []);
+    const observedEvents = traceEvents.filter((event) => event.fn === 'observePayload');
+    const definitions = traceBatches.flatMap((event) => event.payload?.traceValues || []);
+    const refs = observedEvents
+        .map((event) => event.argsValueCapture?.valueId)
+        .filter((valueId) => typeof valueId === 'string');
+    return { ingestEvents, traceBatches, observedEvents, definitions, refs };
+}
+
+async function main() {
+    const config = {
+        tenantId: 'TENANT_content_addressed',
+        appId: 'APP_content_addressed',
+        appSecret: 'content-addressed-test-secret',
+        captureHeaders: false,
+        privacy: { environment: 'dev', captureRaw: true },
+        ingestBase: 'http://127.0.0.1:65535',
+    };
+
+    initReproTracing({ instrument: false, fullValueCapture: true, logFunctionCalls: false });
+    __reproTestHooks.resetSdkBackgroundQueuesForTest();
+
+    const repeatedPayload = makePayload(false);
+    const first = inspectCapture(await runRequest(config, 'S_content_addressed_one', repeatedPayload));
+
+    assert.equal(first.observedEvents.length, 122, 'each invocation must retain enter and exit evidence');
+    assert.equal(first.refs.length, 122, 'every large argument occurrence must retain a resolvable ref');
+    assert.equal(new Set(first.refs).size, 2, 'only stable and changed values should receive IDs');
+    assert.equal(first.definitions.length, 2, 'each distinct value must be defined once per request');
+    assert.equal(new Set(first.definitions.map((entry) => entry.id)).size, 2);
+
+    for (const ref of first.refs) {
+        assert(first.definitions.some((entry) => entry.id === ref), `unresolved captured value ref ${ref}`);
+    }
+    const stableDefinition = first.definitions.find((entry) =>
+        entry.value?.[0]?.shipmentNumber === 'SHIP-CONTENT-STABLE'
+    );
+    assert(stableDefinition, JSON.stringify(first.definitions));
+    assert.equal(stableDefinition.value[0].rows.length, 300);
+    assert.equal(stableDefinition.value[0].rows[299].depot, 'DEPOT-0299');
+
+    const serializedBytes = Buffer.byteLength(JSON.stringify(first.traceBatches));
+    assert(serializedBytes < 250000, `repeated values inflated trace transport to ${serializedBytes} bytes`);
+
+    __reproTestHooks.resetSdkBackgroundQueuesForTest();
+    const second = inspectCapture(await runRequest(config, 'S_content_addressed_two', repeatedPayload));
+    assert.equal(second.definitions.length, 2);
+    assert.notEqual(
+        first.definitions[0].id,
+        second.definitions[0].id,
+        'content IDs must be session-scoped to prevent cross-session correlation',
+    );
+
+    const secretPolicy = normalizeRuntimePrivacyPolicy({
+        environment: 'dev',
+        groups: [
+            {
+                gid: 'content-addressed-secret-policy',
+                scope: 'FIELD',
+                selector: 'field:internalSecret',
+                statements: [
+                    {
+                        sid: 'drop-trace-argument-secret',
+                        when: {
+                            scope: 'FIELD',
+                            selector: 'field:internalSecret',
+                            target: 'trace.args[].internalSecret',
+                        },
+                        apply: { action: 'DROP' },
+                        meta: { priority: 1 },
+                    },
+                ],
+            },
+        ],
+    });
+    assert(secretPolicy);
+
+    const policyConfig = {
+        ...config,
+        appId: 'APP_content_addressed_policy',
+        privacy: { environment: 'dev' },
+    };
+    __reproTestHooks.setRuntimePrivacyPolicyForTest(policyConfig, secretPolicy);
+    __reproTestHooks.resetSdkBackgroundQueuesForTest();
+    const policyCapture = inspectCapture(await runRequest(
+        policyConfig,
+        'S_content_addressed_policy',
+        makePayload(false, 'policy-secret-alpha'),
+        makePayload(false, 'policy-secret-beta'),
+    ));
+    assert.equal(policyCapture.refs.length, 122);
+    assert.equal(new Set(policyCapture.refs).size, 1);
+    assert.equal(policyCapture.definitions.length, 1);
+    const policySerialized = JSON.stringify(policyCapture.definitions);
+    assert(!policySerialized.includes('policy-secret-alpha'), policySerialized);
+    assert(!policySerialized.includes('policy-secret-beta'), policySerialized);
+    assert(policySerialized.includes('[dropped]'), policySerialized);
+
+    const rawConfig = {
+        ...config,
+        appId: 'APP_content_addressed_raw',
+        privacy: { environment: 'dev', captureRaw: true },
+    };
+    __reproTestHooks.setRuntimePrivacyPolicyForTest(rawConfig, secretPolicy);
+    __reproTestHooks.resetSdkBackgroundQueuesForTest();
+    const rawCapture = inspectCapture(await runRequest(
+        rawConfig,
+        'S_content_addressed_raw',
+        makePayload(false, 'raw-secret-alpha'),
+        makePayload(false, 'raw-secret-beta'),
+    ));
+    assert.equal(new Set(rawCapture.refs).size, 2);
+    assert.equal(rawCapture.definitions.length, 2);
+    const rawSerialized = JSON.stringify(rawCapture.definitions);
+    assert(rawSerialized.includes('raw-secret-alpha'), rawSerialized);
+    assert(rawSerialized.includes('raw-secret-beta'), rawSerialized);
+
+    console.log('content-addressed trace value deduplication OK');
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/test/fixtures/semantic-serialization-trace-controller.js

@@ -0,0 +1,85 @@
+class Logger {
+    constructor(context) {
+        this.context = context;
+        this.internalBuffer = Array.from({ length: 200 }, () => 'logger-runtime-state');
+    }
+
+    log() {}
+}
+
+class ConfigService {
+    constructor() {
+        this.cache = {
+            DATABASE_URL: 'mongodb://runtime-user:runtime-password@database/repro',
+            SENDGRID_API_KEY: 'sendgrid-runtime-secret',
+        };
+        this.internalConfig = {
+            modules: Array.from({ length: 800 }, (_, index) => ({
+                index,
+                secret: `config-secret-${index}`,
+                nested: { host: `database-${index}.internal`, port: 27017 },
+            })),
+        };
+    }
+
+    get(key) {
+        return this.cache[key];
+    }
+}
+
+class ApiConfigService {
+    constructor(configService) {
+        this.configService = configService;
+    }
+}
+
+class ShipmentGenerator {
+    constructor(configService) {
+        this.apiConfigService = new ApiConfigService(configService);
+        this.logger = new Logger('ShipmentGenerator');
+        this.triggerAction = 'ShipmentCreated';
+    }
+}
+
+class ShipmentDto {
+    constructor() {
+        this.shipmentNumber = 'SHIP-TRACE-1001';
+        this.site = {
+            number: 'SITE-0042',
+            address: {
+                country: {
+                    code: 'US',
+                    regulatory: { region: 'FDA', enabled: true },
+                },
+            },
+        };
+        this.kits = Array.from({ length: 160 }, (_, index) => ({
+            kitNumber: `KIT-${String(index).padStart(4, '0')}`,
+            status: index % 2 === 0 ? 'available' : 'released',
+            temperature: { minC: 2, maxC: 8 },
+        }));
+    }
+}
+
+function recordShipment(generator, shipment) {
+    return {
+        accepted: true,
+        originalGeneratorObserved: generator instanceof ShipmentGenerator,
+        originalShipmentObserved: shipment instanceof ShipmentDto,
+        runtimeConfigStillReadable:
+            generator.apiConfigService.configService.cache.DATABASE_URL.startsWith('mongodb://'),
+        shipmentNumber: shipment.shipmentNumber,
+        lastKit: shipment.kits[shipment.kits.length - 1].kitNumber,
+    };
+}
+
+async function handleSemanticTrace(_req, res) {
+    const configService = new ConfigService();
+    const generator = new ShipmentGenerator(configService);
+    const shipment = new ShipmentDto();
+    res.json(recordShipment(generator, shipment));
+}
+
+module.exports = {
+    handleSemanticTrace,
+};

package/test/fixtures/semantic-serialization-trace-server.js

@@ -0,0 +1,19 @@
+const express = require('express');
+const { reproMiddleware } = require('../../dist');
+const { handleSemanticTrace } = require('./semantic-serialization-trace-controller');
+
+async function startServer(config) {
+    const app = express();
+    app.use(reproMiddleware(config));
+    app.get('/semantic-trace', handleSemanticTrace);
+
+    return new Promise((resolve, reject) => {
+        const server = app.listen(0, '127.0.0.1');
+        server.once('listening', () => resolve(server));
+        server.once('error', reject);
+    });
+}
+
+module.exports = {
+    startServer,
+};

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

@@ -145,10 +145,19 @@ async function testKafkaConsumerTraceUsesConsumeTraceId() {
             privacy: { environment: 'dev' },
             ingestBase: 'http://127.0.0.1:65535',
         };
+        const consumerPayload = {
+            marker: 'before-consumer-work',
+            repeated: 'consumer-trace-value'.repeat(1024),
+        };
         const wrapped = __reproTestHooks.wrapKafkaEachMessageHandlerForTest(
             async () => {
-                tracer.tracer.enter('consumerWork', { file: '/app/consumer.ts', line: 10 }, { args: ['ok'] });
-                tracer.tracer.exit({ fn: 'consumerWork', file: '/app/consumer.ts', line: 10 }, { returnValue: 'done' });
+                tracer.tracer.enter('consumerWork', { file: '/app/consumer.ts', line: 10 }, { args: [consumerPayload] });
+                consumerPayload.marker = 'at-consumer-exit';
+                tracer.tracer.exit(
+                    { fn: 'consumerWork', file: '/app/consumer.ts', line: 10 },
+                    { args: [consumerPayload], returnValue: consumerPayload },
+                );
+                consumerPayload.marker = 'after-consumer-exit';
 
                 tracer.withTrace('parent-http-trace', () => {
                     tracer.tracer.enter('parentWork', { file: '/app/controller.ts', line: 20 }, { args: ['wrong'] });
@@ -207,6 +216,21 @@ async function testKafkaConsumerTraceUsesConsumeTraceId() {
             .map((traceEvent) => traceEvent.fn);
         assert(traceFns.includes('consumerWork'), traceFns.join(','));
         assert(!traceFns.includes('parentWork'), traceFns.join(','));
+
+        const traceBatches = events.filter((event) => event.event_type === 'trace_batch');
+        const traceEvents = traceBatches.flatMap((event) => event.payload?.trace || []);
+        const definitions = traceBatches.flatMap((event) => event.payload?.traceValues || []);
+        const definitionsById = new Map(definitions.map((definition) => [definition.id, definition]));
+        const consumerEnter = traceEvents.find((event) => event.fn === 'consumerWork' && event.type === 'enter');
+        const consumerExit = traceEvents.find((event) => event.fn === 'consumerWork' && event.type === 'exit');
+        assert(consumerEnter && consumerExit, JSON.stringify(traceEvents));
+        const enterValue = definitionsById.get(consumerEnter.argsValueCapture?.valueId)?.value;
+        const exitArgsValue = definitionsById.get(consumerExit.argsValueCapture?.valueId)?.value;
+        const returnValue = definitionsById.get(consumerExit.returnValueCapture?.valueId)?.value;
+        assert.equal(enterValue?.[0]?.marker, 'before-consumer-work');
+        assert.equal(exitArgsValue?.[0]?.marker, 'at-consumer-exit');
+        assert.equal(returnValue?.marker, 'at-consumer-exit');
+        assert(!JSON.stringify(definitions).includes('after-consumer-exit'));
     } finally {
         global.fetch = originalFetch;
     }

package/test/policy-session-completion.testcontainers.test.js

@@ -79,6 +79,7 @@ function requestNames(port, index) {
                 'x-bug-session-id': 'S_policy_completion',
                 'x-bug-action-id': `A_policy_completion_${index}`,
                 'x-bug-request-start': String(Date.now()),
+                'x-demo-actor-id': 'policy-completion-actor',
             },
         }, (response) => {
             const chunks = [];
@@ -152,10 +153,26 @@ async function main() {
             captureHeaders: false,
             privacy: {
                 environment: 'dev',
-                policy: largePolicy(),
+            },
+            liveMode: {
+                enabled: true,
+                backendOnly: true,
+                defineActorId: ({ req }) => req.headers['x-demo-actor-id'],
+                shouldCapture: () => true,
+                actorType: 'policy-test-user',
             },
             ingestBase: 'http://127.0.0.1:65535',
         };
+        __reproTestHooks.shareRuntimePrivacyStateForTest(
+            {
+                ...cfg,
+                privacy: {
+                    environment: 'dev',
+                    policy: largePolicy(),
+                },
+            },
+            cfg,
+        );
 
         const depotSchema = new mongoose.Schema({
             location: String,

package/test/semantic-serialization-trace.test.js

@@ -0,0 +1,152 @@
+const assert = require('node:assert/strict');
+const http = require('node:http');
+
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '25';
+process.env.REPRO_SDK_TRACE_INLINE_VALUE_MAX_SERIALIZED_CHARS = '2048';
+process.env.TRACE_IDLE_FLUSH_MS = '10';
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+
+const originalFetch = global.fetch;
+const capturedBodies = [];
+
+global.fetch = async (url, init = {}) => {
+    assert.match(String(url), /\/v1\/ingest\/events$/);
+    capturedBodies.push(JSON.parse(String(init.body || '{}')));
+    return {
+        ok: true,
+        status: 202,
+        json: async () => ({ ok: true }),
+        text: async () => '{"ok":true}',
+    };
+};
+
+const { initRepro } = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitFor(predicate, timeoutMs = 4000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate()) return;
+        await sleep(20);
+    }
+    assert(predicate(), 'timed out waiting for semantic trace capture');
+}
+
+function eventsOf(type) {
+    return capturedBodies
+        .flatMap((body) => Array.isArray(body?.events) ? body.events : [])
+        .filter((event) => event?.event_type === type);
+}
+
+function get(url) {
+    return new Promise((resolve, reject) => {
+        const request = http.get(url, (response) => {
+            let body = '';
+            response.setEncoding('utf8');
+            response.on('data', (chunk) => { body += chunk; });
+            response.on('end', () => resolve({ statusCode: response.statusCode, body }));
+        });
+        request.on('error', reject);
+    });
+}
+
+async function main() {
+    const config = {
+        tenantId: 'TENANT_semantic_trace',
+        appId: 'APP_semantic_trace',
+        appSecret: 'secret',
+        appName: 'semantic-trace',
+        serviceName: 'semantic-trace',
+        ingestBase: 'http://127.0.0.1:65535',
+        tracing: {
+            disableFunctionTypes: ['constructor'],
+            fullValueCapture: true,
+            logFunctionCalls: false,
+        },
+    };
+
+    await initRepro(config);
+    const { startServer } = require('./fixtures/semantic-serialization-trace-server');
+    const server = await startServer(config);
+
+    try {
+        const port = server.address().port;
+        const response = await get(
+            `http://127.0.0.1:${port}/semantic-trace` +
+            `?__repro_sid=S_semantic_trace&__repro_aid=A_semantic_trace&__repro_start=${Date.now()}`,
+        );
+        assert.equal(response.statusCode, 200);
+        assert.deepEqual(JSON.parse(response.body), {
+            accepted: true,
+            originalGeneratorObserved: true,
+            originalShipmentObserved: true,
+            runtimeConfigStillReadable: true,
+            shipmentNumber: 'SHIP-TRACE-1001',
+            lastKit: 'KIT-0159',
+        });
+
+        await waitFor(() => eventsOf('backend_request').length === 1);
+        await waitFor(() => eventsOf('trace_batch').some((event) =>
+            event.payload?.trace?.some((traceEvent) => traceEvent?.fn === 'recordShipment')
+        ));
+        await flushIngestQueue();
+
+        const traceBatches = eventsOf('trace_batch');
+        const traceEvents = traceBatches.flatMap((event) => event.payload?.trace || []);
+        const enter = traceEvents.find((event) => event?.type === 'enter' && event?.fn === 'recordShipment');
+        assert(enter, JSON.stringify(traceEvents));
+
+        const traceValues = traceBatches.flatMap((event) => event.payload?.traceValues || []);
+        const argsValue = traceValues.find((entry) =>
+            entry?.id === enter.argsValueCapture?.valueId && entry?.target === 'trace.args'
+        );
+        const capturedArgs = argsValue?.value || enter.args;
+        assert(Array.isArray(capturedArgs), JSON.stringify({ enter, traceValues }));
+
+        assert.equal(capturedArgs[0].__class, 'ShipmentGenerator');
+        assert.equal(capturedArgs[0].triggerAction, 'ShipmentCreated');
+        assert.deepEqual(capturedArgs[0].logger, {
+            __kind: 'repro-semantic',
+            category: 'logger',
+            className: 'Logger',
+            context: 'ShipmentGenerator',
+        });
+        assert.deepEqual(capturedArgs[0].apiConfigService.configService, {
+            __kind: 'repro-semantic',
+            category: 'configuration-service',
+            className: 'ConfigService',
+        });
+
+        assert.equal(capturedArgs[1].shipmentNumber, 'SHIP-TRACE-1001');
+        assert.equal(capturedArgs[1].site.address.country.regulatory.region, 'FDA');
+        assert.equal(capturedArgs[1].kits.length, 160);
+        assert.equal(capturedArgs[1].kits[159].kitNumber, 'KIT-0159');
+
+        const allCapturedJson = JSON.stringify(capturedBodies);
+        assert(!allCapturedJson.includes('sendgrid-runtime-secret'));
+        assert(!allCapturedJson.includes('runtime-password'));
+        assert(!allCapturedJson.includes('config-secret-799'));
+        assert(!allCapturedJson.includes('logger-runtime-state'));
+
+        const argsBytes = Buffer.byteLength(JSON.stringify(capturedArgs));
+        assert(argsBytes < 30000, `semantic trace args unexpectedly large: ${argsBytes} bytes`);
+
+        console.log('semantic serialization real trace pipeline OK');
+    } finally {
+        await new Promise((resolve, reject) => {
+            server.close((error) => error ? reject(error) : resolve());
+        });
+    }
+}
+
+main()
+    .catch((error) => {
+        console.error(error);
+        process.exitCode = 1;
+    })
+    .finally(async () => {
+        await flushIngestQueue().catch(() => {});
+        global.fetch = originalFetch;
+    });