@reproapp/node-sdk 0.0.49 → 0.0.51

package/dist/live-capture-limits.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.limitLiveArguments = exports.collectCaptureOmissions = exports.limitLiveCapture = exports.LIVE_CAPTURE_LIMITS = void 0;
+const http_1 = require("http");
+const semantic_serialization_1 = require("./semantic-serialization");
+exports.LIVE_CAPTURE_LIMITS = Object.freeze({ maxDepth: 10, maxKeys: 100, maxEntries: 100 });
+const marker = (omission) => ({ __kind: 'repro-omitted', complete: false, ...omission });
+const childPath = (path, key) => `${path}[${JSON.stringify(key)}]`;
+function parseStructuredString(value) {
+    if (typeof value !== 'string' || !/^[\s]*[\[{]/.test(value))
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Snapshot only data descriptors: capture must never execute application getters. */
+function limitLiveCapture(value, rootPath = '$') {
+    const omissions = [];
+    const seen = new WeakMap();
+    const omit = (detail) => { omissions.push(detail); return marker(detail); };
+    const walk = (input, depth, path) => {
+        if (input === null || input === undefined)
+            return input;
+        if (typeof input === 'string') {
+            const parsed = parseStructuredString(input);
+            if (parsed === undefined)
+                return input;
+            const before = omissions.length;
+            const bounded = walk(parsed, depth, path);
+            // Preserve the original string exactly unless its structured data exceeded a limit.
+            return omissions.length === before ? input : JSON.stringify(bounded);
+        }
+        if (typeof input === 'bigint' || typeof input === 'symbol')
+            return String(input);
+        if (typeof input === 'function')
+            return '[Function]';
+        if (typeof input !== 'object')
+            return input;
+        const previous = seen.get(input);
+        if (previous && previous.depth <= depth)
+            return { __reproCircularRef: previous.path };
+        seen.set(input, { path, depth });
+        const descriptor = (key) => Object.getOwnPropertyDescriptor(input, key);
+        const data = (key) => descriptor(key)?.value;
+        if (data('__kind') === 'repro-omitted') {
+            const detail = { reason: data('reason'), path: data('path'), limit: data('limit'), originalCount: data('originalCount'), capturedCount: data('capturedCount') };
+            omissions.push(detail);
+            return marker(detail);
+        }
+        if (input instanceof Date)
+            return Number.isNaN(Date.prototype.getTime.call(input)) ? 'Invalid Date' : Date.prototype.toISOString.call(input);
+        if (input instanceof RegExp)
+            return RegExp.prototype.toString.call(input);
+        if (input instanceof http_1.IncomingMessage) {
+            // The business body is its own root, not depth one in a socket graph.
+            return { __kind: 'http-request', method: data('method'), url: data('originalUrl') ?? data('url'),
+                headers: walk(data('headers') ?? Object.getOwnPropertyDescriptor(http_1.IncomingMessage.prototype, 'headers')?.get?.call(input), 0, childPath(path, 'headers')),
+                query: walk(data('query'), 0, childPath(path, 'query')),
+                body: walk(data('body'), 0, childPath(path, 'body')),
+                params: walk(data('params'), 0, childPath(path, 'params')) };
+        }
+        if (input instanceof http_1.ServerResponse)
+            return { __kind: 'http-response', statusCode: data('statusCode') };
+        const projected = (0, semantic_serialization_1.projectSemanticInfrastructureValue)(input);
+        if (projected)
+            return projected.value;
+        // Mongoose stores business fields in _doc; never recurse through $__ state.
+        const documentData = (0, semantic_serialization_1.mongooseDocumentData)(input);
+        if (documentData)
+            return walk(documentData, depth, path);
+        if (depth > exports.LIVE_CAPTURE_LIMITS.maxDepth)
+            return omit({ reason: 'max-depth', path, limit: exports.LIVE_CAPTURE_LIMITS.maxDepth, capturedCount: 0 });
+        if (input instanceof Error) {
+            const details = Object.create(null);
+            for (const key of ['message', 'stack', 'cause', 'errors', ...Object.keys(input)]) {
+                const item = descriptor(key);
+                if (item)
+                    Object.defineProperty(details, key, { ...item, enumerable: true, configurable: true });
+            }
+            return walk(details, depth, path);
+        }
+        if (input instanceof ArrayBuffer || (typeof SharedArrayBuffer !== 'undefined' && input instanceof SharedArrayBuffer) || input instanceof DataView) {
+            let bytes;
+            if (input instanceof DataView) {
+                const read = (key) => Object.getOwnPropertyDescriptor(DataView.prototype, key).get.call(input);
+                bytes = new Uint8Array(read('buffer'), read('byteOffset'), read('byteLength'));
+            }
+            else
+                bytes = new Uint8Array(input);
+            return { __type: input instanceof DataView ? 'DataView' : 'ArrayBuffer', values: walk(bytes, depth, path).values };
+        }
+        if (input instanceof Map) {
+            const entries = [];
+            const size = Object.getOwnPropertyDescriptor(Map.prototype, 'size').get.call(input);
+            for (const [key, item] of Map.prototype.entries.call(input)) {
+                if (entries.length >= exports.LIVE_CAPTURE_LIMITS.maxEntries)
+                    break;
+                const index = entries.length;
+                entries.push([walk(key, depth + 1, childPath(path, `key:${index}`)), walk(item, depth + 1, childPath(path, index))]);
+            }
+            if (size > entries.length)
+                entries.push(omit({ reason: 'max-entries', path, limit: 100, originalCount: size, capturedCount: entries.length }));
+            return { __type: 'Map', entries };
+        }
+        if (input instanceof Set) {
+            const values = [];
+            const size = Object.getOwnPropertyDescriptor(Set.prototype, 'size').get.call(input);
+            for (const item of Set.prototype.values.call(input)) {
+                if (values.length >= 100)
+                    break;
+                values.push(walk(item, depth + 1, childPath(path, values.length)));
+            }
+            if (size > values.length)
+                values.push(omit({ reason: 'max-entries', path, limit: 100, originalCount: size, capturedCount: values.length }));
+            return { __type: 'Set', values };
+        }
+        if (Array.isArray(input) || (ArrayBuffer.isView(input) && !(input instanceof DataView))) {
+            const length = input.length;
+            const previousMarker = Array.isArray(input) && length === 101 ? descriptor('100')?.value : null;
+            const prior = previousMarker && Object.getOwnPropertyDescriptors(previousMarker);
+            const hasPriorLimit = prior?.__kind?.value === 'repro-omitted' && prior?.reason?.value === 'max-entries';
+            const values = [];
+            for (let i = 0; i < Math.min(length, 100); i++) {
+                const itemDescriptor = descriptor(String(i));
+                values.push(itemDescriptor && !('value' in itemDescriptor)
+                    ? omit({ reason: 'accessor', path: childPath(path, i), capturedCount: 0 })
+                    : walk(itemDescriptor?.value, depth + 1, childPath(path, i)));
+            }
+            if (length > 100)
+                values.push(hasPriorLimit
+                    ? walk(previousMarker, depth + 1, path)
+                    : omit({ reason: 'max-entries', path, limit: 100, originalCount: length, capturedCount: 100 }));
+            return Array.isArray(input) ? values : { __type: 'TypedArray', values };
+        }
+        const keys = Object.keys(input);
+        const previousMetadataKey = keys.find(key => {
+            if (!/^__reproCapture\$*$/.test(key))
+                return false;
+            const candidate = descriptor(key)?.value;
+            return candidate && Object.getOwnPropertyDescriptor(candidate, '__kind')?.value === 'repro-omitted'
+                && Object.getOwnPropertyDescriptor(candidate, 'reason')?.value === 'max-keys';
+        });
+        const businessKeys = keys.filter(key => key !== previousMetadataKey);
+        const out = Object.create(null);
+        for (const key of businessKeys.slice(0, 100)) {
+            const itemDescriptor = descriptor(key);
+            out[key] = 'value' in itemDescriptor
+                ? walk(itemDescriptor.value, depth + 1, childPath(path, key))
+                : omit({ reason: 'accessor', path: childPath(path, key), capturedCount: 0 });
+        }
+        if (businessKeys.length > 100 || previousMetadataKey) {
+            const detail = previousMetadataKey
+                ? walk(descriptor(previousMetadataKey)?.value, depth + 1, path)
+                : omit({ reason: 'max-keys', path, limit: 100, originalCount: businessKeys.length, capturedCount: 100 });
+            let metadataKey = '__reproCapture';
+            while (Object.prototype.hasOwnProperty.call(out, metadataKey))
+                metadataKey += '$';
+            out[metadataKey] = detail;
+        }
+        return out;
+    };
+    try {
+        return { value: walk(value, 0, rootPath), omissions };
+    }
+    catch {
+        return { value: omit({ reason: 'uninspectable', path: rootPath, capturedCount: 0 }), omissions };
+    }
+}
+exports.limitLiveCapture = limitLiveCapture;
+function collectCaptureOmissions(value) {
+    const result = [];
+    const seen = new WeakSet();
+    const pending = [value];
+    while (pending.length) {
+        const item = pending.pop();
+        const node = typeof item === 'string' ? parseStructuredString(item) : item;
+        if (!node || typeof node !== 'object' || seen.has(node))
+            continue;
+        seen.add(node);
+        const descriptors = Object.getOwnPropertyDescriptors(node);
+        if (descriptors.__kind?.value === 'repro-omitted') {
+            result.push({ reason: descriptors.reason?.value, path: descriptors.path?.value, limit: descriptors.limit?.value,
+                originalCount: descriptors.originalCount?.value, capturedCount: descriptors.capturedCount?.value });
+            continue;
+        }
+        for (const item of Object.values(descriptors))
+            if ('value' in item)
+                pending.push(item.value);
+    }
+    return result;
+}
+exports.collectCaptureOmissions = collectCaptureOmissions;
+function limitLiveArguments(args) {
+    const values = args.slice(0, 100).map((arg, index) => limitLiveCapture(arg, `$[${index}]`).value);
+    if (args.length > 100) {
+        const prior = Object.getOwnPropertyDescriptor(args, '100')?.value;
+        values.push(args.length === 101 && prior && Object.getOwnPropertyDescriptor(prior, '__kind')?.value === 'repro-omitted'
+            ? limitLiveCapture(prior).value
+            : marker({ reason: 'max-entries', path: '$', limit: 100, originalCount: args.length, capturedCount: 100 }));
+    }
+    return values;
+}
+exports.limitLiveArguments = limitLiveArguments;

package/dist/semantic-serialization.d.ts

@@ -2,6 +2,7 @@ export type SemanticProjection = {
     matched: true;
     value: Record<string, unknown>;
 };
+export declare function mongooseDocumentData(value: object): object | null;
 /**
  * Projects known runtime machinery into stable, non-recursive descriptions.
  * Unknown application values deliberately return null and remain fully captured.

package/dist/semantic-serialization.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectSemanticInfrastructureValue = void 0;
+exports.projectSemanticInfrastructureValue = exports.mongooseDocumentData = void 0;
 function constructorName(value) {
     if (!value || typeof value !== 'object')
         return '';
@@ -49,6 +49,13 @@ function method(value, key) {
         return false;
     }
 }
+function mongooseDocumentData(value) {
+    const doc = Object.getOwnPropertyDescriptor(value, '_doc')?.value;
+    if (!doc || typeof doc !== 'object' || !Object.getOwnPropertyDescriptor(value, '$__')?.value)
+        return null;
+    return method(value, '$__init') && method(value, '$toObject') ? doc : null;
+}
+exports.mongooseDocumentData = mongooseDocumentData;
 function primitiveStateValue(value) {
     if (value === null)
         return null;
@@ -82,6 +89,8 @@ function projectConfigurationService(value, className) {
 function projectLogger(value, className) {
     if (!/(Logger|LoggerService)$/i.test(className))
         return null;
+    if (!method(value, 'log') && !method(value, 'info'))
+        return null;
     const descriptors = ownDataDescriptors(value);
     const context = primitiveStateValue(descriptors.context?.value);
     return semanticValue('logger', className, context !== undefined ? { context } : {});
@@ -90,6 +99,15 @@ function projectNestInfrastructure(value, className) {
     if (!/(ModuleRef|ModulesContainer|InstanceWrapper|NestContainer|Injector|DiscoveryService|ExecutionContextHost|ArgumentsHost|HttpAdapterHost)$/i.test(className)) {
         return null;
     }
+    const signatures = {
+        ModuleRef: ['get', 'resolve'], ModulesContainer: ['get', 'set'],
+        InstanceWrapper: ['getInstanceByContextId'], NestContainer: ['getModules'],
+        Injector: ['loadInstance'], DiscoveryService: ['getProviders'],
+        ExecutionContextHost: ['switchToHttp', 'getArgs'], ArgumentsHost: ['switchToHttp', 'getArgs'],
+        HttpAdapterHost: ['listen$'],
+    };
+    if (!(signatures[className] ?? []).some(key => method(value, key)))
+        return null;
     return semanticValue('nestjs-infrastructure', className);
 }
 function projectRedis(value, className) {
@@ -149,6 +167,19 @@ function projectTypeOrm(value, className) {
     }
     return null;
 }
+function projectMongoInfrastructure(value, className) {
+    const signatures = {
+        MongoClient: ['connect', 'db', 'close'],
+        ClientSession: ['startTransaction', 'endSession'],
+        ConnectionPool: ['checkOut', 'checkIn'],
+        NativeConnection: ['openUri', 'model', 'close'],
+        Schema: ['add', 'path', 'plugin'],
+    };
+    const required = signatures[className];
+    return required?.every(key => method(value, key))
+        ? semanticValue('mongodb-infrastructure', className)
+        : null;
+}
 /**
  * Projects known runtime machinery into stable, non-recursive descriptions.
  * Unknown application values deliberately return null and remain fully captured.
@@ -165,6 +196,7 @@ function projectSemanticInfrastructureValue(value) {
         projectRedis(value, className) ||
         projectKafka(value, className) ||
         projectAmqp(value, className) ||
+        projectMongoInfrastructure(value, className) ||
         projectPostgres(value, className) ||
         projectTypeOrm(value, className));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reproapp/node-sdk",
-  "version": "0.0.49",
+  "version": "0.0.51",
   "description": "Repro Nest SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,11 +9,13 @@
     "node": ">=18"
   },
   "scripts": {
+    "test:live-capture": "npm run build && node test/live-capture-limits.test.js && node test/ingest-throttle-retention.test.js && node test/live-capture-limits.testcontainers.test.js",
+    "test:live-brokers": "npm run build && node test/live-broker-limits.testcontainers.test.js",
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
     "prepublishOnly": "npm run build",
     "test": "npm run build && node test/semantic-serialization.test.js && node test/semantic-serialization-trace.test.js && node test/content-addressed-trace-values.test.js && node test/trace-observation-snapshots.test.js && node test/session-storage-budget.test.js && 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/sdk-background-timeout-isolation.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-high-priority-fairness.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-policy-index.test.js && node test/policy-capture-attestation.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/content-addressed-mongodb.testcontainers.test.js && node test/policy-session-completion.testcontainers.test.js && node test/postgresql-integrations.testcontainers.test.js"
+    "test:containers": "npm run build && node test/background-continuous-traffic.testcontainers.test.js && 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/content-addressed-mongodb.testcontainers.test.js && node test/policy-session-completion.testcontainers.test.js && node test/postgresql-integrations.testcontainers.test.js"
   },
   "peerDependencies": {
     "express": "^5.1.0",
@@ -21,8 +23,11 @@
   },
   "devDependencies": {
     "@nestjs/typeorm": "^11.0.0",
+    "@testcontainers/kafka": "^11.8.1",
     "@types/express": "^5.0.3",
     "@types/pg": "^8.20.0",
+    "amqplib": "^0.10.9",
+    "kafkajs": "^2.2.4",
     "mongodb": "^6.21.0",
     "pg": "^8.22.0",
     "postgres": "^3.4.9",