Merge branch 'main' of github.com:open-telemetry/opentelemetry-js-contrib

Author: sudarshan12s

package-lock.json

@@ -106,10 +106,12 @@ export class MongooseInstrumentation extends InstrumentationBase<MongooseInstrum
     return module;
   }
 
-  private patch(
-    moduleExports: typeof mongoose,
-    moduleVersion: string | undefined
-  ) {
+  private patch(module: any, moduleVersion: string | undefined) {
+    const moduleExports: typeof mongoose =
+      module[Symbol.toStringTag] === 'Module'
+        ? module.default // ESM
+        : module; // CommonJS
+
     this._wrap(
       moduleExports.Model.prototype,
       'save',
@@ -154,10 +156,12 @@ export class MongooseInstrumentation extends InstrumentationBase<MongooseInstrum
     return moduleExports;
   }
 
-  private unpatch(
-    moduleExports: typeof mongoose,
-    moduleVersion: string | undefined
-  ): void {
+  private unpatch(module: any, moduleVersion: string | undefined): void {
+    const moduleExports: typeof mongoose =
+      module[Symbol.toStringTag] === 'Module'
+        ? module.default // ESM
+        : module; // CommonJS
+
     const contextCaptureFunctions = getContextCaptureFunctions(moduleVersion);
 
     this._unwrap(moduleExports.Model.prototype, 'save');

plugins/node/instrumentation-mongoose/src/mongoose.ts

@@ -0,0 +1,63 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Use mongoose from an ES module:
+//    node --experimental-loader=@opentelemetry/instrumentation/hook.mjs use-mongoose.mjs [MONGO_URL] [DB_NAME
+
+import { trace } from '@opentelemetry/api';
+import { createTestNodeSdk } from '@opentelemetry/contrib-test-utils';
+
+import { MongooseInstrumentation } from '../../build/src/index.js';
+
+const sdk = createTestNodeSdk({
+  serviceName: 'use-mongoose',
+  instrumentations: [new MongooseInstrumentation()],
+});
+sdk.start();
+
+import assert from 'assert';
+import mongoose from 'mongoose';
+
+const MONGO_URL = process.argv[2] || '';
+const DB_NAME = process.argv[3] || '';
+
+const randomId = ((Math.random() * 2 ** 32) >>> 0).toString(16);
+
+await mongoose.connect(MONGO_URL, {
+  dbName: DB_NAME,
+});
+
+const TestModel = mongoose.model(
+  'Test',
+  new mongoose.Schema({
+    name: String,
+  })
+);
+
+const tracer = trace.getTracer('mongoose-instrumentation');
+await tracer.startActiveSpan('manual', async span => {
+  const name = `test-${randomId}`;
+  const [createdDoc] = await TestModel.create([{ name }]);
+
+  const doc = await TestModel.findOne({ name }).exec();
+
+  assert(doc && createdDoc?._id.toString() === doc?._id.toString());
+
+  span.end();
+});
+
+await mongoose.disconnect();
+await sdk.shutdown();

plugins/node/instrumentation-mongoose/test/fixtures/use-mongoose.mjs

@@ -14,8 +14,10 @@
  * limitations under the License.
  */
 import 'mocha';
+import * as assert from 'assert';
 import { expect } from 'expect';
 import { context, ROOT_CONTEXT } from '@opentelemetry/api';
+import * as testUtils from '@opentelemetry/contrib-test-utils';
 import {
   SEMATTRS_DB_OPERATION,
   SEMATTRS_DB_STATEMENT,
@@ -548,4 +550,27 @@ describe('mongoose instrumentation [common]', () => {
       expect(spans.length).toBe(0);
     });
   });
+
+  it('should work with ESM usage', async () => {
+    await testUtils.runTestFixture({
+      cwd: __dirname,
+      argv: ['fixtures/use-mongoose.mjs', MONGO_URI, DB_NAME],
+      env: {
+        NODE_OPTIONS:
+          '--experimental-loader=@opentelemetry/instrumentation/hook.mjs',
+        NODE_NO_WARNINGS: '1',
+      },
+      checkResult: (err, stdout, stderr) => {
+        assert.ifError(err);
+      },
+      checkCollector: (collector: testUtils.TestCollector) => {
+        const spans = collector.sortedSpans;
+        assert.strictEqual(spans[0].name, 'manual');
+        assert.strictEqual(spans[1].name, 'mongoose.Test.save');
+        assert.strictEqual(spans[1].parentSpanId, spans[0].spanId);
+        assert.strictEqual(spans[2].name, 'mongoose.Test.findOne');
+        assert.strictEqual(spans[2].parentSpanId, spans[0].spanId);
+      },
+    });
+  });
 });

plugins/node/instrumentation-mongoose/test/mongoose-common.test.ts

@@ -1,5 +1,5 @@
 express:
   - versions:
-      include: "^4.16.2"
+      include: ">=4.16.2 <6"
       mode: latest-minors
-    commands: npm run test
+    commands: npm test

plugins/node/opentelemetry-instrumentation-express/.tav.yml

@@ -53,7 +53,7 @@
     "@types/mocha": "10.0.10",
     "@types/node": "18.18.14",
     "@types/sinon": "17.0.4",
-    "express": "4.20.0",
+    "express": "^5.1.0",
     "nyc": "17.1.0",
     "rimraf": "5.0.10",
     "sinon": "15.2.0",

plugins/node/opentelemetry-instrumentation-express/package.json

@@ -60,9 +60,13 @@ export class ExpressInstrumentation extends InstrumentationBase<ExpressInstrumen
     return [
       new InstrumentationNodeModuleDefinition(
         'express',
-        ['>=4.0.0 <5'],
+        ['>=4.0.0 <6'],
         moduleExports => {
-          const routerProto = moduleExports.Router as unknown as express.Router;
+          const isExpressWithRouterPrototype =
+            typeof moduleExports?.Router?.prototype?.route === 'function';
+          const routerProto = isExpressWithRouterPrototype
+            ? moduleExports.Router.prototype // Express v5
+            : moduleExports.Router; // Express v4
           // patch express.Router.route
           if (isWrapped(routerProto.route)) {
             this._unwrap(routerProto, 'route');
@@ -82,13 +86,17 @@ export class ExpressInstrumentation extends InstrumentationBase<ExpressInstrumen
             moduleExports.application,
             'use',
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this._getAppUsePatch() as any
+            this._getAppUsePatch(isExpressWithRouterPrototype) as any
           );
           return moduleExports;
         },
         moduleExports => {
           if (moduleExports === undefined) return;
-          const routerProto = moduleExports.Router as unknown as express.Router;
+          const isExpressWithRouterPrototype =
+            typeof moduleExports?.Router?.prototype?.route === 'function';
+          const routerProto = isExpressWithRouterPrototype
+            ? moduleExports.Router.prototype
+            : moduleExports.Router;
           this._unwrap(routerProto, 'route');
           this._unwrap(routerProto, 'use');
           this._unwrap(moduleExports.application, 'use');
@@ -136,16 +144,24 @@ export class ExpressInstrumentation extends InstrumentationBase<ExpressInstrumen
   /**
    * Get the patch for Application.use function
    */
-  private _getAppUsePatch() {
+  private _getAppUsePatch(isExpressWithRouterPrototype: boolean) {
     const instrumentation = this;
     return function (original: express.Application['use']) {
       return function use(
-        this: { _router: ExpressRouter },
+        // `router` in express@5, `_router` in express@4.
+        this: { _router?: ExpressRouter; router?: ExpressRouter },
         ...args: Parameters<typeof original>
       ) {
+        // If we access app.router in express 4.x we trigger an assertion error.
+        // This property existed in v3, was removed in v4 and then re-added in v5.
+        const router = isExpressWithRouterPrototype
+          ? this.router
+          : this._router;
         const route = original.apply(this, args);
-        const layer = this._router.stack[this._router.stack.length - 1];
-        instrumentation._applyPatch(layer, getLayerPath(args));
+        if (router) {
+          const layer = router.stack[router.stack.length - 1];
+          instrumentation._applyPatch(layer, getLayerPath(args));
+        }
         return route;
       };
     };

plugins/node/opentelemetry-instrumentation-express/src/instrumentation.ts

@@ -97,7 +97,7 @@ export const getLayerMetadata = (
       },
       name: `router - ${extractedRouterPath}`,
     };
-  } else if (layer.name === 'bound dispatch') {
+  } else if (layer.name === 'bound dispatch' || layer.name === 'handle') {
     return {
       attributes: {
         [AttributeNames.EXPRESS_NAME]: