@reproapp/node-sdk 0.0.49 → 0.0.51

package/test/live-capture-limits.testcontainers.test.js

@@ -0,0 +1,78 @@
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '30';
+process.env.TRACE_IDLE_FLUSH_MS = '10';
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const { GenericContainer, Wait } = require('testcontainers');
+const { initRepro } = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+async function main() {
+  const posts = [];
+  const sink = http.createServer((req, res) => {
+    const chunks = [];
+    req.on('data', chunk => chunks.push(chunk));
+    req.on('end', () => { posts.push(JSON.parse(Buffer.concat(chunks))); res.writeHead(202); res.end('{}'); });
+  });
+  await new Promise(resolve => sink.listen(0, '127.0.0.1', resolve));
+  let mongo, app;
+  try {
+    mongo = await new GenericContainer('mongo:7').withExposedPorts(27017).withWaitStrategy(Wait.forListeningPorts()).start();
+    const config = { tenantId: 'TENANT_limits', appId: 'APP_limits', appSecret: 'test',
+      privacy: { environment: 'dev', captureRaw: true }, ingestBase: `http://127.0.0.1:${sink.address().port}`,
+      tracing: { fullValueCapture: true, disableFunctionTypes: ['constructor'], logFunctionCalls: false } };
+    await initRepro(config);
+    app = await require('./fixtures/live-capture-limits-server').start(config, `mongodb://${mongo.getHost()}:${mongo.getMappedPort(27017)}/limits`);
+    for (const mode of ['live', 'staging']) {
+      const response = await fetch(`http://127.0.0.1:${app.server.address().port}/shipment?__repro_sid=S_${mode}&__repro_aid=A_${mode}&__repro_mode=${mode}`);
+      assert.equal(response.status, 200);
+      const actual = await response.json();
+      assert.equal(actual.rows.length, 157, 'recording must not alter the application response');
+      assert.equal(actual.rows[156].id, 156);
+    }
+    const deadline = Date.now() + 30_000;
+    let events = [];
+    do {
+      await flushIngestQueue();
+      events = posts.flatMap(post => post.events || []);
+      if (events.filter(event => event.event_type === 'request_capture_manifest').length >= 2) break;
+      await sleep(100);
+    } while (Date.now() < deadline);
+    for (const mode of ['live', 'staging']) {
+      const scoped = events.filter(event => event.session_id === `S_${mode}`);
+      const request = scoped.find(event => event.event_type === 'backend_request')?.payload?.request;
+      assert(request, `missing ${mode} request`);
+      const values = scoped.flatMap(event => [...(event.payload?.traceValues || []), ...(event.payload?.requestValues || []), ...(event.payload?.dbValues || [])]);
+      if (request.respBodyValueCapture?.valueId) assert(values.some(value => value.id === request.respBodyValueCapture.valueId), 'response reference must resolve');
+      const body = values.find(value => value.id === request.respBodyValueCapture?.valueId)?.value || request.respBody;
+      assert(body?.rows, `missing ${mode} response body`);
+      assert.equal(body.rows.length, mode === 'live' ? 101 : 157, JSON.stringify({ mode, capture: request.respBodyValueCapture, valueTargets: values.map(value => value.target) }));
+      if (mode === 'live') {
+        assert.equal(body.rows[100].originalCount, 157);
+        assert.equal(request.respBodyValueCapture.complete, false);
+      }
+      const changes = scoped.filter(event => event.event_type === 'db_change').flatMap(event => event.payload?.db || []);
+      const read = changes.find(change => change.op === 'findOne');
+      assert(read, `missing ${mode} database query`);
+      const result = values.find(value => value.id === read.resultMetaValueCapture?.valueId)?.value || read.resultMeta;
+      const resultText = JSON.stringify(result);
+      assert(resultText?.includes('SHIP-LIMIT'), `missing ${mode} database result ${JSON.stringify(read)}`);
+      assert.equal(resultText.includes('"id":156'), mode === 'staging', 'query results must follow the same mode as responses');
+      if (mode === 'live') assert.equal(read.resultMetaValueCapture.complete, false);
+      const trace = scoped.flatMap(event => event.payload?.trace || []).find(event => event.fn === 'inspectShipment' && event.type === 'enter');
+      assert(trace, `missing ${mode} function arguments`);
+      const args = values.find(value => value.id === trace.argsValueCapture?.valueId)?.value || trace.args;
+      assert.equal(args[0].rows.length, mode === 'live' ? 101 : 157);
+    }
+    console.log('real Mongo + Express + instrumented traces: live bounds and exact staging evidence passed');
+  } finally {
+    if (app) await app.close();
+    await flushIngestQueue();
+    await new Promise(resolve => sink.close(resolve));
+    if (mongo) await mongo.stop();
+  }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });