@reproapp/node-sdk 0.0.47 → 0.0.48

package/src/semantic-serialization.ts

@@ -0,0 +1,182 @@
+export type SemanticProjection = {
+    matched: true;
+    value: Record<string, unknown>;
+};
+
+type DataDescriptor = PropertyDescriptor & { value: unknown };
+
+function constructorName(value: unknown): string {
+    if (!value || typeof value !== 'object') return '';
+    try {
+        const prototype = Object.getPrototypeOf(value);
+        const constructor = prototype
+            ? Object.getOwnPropertyDescriptor(prototype, 'constructor')?.value
+            : undefined;
+        const name = constructor?.name;
+        return typeof name === 'string' ? name : '';
+    } catch {
+        return '';
+    }
+}
+
+function ownDataDescriptors(value: object): Record<string, DataDescriptor> {
+    const out: Record<string, DataDescriptor> = {};
+    let descriptors: Record<string, PropertyDescriptor>;
+    try {
+        descriptors = Object.getOwnPropertyDescriptors(value);
+    } catch {
+        return out;
+    }
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+        if (Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+            out[key] = descriptor as DataDescriptor;
+        }
+    }
+    return out;
+}
+
+function method(value: unknown, key: string): boolean {
+    try {
+        let current: object | null = value as object;
+        while (current) {
+            const descriptor = Object.getOwnPropertyDescriptor(current, key);
+            if (descriptor) {
+                return Object.prototype.hasOwnProperty.call(descriptor, 'value') &&
+                    typeof descriptor.value === 'function';
+            }
+            current = Object.getPrototypeOf(current);
+        }
+        return false;
+    } catch {
+        return false;
+    }
+}
+
+function primitiveStateValue(value: unknown): string | number | boolean | null | undefined {
+    if (value === null) return null;
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'bigint') return value.toString();
+    if (value instanceof Date) return value.toISOString();
+    return undefined;
+}
+
+function semanticValue(
+    category: string,
+    className: string,
+    details: Record<string, unknown> = {},
+): SemanticProjection {
+    return {
+        matched: true,
+        value: {
+            __kind: 'repro-semantic',
+            category,
+            ...(className ? { className } : {}),
+            ...details,
+        },
+    };
+}
+
+function projectConfigurationService(value: object, className: string): SemanticProjection | null {
+    if (!/(^|Api|App|Runtime|Environment)ConfigService$/i.test(className)) return null;
+    if (!method(value, 'get') && !method(value, 'getOrThrow')) return null;
+    return semanticValue('configuration-service', className);
+}
+
+function projectLogger(value: object, className: string): SemanticProjection | null {
+    if (!/(Logger|LoggerService)$/i.test(className)) return null;
+    const descriptors = ownDataDescriptors(value);
+    const context = primitiveStateValue(descriptors.context?.value);
+    return semanticValue('logger', className, context !== undefined ? { context } : {});
+}
+
+function projectNestInfrastructure(value: object, className: string): SemanticProjection | null {
+    if (!/(ModuleRef|ModulesContainer|InstanceWrapper|NestContainer|Injector|DiscoveryService|ExecutionContextHost|ArgumentsHost|HttpAdapterHost)$/i.test(className)) {
+        return null;
+    }
+    return semanticValue('nestjs-infrastructure', className);
+}
+
+function projectRedis(value: object, className: string): SemanticProjection | null {
+    const looksLikeRedis = /Redis|Commander|Cluster/i.test(className) && (
+        method(value, 'get') || method(value, 'set') || method(value, 'pipeline') || method(value, 'multi')
+    );
+    if (!looksLikeRedis) return null;
+    const descriptors = ownDataDescriptors(value);
+    const status = primitiveStateValue(descriptors.status?.value);
+    return semanticValue('redis-client', className, status !== undefined ? { status } : {});
+}
+
+function projectKafka(value: object, className: string): SemanticProjection | null {
+    if (!/Kafka/i.test(className)) return null;
+    if (method(value, 'send') && method(value, 'connect') && method(value, 'disconnect')) {
+        return semanticValue('kafka-producer', className || 'KafkaProducer');
+    }
+    if (method(value, 'subscribe') && method(value, 'run') && method(value, 'connect')) {
+        return semanticValue('kafka-consumer', className || 'KafkaConsumer');
+    }
+    if (method(value, 'listTopics') && method(value, 'connect') && method(value, 'disconnect')) {
+        return semanticValue('kafka-admin', className || 'KafkaAdmin');
+    }
+    return null;
+}
+
+function projectAmqp(value: object, className: string): SemanticProjection | null {
+    if (!/(Amqp|Channel|ChannelModel|ConfirmChannel)/i.test(className)) return null;
+    if (method(value, 'publish') && method(value, 'sendToQueue') && method(value, 'ack')) {
+        return semanticValue('amqp-channel', className || 'AmqpChannel');
+    }
+    if (method(value, 'createChannel') && method(value, 'close')) {
+        return semanticValue('amqp-connection', className || 'AmqpConnection');
+    }
+    return null;
+}
+
+function projectPostgres(value: object, className: string): SemanticProjection | null {
+    if (/^(Pool|BoundPool)$/i.test(className) && method(value, 'query') && method(value, 'connect')) {
+        return semanticValue('postgres-pool', className);
+    }
+    if (/^(Client|PoolClient)$/i.test(className) && method(value, 'query')) {
+        return semanticValue('postgres-client', className);
+    }
+    return null;
+}
+
+function projectTypeOrm(value: object, className: string): SemanticProjection | null {
+    if (/^DataSource$/i.test(className) && method(value, 'createQueryRunner')) {
+        return semanticValue('typeorm-infrastructure', className);
+    }
+    if (/^EntityManager$/i.test(className) && method(value, 'getRepository') && method(value, 'query')) {
+        return semanticValue('typeorm-infrastructure', className);
+    }
+    if (/^QueryRunner$/i.test(className) && method(value, 'query') && method(value, 'release')) {
+        return semanticValue('typeorm-infrastructure', className);
+    }
+    if (/^Repository$/i.test(className) && method(value, 'find') && method(value, 'save')) {
+        return semanticValue('typeorm-infrastructure', className);
+    }
+    return null;
+}
+
+/**
+ * Projects known runtime machinery into stable, non-recursive descriptions.
+ * Unknown application values deliberately return null and remain fully captured.
+ */
+export function projectSemanticInfrastructureValue(value: unknown): SemanticProjection | null {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+
+    const className = constructorName(value);
+    if (!className || className === 'Object') return null;
+
+    return (
+        projectConfigurationService(value, className) ||
+        projectLogger(value, className) ||
+        projectNestInfrastructure(value, className) ||
+        projectRedis(value, className) ||
+        projectKafka(value, className) ||
+        projectAmqp(value, className) ||
+        projectPostgres(value, className) ||
+        projectTypeOrm(value, className)
+    );
+}

