@reproapp/node-sdk 0.0.30 → 0.0.32

package/test/mongodb-esm-import-hook.test.js

@@ -0,0 +1,207 @@
+process.env.REPRO_INGEST_REQUEST_TIMEOUT_MS = '50';
+process.env.REPRO_SDK_BACKGROUND_MAX_DEFER_MS = '25';
+process.env.REPRO_SDK_BACKGROUND_IDLE_DELAY_MS = '0';
+process.env.REPRO_SDK_BACKGROUND_BUSY_IDLE_DELAY_MS = '0';
+process.env.TRACE_IDLE_FLUSH_MS = '10';
+process.env.TRACE_LINGER_AFTER_FINISH_MS = '0';
+
+const assert = require('assert');
+const { EventEmitter } = require('events');
+const { pathToFileURL } = require('url');
+const { join } = require('path');
+const { mkdtempSync, mkdirSync, rmSync, writeFileSync } = require('fs');
+const { tmpdir } = require('os');
+const { initRepro, reproMiddleware, __reproTestHooks } = require('../dist');
+const { flushIngestQueue } = require('../dist/ingest/client');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitFor(predicate, timeoutMs = 3000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate()) return;
+        await sleep(20);
+    }
+    assert(predicate(), 'timed out waiting for expected ingest payload');
+}
+
+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) => Array.isArray(event.payload?.db) ? event.payload.db : []);
+}
+
+function makeReqRes() {
+    const req = new EventEmitter();
+    req.method = 'POST';
+    req.url = '/native-mongodb-esm';
+    req.originalUrl = '/native-mongodb-esm';
+    req.headers = {
+        'x-bug-session-id': 'S_mongo_esm',
+        'x-bug-action-id': 'A_mongo_esm',
+    };
+    req.query = {};
+    req.params = {};
+    req.body = undefined;
+
+    const res = new EventEmitter();
+    res.statusCode = 200;
+    res.getHeader = () => undefined;
+    res.getHeaders = () => ({});
+    res.write = () => true;
+    res.end = function end() {
+        this.emit('finish');
+        return this;
+    };
+
+    return { req, res };
+}
+
+function createEsmMongoFixture() {
+    const root = mkdtempSync(join(tmpdir(), 'repro-node-sdk-esm-mongodb-'));
+    const packageDir = join(root, 'node_modules', 'mongodb');
+    mkdirSync(packageDir, { recursive: true });
+    writeFileSync(join(packageDir, 'package.json'), JSON.stringify({
+        name: 'mongodb',
+        version: '99.0.0-repro-fixture',
+        type: 'module',
+        exports: './index.mjs',
+    }, null, 2));
+    writeFileSync(join(packageDir, 'index.mjs'), `
+export class Collection {
+  constructor(dbName, collectionName) {
+    this.dbName = dbName;
+    this.collectionName = collectionName;
+  }
+
+  async insertOne(doc, options) {
+    if (options?.session?.id !== 'esm-native-session-1') {
+      throw new Error(\`unexpected session \${options?.session?.id}\`);
+    }
+    doc._id = doc._id ?? 'subject-esm-1';
+    return { acknowledged: true, insertedId: doc._id };
+  }
+}
+
+export class Db {
+  constructor(dbName) {
+    this.databaseName = dbName;
+  }
+
+  collection(collectionName) {
+    return new Collection(this.databaseName, collectionName);
+  }
+}
+
+export class MongoClient {
+  constructor(uri) {
+    this.uri = uri;
+  }
+
+  db(dbName) {
+    return new Db(dbName);
+  }
+}
+`);
+    const appFile = join(root, 'app.mjs');
+    writeFileSync(appFile, `
+import { MongoClient } from 'mongodb';
+
+const dbClient = new MongoClient('mongodb://127.0.0.1:27017/clinical');
+
+export async function insertSubject() {
+  const subjectsCollection = dbClient.db('clinical').collection('subjects');
+  return subjectsCollection.insertOne(
+    { subjectNumber: '10013038', status: 'screened' },
+    {
+      session: {
+        id: 'esm-native-session-1',
+        hasEnded: false,
+        inTransaction: () => true,
+      },
+    },
+  );
+}
+`);
+    return { root, appFile };
+}
+
+async function main() {
+    const capturedBodies = [];
+    const originalFetch = global.fetch;
+    let fixtureRoot = null;
+    global.fetch = async (_url, init) => {
+        capturedBodies.push(JSON.parse(String(init?.body ?? '{}')));
+        return {
+            ok: true,
+            status: 202,
+            json: async () => ({ ok: true }),
+            text: async () => '{"ok":true}',
+        };
+    };
+
+    try {
+        const cfg = {
+            tenantId: 'TENANT_test',
+            appId: 'APP_test',
+            appSecret: 'secret',
+            captureHeaders: false,
+            privacy: { environment: 'dev', captureRaw: true },
+            ingestBase: 'http://127.0.0.1:65535',
+        };
+        await initRepro(cfg);
+
+        const fixture = createEsmMongoFixture();
+        fixtureRoot = fixture.root;
+        const fixtureUrl = pathToFileURL(fixture.appFile).href;
+        const { insertSubject } = await import(`${fixtureUrl}?run=${Date.now()}`);
+
+        const middleware = reproMiddleware(cfg);
+        const { req, res } = makeReqRes();
+        await new Promise((resolve, reject) => {
+            middleware(req, res, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                Promise.resolve(insertSubject()).then(resolve, reject);
+            });
+        });
+        res.end();
+
+        await waitFor(() => dbChanges(flattenEvents(capturedBodies)).length === 1);
+        await __reproTestHooks.drainSdkBackgroundQueueForTest();
+        await flushIngestQueue();
+
+        const [change] = dbChanges(flattenEvents(capturedBodies));
+        assert.strictEqual(change.type, 'mongo');
+        assert.strictEqual(change.collection, 'subjects');
+        assert.strictEqual(change.op, 'insertOne');
+        assert.strictEqual(change.pk._id, 'subject-esm-1');
+        assert.strictEqual(change.query.driver, 'mongodb');
+        assert.strictEqual(change.query.db, 'clinical');
+        assert.strictEqual(change.query.doc.subjectNumber, '10013038');
+        assert.strictEqual(change.query.options.session.__kind, 'mongodb_client_session');
+        assert.strictEqual(change.query.options.session.id, 'esm-native-session-1');
+        assert.strictEqual(change.after.subjectNumber, '10013038');
+        assert.strictEqual(change.resultMeta.insertedId, 'subject-esm-1');
+
+        console.log('mongodb esm import hook OK');
+    } finally {
+        await __reproTestHooks.drainSdkBackgroundQueueForTest();
+        await flushIngestQueue();
+        if (fixtureRoot) {
+            try { rmSync(fixtureRoot, { recursive: true, force: true }); } catch {}
+        }
+        global.fetch = originalFetch;
+    }
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/test/mongodb-suppression-cleanup.test.js

