feat(mongoose): implement orchestrion mongoose integration

Port the OTel mongoose intstrumentation to Orchestrion. Add Deno
integration, and node integration tests for mongoose versions 5, 6, 7,
8, and 9.

Native diagnostics channel used on Mongoose versions supporting them
(ie, 9.7+).

Fix: JS-2412
Fix: #20761

Author: isaacs

dev-packages/node-integration-tests/suites/tracing/mongoose-v5/instrument.mjs

@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+});

dev-packages/node-integration-tests/suites/tracing/mongoose-v5/scenario.mjs

@@ -0,0 +1,36 @@
+import * as Sentry from '@sentry/node';
+import mongoose from 'mongoose';
+
+async function run() {
+  await mongoose.connect(process.env.MONGO_URL || '');
+
+  const BlogPostSchema = new mongoose.Schema({
+    title: String,
+    body: String,
+    date: Date,
+  });
+
+  const BlogPost = mongoose.model('BlogPost', BlogPostSchema);
+
+  await Sentry.startSpan(
+    {
+      name: 'Test Transaction',
+      op: 'transaction',
+    },
+    async () => {
+      const post = new BlogPost({ title: 'Test', body: 'Test body', date: new Date() });
+
+      await post.save();
+
+      await BlogPost.findOne({});
+
+      await BlogPost.aggregate([{ $match: {} }]);
+
+      await BlogPost.insertMany([{ title: 'Insert', body: 'Insert body', date: new Date() }]);
+
+      await BlogPost.bulkWrite([{ insertOne: { document: { title: 'Bulk', body: 'Bulk body', date: new Date() } } }]);
+    },
+  );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/mongoose-v5/test.ts

@@ -0,0 +1,59 @@
+import { MongoMemoryServer } from 'mongodb-memory-server-global';
+import { afterAll, beforeAll, describe, expect } from 'vitest';
+import { isOrchestrionEnabled } from '../../../utils';
+import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
+
+// Pins mongoose 5.9.7
+// the bottom of the IITM patcher's `>=5.9.7 <9.7.0` range, so the oldest
+// supported major is exercised against a real mongoose.
+describe('Mongoose v5 Test', () => {
+  const origin = isOrchestrionEnabled() ? 'auto.db.orchestrion.mongoose' : 'auto.db.otel.mongoose';
+  let mongoServer: MongoMemoryServer;
+
+  beforeAll(async () => {
+    mongoServer = await MongoMemoryServer.create();
+    process.env.MONGO_URL = mongoServer.getUri();
+  }, 30000);
+
+  afterAll(async () => {
+    if (mongoServer) {
+      await mongoServer.stop();
+    }
+    cleanupChildProcesses();
+  });
+
+  const expectedSpan = (operation: string) =>
+    expect.objectContaining({
+      data: expect.objectContaining({
+        'db.mongodb.collection': 'blogposts',
+        'db.operation': operation,
+        'db.system': 'mongoose',
+      }),
+      description: `mongoose.BlogPost.${operation}`,
+      op: 'db',
+      origin,
+    });
+
+  const EXPECTED_TRANSACTION = {
+    transaction: 'Test Transaction',
+    spans: expect.arrayContaining([
+      expectedSpan('save'),
+      expectedSpan('findOne'),
+      expectedSpan('aggregate'),
+      expectedSpan('insertMany'),
+      expectedSpan('bulkWrite'),
+    ]),
+  };
+
+  createEsmAndCjsTests(
+    __dirname,
+    'scenario.mjs',
+    'instrument.mjs',
+    (createTestRunner, test) => {
+      test('auto-instruments `mongoose` v5.', async () => {
+        await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+      });
+    },
+    { additionalDependencies: { mongoose: '^5.9.7' } },
+  );
+});

dev-packages/node-integration-tests/suites/tracing/mongoose-v7/test.ts

@@ -1,9 +1,11 @@
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, describe, expect } from 'vitest';
+import { isOrchestrionEnabled } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
 // Pins mongoose 7 so the `contextCaptureFunctions7` version branch is exercised against a real mongoose.
 describe('Mongoose v7 Test', () => {
+  const origin = isOrchestrionEnabled() ? 'auto.db.orchestrion.mongoose' : 'auto.db.otel.mongoose';
   let mongoServer: MongoMemoryServer;
 
   beforeAll(async () => {
@@ -27,7 +29,7 @@ describe('Mongoose v7 Test', () => {
       }),
       description: `mongoose.BlogPost.${operation}`,
       op: 'db',
-      origin: 'auto.db.otel.mongoose',
+      origin,
     });
 
   const EXPECTED_TRANSACTION = {

dev-packages/node-integration-tests/suites/tracing/mongoose-v8/test.ts

@@ -1,10 +1,12 @@
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, describe, expect } from 'vitest';
+import { isOrchestrionEnabled } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
 // Pins mongoose 8 (>= 8.21) so the document `updateOne`/`deleteOne` lazy-Query path is exercised
 // against a real mongoose, guarding the thenable trap that mongoose 6 (the workspace version) can't hit.
 describe('Mongoose v8 Test', () => {
+  const origin = isOrchestrionEnabled() ? 'auto.db.orchestrion.mongoose' : 'auto.db.otel.mongoose';
   let mongoServer: MongoMemoryServer;
 
   beforeAll(async () => {
@@ -30,7 +32,7 @@ describe('Mongoose v8 Test', () => {
         }),
         description: 'mongoose.BlogPost.save',
         op: 'db',
-        origin: 'auto.db.otel.mongoose',
+        origin,
       }),
       expect.objectContaining({
         data: expect.objectContaining({
@@ -40,7 +42,7 @@ describe('Mongoose v8 Test', () => {
         }),
         description: 'mongoose.BlogPost.updateOne',
         op: 'db',
-        origin: 'auto.db.otel.mongoose',
+        origin,
       }),
       expect.objectContaining({
         data: expect.objectContaining({
@@ -50,7 +52,7 @@ describe('Mongoose v8 Test', () => {
         }),
         description: 'mongoose.BlogPost.deleteOne',
         op: 'db',
-        origin: 'auto.db.otel.mongoose',
+        origin,
       }),
     ]),
   };

dev-packages/node-integration-tests/suites/tracing/mongoose-v9/test.ts

@@ -1,13 +1,14 @@
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, expect } from 'vitest';
-import { conditionalTest } from '../../../utils';
+import { conditionalTest, isOrchestrionEnabled } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
 // Pins the highest mongoose 9 below 9.7, the top of the IITM patcher's `>=5.9.7 <9.7.0` range, so the
 // monkey-patch path is exercised against a real mongoose 9. mongoose >= 9.7 publishes via
 // diagnostics_channel and is covered by the `mongoose-tracing-channel` suite instead.
 // mongoose 9 requires Node >=20.19, so this suite is skipped on older Node.
 conditionalTest({ min: 20 })('Mongoose v9 Test', () => {
+  const origin = isOrchestrionEnabled() ? 'auto.db.orchestrion.mongoose' : 'auto.db.otel.mongoose';
   let mongoServer: MongoMemoryServer;
 
   beforeAll(async () => {
@@ -31,7 +32,7 @@ conditionalTest({ min: 20 })('Mongoose v9 Test', () => {
       }),
       description: `mongoose.BlogPost.${operation}`,
       op: 'db',
-      origin: 'auto.db.otel.mongoose',
+      origin,
     });
 
   const EXPECTED_TRANSACTION = {

dev-packages/node-integration-tests/suites/tracing/mongoose/test.ts

@@ -1,8 +1,10 @@
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, describe, expect } from 'vitest';
+import { isOrchestrionEnabled } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
 describe('Mongoose experimental Test', () => {
+  const origin = isOrchestrionEnabled() ? 'auto.db.orchestrion.mongoose' : 'auto.db.otel.mongoose';
   let mongoServer: MongoMemoryServer;
 
   beforeAll(async () => {
@@ -29,7 +31,7 @@ describe('Mongoose experimental Test', () => {
         }),
         description: 'mongoose.BlogPost.save',
         op: 'db',
-        origin: 'auto.db.otel.mongoose',
+        origin,
       }),
       expect.objectContaining({
         data: expect.objectContaining({
@@ -40,7 +42,7 @@ describe('Mongoose experimental Test', () => {
         }),
         description: 'mongoose.BlogPost.findOne',
         op: 'db',
-        origin: 'auto.db.otel.mongoose',
+        origin,
       }),
       expect.objectContaining({
         data: expect.objectContaining({
@@ -51,7 +53,7 @@ describe('Mongoose experimental Test', () => {
         }),
         description: 'mongoose.BlogPost.aggregate',
         op: 'db',
-        origin: 'auto.db.otel.mongoose',
+        origin,
       }),
       expect.objectContaining({
         data: expect.objectContaining({
@@ -62,7 +64,7 @@ describe('Mongoose experimental Test', () => {
         }),
         description: 'mongoose.BlogPost.insertMany',
         op: 'db',
-        origin: 'auto.db.otel.mongoose',
+        origin,
       }),
       expect.objectContaining({
         data: expect.objectContaining({
@@ -73,7 +75,7 @@ describe('Mongoose experimental Test', () => {
         }),
         description: 'mongoose.BlogPost.bulkWrite',
         op: 'db',
-        origin: 'auto.db.otel.mongoose',
+        origin,
       }),
       // `remove` is patched only on mongoose 5/6.
       expect.objectContaining({
@@ -85,7 +87,7 @@ describe('Mongoose experimental Test', () => {
         }),
         description: 'mongoose.BlogPost.remove',
         op: 'db',
-        origin: 'auto.db.otel.mongoose',
+        origin,
       }),
       // A failing operation still produces a span, marked with an error status.
       expect.objectContaining({
@@ -95,7 +97,7 @@ describe('Mongoose experimental Test', () => {
         }),
         description: 'mongoose.RequiredDoc.save',
         op: 'db',
-        origin: 'auto.db.otel.mongoose',
+        origin,
         status: 'internal_error',
       }),
     ]),

packages/deno/src/index.ts

@@ -117,6 +117,7 @@ export { denoAmqplibIntegration } from './integrations/amqplib';
 export { denoDataloaderIntegration } from './integrations/dataloader';
 export { denoKnexIntegration } from './integrations/knex';
 export { denoKoaIntegration } from './integrations/koa';
+export { denoMongooseIntegration } from './integrations/mongoose';
 export { denoContextIntegration } from './integrations/context';
 export { globalHandlersIntegration } from './integrations/globalhandlers';
 export { normalizePathsIntegration } from './integrations/normalizepaths';

packages/deno/src/integrations/mongoose.ts

@@ -0,0 +1,34 @@
+import { mongooseChannelIntegration } from '@sentry/server-utils/orchestrion';
+import type { Integration, IntegrationFn } from '@sentry/core';
+import { defineIntegration, extendIntegration } from '@sentry/core';
+import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
+
+const INTEGRATION_NAME = 'DenoMongoose' as const;
+
+/**
+ * Create spans for `mongoose` queries under Deno.
+ *
+ * `mongoose` channels are injected by the orchestrion runtime hook at load
+ * time. The `@sentry/deno/import` loader must be active for this integration
+ * to record anything.
+ *
+ * The channel-subscription logic is shared with the other server runtimes in
+ * `@sentry/server-utils`. This just installs Deno's `AsyncLocalStorage`
+ * context strategy (so spans nest under the active span and survive mongoose's
+ * internal callback dispatch) before delegating.
+ */
+const _denoMongooseIntegration = (() => {
+  const inner = mongooseChannelIntegration();
+
+  return extendIntegration(inner, {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      setAsyncLocalStorageAsyncContextStrategy();
+    },
+  });
+}) satisfies IntegrationFn;
+
+export const denoMongooseIntegration = defineIntegration(_denoMongooseIntegration) as () => Integration & {
+  name: 'DenoMongoose';
+  setupOnce: () => void;
+};

packages/deno/src/sdk.ts

@@ -25,6 +25,7 @@ import { denoServeIntegration } from './integrations/deno-serve';
 import { denoHttpIntegration } from './integrations/http';
 import { denoAmqplibIntegration } from './integrations/amqplib';
 import { denoKoaIntegration } from './integrations/koa';
+import { denoMongooseIntegration } from './integrations/mongoose';
 import { denoMysqlIntegration } from './integrations/mysql';
 import { denoPostgresIntegration } from './integrations/postgres';
 import { denoRedisIntegration } from './integrations/redis';
@@ -63,7 +64,13 @@ export function getDefaultIntegrations(_options: Options): Integration[] {
     // (or in parallel to) loading the SDK, so we only gate on whether the
     // feature is possible. If they're never loaded, it'll just be a no-op.
     ...(MODULE_REGISTER_HOOKS_SUPPORTED
-      ? [denoMysqlIntegration(), denoPostgresIntegration(), denoAmqplibIntegration(), denoKoaIntegration()]
+      ? [
+          denoAmqplibIntegration(),
+          denoKoaIntegration(),
+          denoMongooseIntegration(),
+          denoMysqlIntegration(),
+          denoPostgresIntegration(),
+        ]
       : []),
     contextLinesIntegration(),
     normalizePathsIntegration(),