package/test/content-addressed-mongodb.testcontainers.test.js

@@ -0,0 +1,348 @@
+process.env.REPRO_INGEST_REQUEST_TIMEOUT_MS = '100';
+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.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 mongoose = require('mongoose');
+const { GenericContainer, Wait } = require('testcontainers');
+
+const {
+    initReproTracing,
+    reproMiddleware,
+    reproMongoosePlugin,
+    __reproTestHooks,
+} = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const byteLength = (value) => Buffer.byteLength(JSON.stringify(value), 'utf8');
+
+class Logger {
+    constructor(context) {
+        this.context = context;
+        this.buffers = Array.from({ length: 200 }, () => 'mongo-test-logger-buffer');
+    }
+
+    log() {}
+}
+
+class ConfigService {
+    constructor() {
+        this.cache = {
+            DATABASE_URL: 'mongodb://captured-config-secret@database/repro',
+        };
+        this.internalConfig = Array.from({ length: 1000 }, (_, index) => ({
+            index,
+            credential: `mongo-config-credential-${index}`,
+        }));
+    }
+
+    get(key) {
+        return this.cache[key];
+    }
+}
+
+class SubjectRepository {
+    constructor(model, configService) {
+        this.model = model;
+        this.configService = configService;
+        this.logger = new Logger('SubjectRepository');
+        this.collectionName = 'subjects';
+    }
+}
+
+async function loadSubjectRepeatedly(repository, query) {
+    const docs = [];
+    for (let index = 0; index < 6; index += 1) {
+        docs.push(await repository.model.findOne(query).lean().exec());
+    }
+
+    let duplicateCode = null;
+    try {
+        await repository.model.create({
+            ...docs[0],
+            _id: undefined,
+        });
+    } catch (error) {
+        duplicateCode = error?.code ?? null;
+    }
+
+    return {
+        repositoryIdentityPreserved: repository instanceof SubjectRepository,
+        duplicateCode,
+        docs,
+    };
+}
+
+function makeSubject() {
+    return {
+        subjectNumber: 'SUBJECT-CONTENT-1001',
+        status: 'screened',
+        visits: Array.from({ length: 80 }, (_, visitIndex) => ({
+            visitNumber: `VISIT-${String(visitIndex).padStart(3, '0')}`,
+            assessments: Array.from({ length: 5 }, (_, assessmentIndex) => ({
+                code: `ASSESSMENT-${visitIndex}-${assessmentIndex}`,
+                result: visitIndex * 10 + assessmentIndex,
+                referenceRange: { min: 0, max: 1000, unit: 'mg' },
+                flags: assessmentIndex === 4 ? ['review'] : [],
+            })),
+        })),
+        metadata: {
+            source: 'clinical-import',
+            audit: {
+                importedBy: 'SYSTEM',
+                importBatch: 'BATCH-CONTENT-1',
+            },
+        },
+    };
+}
+
+function makeReqRes(sessionId, actionId) {
+    const req = new EventEmitter();
+    req.method = 'POST';
+    req.url = '/subjects/repeated-read';
+    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 = 200;
+    res.getHeader = () => undefined;
+    res.getHeaders = () => ({});
+    res.setHeader = () => {};
+    res.write = () => true;
+    res.end = function end() {
+        this.emit('finish');
+        return this;
+    };
+    return { req, res };
+}
+
+function flattenEvents(posts) {
+    return posts.flatMap((body) => Array.isArray(body?.events) ? body.events : []);
+}
+
+function dbChanges(events) {
+    return events
+        .filter((event) => event.event_type === 'db_change')
+        .flatMap((event) => event.payload?.db || []);
+}
+
+function manifests(events) {
+    return events
+        .filter((event) => event.event_type === 'request_capture_manifest')
+        .map((event) => event.payload?.requestCaptureManifest ?? event.payload)
+        .filter(Boolean);
+}
+
+async function startMongo() {
+    if (process.env.REPRO_MONGO_TEST_URI) {
+        return { uri: process.env.REPRO_MONGO_TEST_URI, stop: async () => {} };
+    }
+    const container = await new GenericContainer('mongo:7')
+        .withExposedPorts(27017)
+        .withTmpFs({ '/data/db': 'rw,noexec,nosuid,size=1g' })
+        .withCommand(['mongod', '--bind_ip_all', '--setParameter', 'diagnosticDataCollectionEnabled=false'])
+        .withWaitStrategy(Wait.forListeningPorts())
+        .start();
+    return {
+        uri: `mongodb://${container.getHost()}:${container.getMappedPort(27017)}/repro_content_addressed`,
+        stop: () => container.stop(),
+    };
+}
+
+async function main() {
+    const posts = [];
+    const originalFetch = 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}',
+        };
+    };
+
+    let mongo;
+    let connection;
+    try {
+        mongo = await startMongo();
+        connection = await mongoose.createConnection(mongo.uri).asPromise();
+
+        const config = {
+            tenantId: 'TENANT_content_addressed_mongo',
+            appId: 'APP_content_addressed_mongo',
+            appSecret: 'content-addressed-mongo-secret',
+            captureHeaders: false,
+            privacy: { environment: 'dev', captureRaw: true },
+            ingestBase: 'http://127.0.0.1:65535',
+        };
+        const assessmentSchema = new mongoose.Schema({
+            code: String,
+            result: Number,
+            referenceRange: { min: Number, max: Number, unit: String },
+            flags: [String],
+        }, { _id: false });
+        const visitSchema = new mongoose.Schema({
+            visitNumber: String,
+            assessments: [assessmentSchema],
+        }, { _id: false });
+        const subjectSchema = new mongoose.Schema({
+            subjectNumber: { type: String, unique: true },
+            status: String,
+            visits: [visitSchema],
+            metadata: mongoose.Schema.Types.Mixed,
+        });
+        reproMongoosePlugin(config)(subjectSchema);
+        const Subject = connection.model('ContentSubject', subjectSchema, 'content_subjects');
+        await Subject.init();
+        await Subject.create(makeSubject());
+
+        initReproTracing({ instrument: false, fullValueCapture: true, logFunctionCalls: false });
+        __reproTestHooks.resetSdkBackgroundQueuesForTest();
+        const middleware = reproMiddleware(config);
+        const { req, res } = makeReqRes('S_content_addressed_mongo', 'A_content_addressed_mongo');
+        const repository = new SubjectRepository(Subject, new ConfigService());
+        let operationResult;
+
+        await new Promise((resolve, reject) => {
+            middleware(req, res, async (error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                try {
+                    operationResult = await global.__repro_call(
+                        loadSubjectRepeatedly,
+                        null,
+                        [repository, { subjectNumber: 'SUBJECT-CONTENT-1001' }],
+                        '/app/src/subjects.repository.ts',
+                        120,
+                        'loadSubjectRepeatedly',
+                        false,
+                    );
+                    res.end();
+                    resolve();
+                } catch (operationError) {
+                    reject(operationError);
+                }
+            });
+        });
+
+        assert.equal(operationResult.repositoryIdentityPreserved, true);
+        assert.equal(operationResult.duplicateCode, 11000);
+        assert.equal(operationResult.docs.length, 6);
+        assert.equal(operationResult.docs[0].visits.length, 80);
+        assert.equal(operationResult.docs[5].visits[79].assessments[4].code, 'ASSESSMENT-79-4');
+
+        const deadline = Date.now() + 8000;
+        while (Date.now() < deadline) {
+            const events = flattenEvents(posts);
+            if (dbChanges(events).length >= 7 && manifests(events).length === 1 &&
+                events.some((event) => event.event_type === 'trace_batch')) {
+                break;
+            }
+            await sleep(25);
+        }
+        await __reproTestHooks.drainSdkBackgroundQueueForTest();
+        await flushIngestQueue();
+
+        const events = flattenEvents(posts);
+        const changes = dbChanges(events);
+        const manifest = manifests(events)[0];
+        assert(manifest, 'expected request capture manifest');
+        assert.equal(manifest.expected.dbChange, changes.length);
+
+        const readChanges = changes.filter((change) =>
+            change.collection === 'content_subjects' &&
+            change.op === 'findOne' &&
+            change.resultMetaValueCapture?.status === 'stored'
+        );
+        assert(readChanges.length >= 6, JSON.stringify(changes));
+        const resultValueIds = new Set(
+            readChanges.map((change) => change.resultMetaValueCapture.valueId),
+        );
+        assert.equal(resultValueIds.size, 1, 'identical query results must share one content ID');
+
+        const dbValueDefinitions = events
+            .filter((event) => event.event_type === 'db_change')
+            .flatMap((event) => event.payload?.dbValues || []);
+        const resultDefinitions = dbValueDefinitions.filter((entry) =>
+            resultValueIds.has(entry.id) && entry.target === 'db.resultMeta'
+        );
+        assert.equal(resultDefinitions.length, 1, 'repeated DB result must be transported once');
+        const fullResult = resultDefinitions[0].value;
+        assert.equal(fullResult.subjectNumber, 'SUBJECT-CONTENT-1001');
+        assert.equal(fullResult.visits.length, 80);
+        assert.equal(fullResult.visits[79].assessments[4].code, 'ASSESSMENT-79-4');
+        const legacyRepeatedResultBytes = readChanges.length * byteLength(fullResult);
+        const optimizedResultBytes = byteLength(fullResult) + readChanges.reduce(
+            (total, change) => total + byteLength(change.resultMetaValueCapture),
+            0,
+        );
+        const resultReduction = 1 - optimizedResultBytes / legacyRepeatedResultBytes;
+        assert(
+            resultReduction > 0.75,
+            `repeated DB result storage reduced only ${(resultReduction * 100).toFixed(1)}%`,
+        );
+
+        const failedWrite = changes.find((change) =>
+            change.collection === 'content_subjects' && change.error?.code === 11000
+        );
+        assert(failedWrite, 'duplicate-key failure must remain captured');
+
+        const traceBatches = events.filter((event) => event.event_type === 'trace_batch');
+        const traceEvents = traceBatches.flatMap((event) => event.payload?.trace || []);
+        const enter = traceEvents.find((event) =>
+            event.fn === 'loadSubjectRepeatedly' && event.type === 'enter'
+        );
+        assert(enter, JSON.stringify(traceEvents));
+        const traceDefinitions = traceBatches.flatMap((event) => event.payload?.traceValues || []);
+        const argsDefinition = traceDefinitions.find((entry) =>
+            entry.id === enter.argsValueCapture?.valueId
+        );
+        assert(argsDefinition, JSON.stringify(traceDefinitions));
+        assert.deepEqual(argsDefinition.value[0].configService, {
+            __kind: 'repro-semantic',
+            category: 'configuration-service',
+            className: 'ConfigService',
+        });
+        assert.equal(argsDefinition.value[1].subjectNumber, 'SUBJECT-CONTENT-1001');
+
+        const capturedJson = JSON.stringify(posts);
+        assert(!capturedJson.includes('captured-config-secret'));
+        assert(!capturedJson.includes('mongo-config-credential-999'));
+        assert(!capturedJson.includes('mongo-test-logger-buffer'));
+
+        console.log('content-addressed MongoDB testcontainers coverage OK', JSON.stringify({
+            repeatedResultOccurrences: readChanges.length,
+            uniqueResultDefinitions: resultDefinitions.length,
+            legacyRepeatedResultBytes,
+            optimizedResultBytes,
+            resultReductionPercent: Number((resultReduction * 100).toFixed(2)),
+        }));
+    } finally {
+        await __reproTestHooks.drainSdkBackgroundQueueForTest().catch(() => {});
+        await flushIngestQueue().catch(() => {});
+        global.fetch = originalFetch;
+        if (connection) await connection.close().catch(() => {});
+        if (mongo) await mongo.stop().catch(() => {});
+    }
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});