@@ -0,0 +1,72 @@
+const assert = require('assert');
+const mongoose = require('mongoose');
+const { reproMongoosePlugin, __reproTestHooks } = require('../dist');
+
+function execPre(hooks, name, context) {
+    return new Promise((resolve, reject) => {
+        hooks.execPre(name, context, [], (error) => (error ? reject(error) : resolve()));
+    });
+}
+
+function execPost(hooks, name, context, args = []) {
+    return new Promise((resolve, reject) => {
+        hooks.execPost(name, context, args, {}, (error) => (error ? reject(error) : resolve()));
+    });
+}
+
+async function testPostSaveEarlyReturnReleasesSuppression() {
+    const schema = new mongoose.Schema({ name: String });
+    reproMongoosePlugin({
+        tenantId: 'TENANT_test',
+        appId: 'APP_test',
+        appSecret: 'secret',
+        privacy: { environment: 'dev', captureRaw: true },
+        ingestBase: 'http://127.0.0.1:65535',
+    })(schema);
+    const Model = mongoose.model(`ReproSuppressionCleanup${Date.now()}`, schema, 'subjects');
+    const doc = new Model({ name: 'subject' });
+
+    await __reproTestHooks.runWithRequestContextForTest({ sid: 'S_cleanup', aid: 'A_cleanup' }, async () => {
+        await execPre(schema.s.hooks, 'save', doc);
+        assert.equal(__reproTestHooks.getNativeMongoSuppressionCountForTest(), 1);
+
+        // No rid/span is present, so the post hook exits through shouldCaptureDbSpan(false).
+        await execPost(schema.s.hooks, 'save', doc, [doc]);
+        assert.equal(__reproTestHooks.getNativeMongoSuppressionCountForTest(), 0);
+    });
+}
+
+async function testPostSaveOutsideOriginalAlsReleasesOwnerStoreSuppression() {
+    const schema = new mongoose.Schema({ name: String });
+    reproMongoosePlugin({
+        tenantId: 'TENANT_test',
+        appId: 'APP_test',
+        appSecret: 'secret',
+        privacy: { environment: 'dev', captureRaw: true },
+        ingestBase: 'http://127.0.0.1:65535',
+    })(schema);
+    const Model = mongoose.model(`ReproSuppressionOwnerStore${Date.now()}`, schema, 'subjects');
+    const doc = new Model({ name: 'subject' });
+
+    let token;
+    await __reproTestHooks.runWithRequestContextForTest({ sid: 'S_owner', aid: 'A_owner', rid: 'R_owner' }, async () => {
+        await execPre(schema.s.hooks, 'save', doc);
+        assert.equal(__reproTestHooks.getNativeMongoSuppressionCountForTest(), 1);
+        token = doc.__repro_native_mongo_suppression;
+        assert.equal(token.ownerStore.nativeMongoSuppressions.length, 1);
+    });
+
+    await execPost(schema.s.hooks, 'save', doc, [doc]);
+    assert.equal(token.ownerStore, undefined);
+}
+
+async function main() {
+    await testPostSaveEarlyReturnReleasesSuppression();
+    await testPostSaveOutsideOriginalAlsReleasesOwnerStoreSuppression();
+    console.log('mongodb suppression cleanup OK');
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});