dd-trace 5.114.0 → 5.116.0

package/packages/datadog-instrumentations/src/grpc/server.js

@@ -2,6 +2,7 @@
 
 const { channel, addHook } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
+const { FOREIGN_HTTP2_SERVER } = require('../../../dd-trace/src/constants')
 const types = require('./types')
 
 const startChannel = channel('apm:grpc:server:request:start')
@@ -76,6 +77,22 @@ function wrapRegister (register) {
   }
 }
 
+function wrapSetupHandlers (setupHandlers) {
+  return function (http2Server) {
+    // gRPC builds its transport on a core Node `Http2Server` and drives every
+    // call through its own span lifecycle over the raw 'stream' event. Mark the
+    // server so the http2 server instrumentation leaves it untraced; otherwise
+    // its re-enabled 'stream' path would wrap every gRPC call in a second
+    // web.request span and become the top frame. `_setupHandlers` is the single
+    // server-creation funnel across all supported versions (the older
+    // `createHttp2Server` does not exist), and it runs at bind time, before any
+    // request reaches the wrapped `emit`.
+    if (http2Server) http2Server[FOREIGN_HTTP2_SERVER] = true
+
+    return setupHandlers.apply(this, arguments)
+  }
+}
+
 function createWrapEmit (call, ctx, onCancel) {
   return function wrapEmit (emit) {
     return function (event, arg1) {
@@ -149,6 +166,7 @@ function isEmitter (obj) {
 
 addHook({ name: '@grpc/grpc-js', versions: ['>=1.0.3'], file: 'build/src/server.js' }, server => {
   shimmer.wrap(server.Server.prototype, 'register', wrapRegister)
+  shimmer.wrap(server.Server.prototype, '_setupHandlers', wrapSetupHandlers)
 
   return server
 })

package/packages/datadog-instrumentations/src/helpers/hook.js

@@ -49,10 +49,19 @@ function Hook (modules, hookOptions, onrequire) {
   this._patched = Object.create(null)
   const patched = new WeakMap()
 
+  /**
+   * @param {object|Function|undefined} moduleExports
+   * @param {string} moduleName
+   * @param {string|undefined} moduleBaseDir
+   * @param {string|undefined} moduleVersion
+   * @param {boolean|undefined} isIitm
+   */
   const safeHook = (moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm) => {
     const parts = [moduleBaseDir, moduleName].filter(Boolean)
     const filename = path.join(...parts)
 
+    const defaultExport = isIitm && moduleExports.default
+    let defaultExportAliases
     let defaultWrapResult
 
     const wrappedOnrequire = (moduleExports, ...args) => {
@@ -77,17 +86,29 @@ function Hook (modules, hookOptions, onrequire) {
     }
 
     if (
-      isIitm &&
-      moduleExports.default &&
-      (typeof moduleExports.default === 'object' ||
-      typeof moduleExports.default === 'function')
+      defaultExport &&
+      (typeof defaultExport === 'object' ||
+      typeof defaultExport === 'function')
     ) {
-      defaultWrapResult = wrappedOnrequire(moduleExports.default, moduleName, moduleBaseDir, moduleVersion, isIitm)
+      defaultWrapResult = wrappedOnrequire(defaultExport, moduleName, moduleBaseDir, moduleVersion, isIitm)
+      if (defaultWrapResult && defaultWrapResult !== defaultExport) {
+        defaultExportAliases = []
+        for (const exportName of Object.keys(moduleExports)) {
+          if (exportName !== 'default' && moduleExports[exportName] === defaultExport) {
+            defaultExportAliases.push(exportName)
+          }
+        }
+      }
     }
 
     const newExports = wrappedOnrequire(moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm)
 
-    if (defaultWrapResult) newExports.default = defaultWrapResult
+    if (defaultWrapResult && defaultExportAliases) {
+      newExports.default = defaultWrapResult
+      for (const exportName of defaultExportAliases) {
+        moduleExports[exportName] = defaultWrapResult
+      }
+    }
 
     this._patched[filename] = true
 

package/packages/datadog-instrumentations/src/helpers/optional-peer-bundler.js

@@ -4,19 +4,19 @@ const path = require('node:path')
 
 // Build-time half of the optional-peer mechanism shared by the webpack and esbuild plugins.
 //
-// Runtime files load an optional peer through `requireOptionalPeer('name')` (see
-// `require-optional-peer.js`), which bundlers cannot follow, so a build that does not opt into
-// the feature never pulls in the peer's (possibly optional) dependency chain (#8635). When the
-// peer is installed at build time the user has opted in, so the plugins rewrite the call into a
-// literal `require('name')` and let the bundler inline the peer, which keeps it working after
-// the bundle is relocated to a tree without the peer on disk (#8980). Peers that are absent at
-// build time stay opaque, so the rewrite is a no-op and the #8635 guarantee holds.
+// Runtime files load an optional peer through a local `requireOptionalPeer('name')` wrapper.
+// File tracers recognize its bound-require shape, while bundlers cannot follow the dynamic
+// argument, so a build that does not opt into the feature never pulls in the peer's dependency
+// chain (#8635). When the peer is installed at build time the user has opted in, so the plugins
+// rewrite the call into a literal `require('name')` and let the bundler inline the peer, which
+// keeps it working after the bundle is relocated without the peer on disk (#8980). Peers that
+// are absent at build time stay opaque, so the rewrite is a no-op and the #8635 guarantee holds.
 
 // Files that load an optional peer this way, as suffixes of the resolved module path. The same
 // suffix matches the repo layout and `node_modules/dd-trace`. Add a file here to extend the
 // mechanism to a new optional peer; no plugin change is needed.
 const OPTIONAL_PEER_FILES = [
-  'packages/dd-trace/src/openfeature/flagging_provider.js',
+  'packages/dd-trace/src/openfeature/require-provider.js',
 ]
 
 // Captures the peer name from `requireOptionalPeer('name')` / `requireOptionalPeer("name")`.

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/playwright.js

@@ -1,8 +1,34 @@
 'use strict'
 
-// Playwright 1.60 bundles several former hook targets into local classes/functions.
-// Keep these rewrites limited to private bundled internals that addHook cannot wrap.
+// Playwright keeps several hook targets in private local classes/functions.
+// Keep these rewrites limited to bundled internals that addHook cannot wrap.
 module.exports = [
+  {
+    module: {
+      name: 'playwright',
+      versionRange: '>=1.38.0 <1.51.0',
+      filePath: 'lib/index.js',
+    },
+    functionQuery: {
+      className: 'ArtifactsRecorder',
+      methodName: '_createScreenshotAttachmentPath',
+      kind: 'Sync',
+    },
+    channelName: 'ArtifactsRecorder_createScreenshotAttachmentPath',
+  },
+  {
+    module: {
+      name: 'playwright',
+      versionRange: '>=1.51.0',
+      filePath: 'lib/index.js',
+    },
+    functionQuery: {
+      className: 'SnapshotRecorder',
+      methodName: '_createAttachmentPath',
+      kind: 'Sync',
+    },
+    channelName: 'SnapshotRecorder_createAttachmentPath',
+  },
   {
     module: {
       name: 'playwright',

package/packages/datadog-instrumentations/src/helpers/router-helper.js

@@ -4,7 +4,7 @@ const shimmer = require('../../../datadog-shimmer')
 const { channel } = require('./instrument')
 
 const routerMountPaths = new WeakMap() // to track mount paths for router instances
-const layerMatchers = new WeakMap() // to store layer matchers
+const layerMeta = new WeakMap() // per-layer middleware dispatch metadata (resolved name + route matchers)
 const appMountedRouters = new WeakSet() // to track routers mounted via app.use()
 
 const METHODS = [...require('http').METHODS.map(v => v.toLowerCase()), 'all']
@@ -70,7 +70,7 @@ function collectRoutesFromRouter (router, prefix) {
       // Extract mount path from layer
       const mountPath = typeof layer.path === 'string'
         ? layer.path
-        : getLayerMatchers(layer)?.[0]?.path || ''
+        : getLayerMeta(layer)?.matchers?.[0]?.path || ''
 
       const nestedPrefix = joinPath(prefix, mountPath)
       if (nestedPrefix === null) continue
@@ -121,12 +121,12 @@ function getRouterMountPaths (router) {
   return [...paths]
 }
 
-function setLayerMatchers (layer, matchers) {
-  layerMatchers.set(layer, matchers)
+function setLayerMeta (layer, meta) {
+  layerMeta.set(layer, meta)
 }
 
-function getLayerMatchers (layer) {
-  return layerMatchers.get(layer)
+function getLayerMeta (layer) {
+  return layerMeta.get(layer)
 }
 
 function normalizeMethodName (method) {
@@ -224,8 +224,8 @@ module.exports = {
   setRouterMountPath,
   getRouterMountPaths,
   joinPath,
-  setLayerMatchers,
-  getLayerMatchers,
+  setLayerMeta,
+  getLayerMeta,
   markAppMounted,
   isAppMounted,
   normalizeRoutePath,

package/packages/datadog-instrumentations/src/http2/server.js

@@ -1,18 +1,26 @@
 'use strict'
 
-// Old instrumentation temporarily replaced with compatibility mode only instrumentation.
-// See https://github.com/DataDog/dd-trace-js/issues/312
-
 const {
   channel,
   addHook,
 } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
+const { FOREIGN_HTTP2_SERVER } = require('../../../dd-trace/src/constants')
 
 const startServerCh = channel('apm:http2:server:request:start')
 const errorServerCh = channel('apm:http2:server:request:error')
+const adoptServerCh = channel('apm:http2:server:request:adopt')
 const emitCh = channel('apm:http2:server:response:emit')
 
+const HTTP2_HEADER_METHOD = ':method'
+const HTTP2_HEADER_PATH = ':path'
+const HTTP2_HEADER_STATUS = ':status'
+
+// Streams whose server span was already created from the 'stream' event. The
+// compatibility layer synthesizes 'request' from that same stream, so the
+// 'request' branch consults this set to avoid creating a second span.
+const tracedStreams = new WeakSet()
+
 addHook({ name: 'http2' }, http2 => {
   shimmer.wrap(http2, 'createSecureServer', wrapCreateServer)
   shimmer.wrap(http2, 'createServer', wrapCreateServer)
@@ -36,34 +44,152 @@ function wrapResponseEmit (originalEmit, ctx) {
   }
 }
 
+function wrapStreamEmit (originalEmit, ctx) {
+  // Named `emit`/arity-1 mirrors the stream method so the per-stream wrap skips
+  // its name/length rewrite. `this` is the Http2Stream; the plugin finishes on
+  // 'close', the same finish signal as the compatibility response.
+  return function emit (eventName) {
+    ctx.eventName = eventName
+    return emitCh.runStores(ctx, originalEmit, this, ...arguments)
+  }
+}
+
 function wrapEmit (originalEmit) {
   // Named `emit` mirrors the server method so the one-time wrap skips its name
   // rewrite; rest params keep the per-event forwarding allocation-free.
   return function emit (...args) {
-    if (!startServerCh.hasSubscribers) {
+    // A server owned by another instrumentation (e.g. @grpc/grpc-js) drives its
+    // own span lifecycle over the raw 'stream' API, so tracing it here would add
+    // a spurious web.request span on top of that integration's span and steal
+    // the top frame. Skip it entirely; the mark is set at server creation, so
+    // this is one property read on servers we do trace.
+    if (!startServerCh.hasSubscribers || this[FOREIGN_HTTP2_SERVER]) {
       return Reflect.apply(originalEmit, this, args)
     }
 
     const eventName = args[0]
-    if (eventName === 'request') {
+    if (eventName === 'stream') {
+      // The compatibility layer synthesizes 'request' from an internal 'stream'
+      // listener it registers exactly once when a 'request' listener is added,
+      // so `listenerCount('stream')` exceeds one only when the application also
+      // registered a raw-stream listener. Owning the span here for that case
+      // keeps it active while the application's stream listener runs; the
+      // synthesized 'request' that fires nested below then reuses it. A
+      // request-only server (no raw-stream listener) is left to the 'request'
+      // branch so the compatibility response keeps its richer req/res.
+      const requestListenerCount = this.listenerCount('request')
+      if (requestListenerCount === 0 || this.listenerCount('stream') > 1) {
+        const stream = args[1]
+        const headers = args[2]
+        const ctx = createStreamAdapter(stream, headers)
+        // Only a mixed server (a 'request' listener is present) synthesizes a
+        // real request off this stream and adopts the span later, so only then
+        // does the context need keying on the stream. A raw-stream-only server
+        // never adopts; leaving the flag unset keeps the stream->context write
+        // off its hot path.
+        ctx.adoptable = requestListenerCount !== 0
+        tracedStreams.add(stream)
+
+        return traceServerRequest(ctx, () => {
+          shimmer.wrap(stream, 'emit', emit => wrapStreamEmit(emit, ctx))
+          return Reflect.apply(originalEmit, this, args)
+        })
+      }
+    } else if (eventName === 'request') {
       const req = args[1]
       const res = args[2]
       res.req = req
 
-      const ctx = { req, res }
-      return startServerCh.runStores(ctx, () => {
-        shimmer.wrap(res, 'emit', emit => wrapResponseEmit(emit, ctx))
-
-        try {
+      // A mixed server (raw-stream + 'request' listeners) already created the
+      // span from the 'stream' event above; the stream's single 'close' is the
+      // sole finish source, so skip creating a second span. The synthesized
+      // request/response are the real objects a user's 'request' handler and
+      // the finish `hooks.request` expect, so hand them to the existing
+      // stream-backed context rather than leaving it on the throwaway adapter.
+      if (tracedStreams.has(req.stream)) {
+        adoptServerCh.publish({ req, res })
+      } else {
+        const ctx = { req, res }
+        return traceServerRequest(ctx, () => {
+          shimmer.wrap(res, 'emit', emit => wrapResponseEmit(emit, ctx))
           return Reflect.apply(originalEmit, this, args)
-        } catch (error) {
-          ctx.error = error
-          errorServerCh.publish(ctx)
-
-          throw error
-        }
-      })
+        })
+      }
     }
+
     return Reflect.apply(originalEmit, this, args)
   }
 }
+
+// Enter the request context and run `emitEvent` (the original `emit`, wrapped to
+// publish per-event for the matching response/stream), publishing any synchronous
+// throw from a user handler before letting it propagate.
+/**
+ * @param {StreamRequestContext | { req: object, res: object }} ctx
+ * @param {() => unknown} emitEvent
+ */
+function traceServerRequest (ctx, emitEvent) {
+  return startServerCh.runStores(ctx, () => {
+    try {
+      return emitEvent()
+    } catch (error) {
+      ctx.error = error
+      errorServerCh.publish(ctx)
+      throw error
+    }
+  })
+}
+
+/**
+ * The minimal req/res pair the shared web lifecycle (`web.js`) keys on, built
+ * from a core-API `Http2Stream`. The fields below are exactly the surface
+ * `web.js` / `url.js` / `ip_extractor.js` read for a stream-backed request; a
+ * new read added there must be mirrored here or it resolves to `undefined` on
+ * the core path only.
+ *
+ * @typedef {object} StreamRequestContext
+ * @property {object} req
+ * @property {import('node:http2').ServerHttp2Stream} req.stream branch key in `web.js`/`url.js`
+ * @property {import('node:http2').IncomingHttpHeaders} req.headers raw pseudo-header map
+ * @property {string} [req.method]
+ * @property {string} [req.url]
+ * @property {import('node:net').Socket} [req.socket] peer address source (OTel)
+ * @property {object} res
+ * @property {object} res.req back-reference used by `wrapResponseEmit`/finish
+ * @property {number} res.statusCode read at finish from `stream.sentHeaders`
+ * @property {(name: string) => string | number | string[] | undefined} res.getHeader response-header tagging
+ */
+
+// Present the core-API stream + pseudo-header map as the minimal req/res pair
+// the shared web lifecycle (`web.js`) consumes. The response status and headers
+// are getters because `stream.sentHeaders` is empty until `stream.respond()`
+// runs in the user handler; a snapshot taken here would always be `undefined`.
+/**
+ * @param {import('node:http2').ServerHttp2Stream} stream
+ * @param {import('node:http2').IncomingHttpHeaders} headers
+ * @returns {StreamRequestContext}
+ */
+function createStreamAdapter (stream, headers) {
+  const req = {
+    stream,
+    headers,
+    method: headers[HTTP2_HEADER_METHOD],
+    url: headers[HTTP2_HEADER_PATH],
+    socket: stream.session?.socket,
+  }
+  const res = {
+    req,
+    get statusCode () {
+      // A stream aborted before `stream.respond()` has no `:status`. The
+      // compatibility `Http2ServerResponse.statusCode` defaults to 200 in that
+      // case, so match it rather than report `undefined` (which `validateStatus`
+      // would treat as an error and which drops the `http.status_code` tag).
+      return stream.sentHeaders?.[HTTP2_HEADER_STATUS] ?? 200
+    },
+    getHeader (name) {
+      return stream.sentHeaders?.[name]
+    },
+  }
+
+  return { req, res }
+}

package/packages/datadog-instrumentations/src/jest.js

@@ -1858,13 +1858,39 @@ function resetSuiteSkippingRunState () {
   coverageBackfillFiles = undefined
 }
 
+function resetLibraryConfiguration () {
+  knownTests = {}
+  isCodeCoverageEnabled = false
+  isCoverageReportUploadEnabled = false
+  isItrEnabled = false
+  isSuitesSkippingEnabled = false
+  isEarlyFlakeDetectionEnabled = false
+  earlyFlakeDetectionNumRetries = 0
+  earlyFlakeDetectionSlowTestRetries = {}
+  earlyFlakeDetectionFaultyThreshold = 30
+  isEarlyFlakeDetectionFaulty = false
+  isKnownTestsEnabled = false
+  isTestManagementTestsEnabled = false
+  testManagementTests = {}
+  testManagementAttemptToFixRetries = 0
+  isImpactedTestsEnabled = false
+  modifiedFiles = {}
+  repositoryRoot = undefined
+}
+
 function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
   if (!isItrEnabled || !isSuitesSkippingEnabled) return originalTests
 
-  const suitePathRoot = getRepositoryRootFromTest(originalTests[0], rootDir)
-  const jestSuitesToRun = getJestSuitesToRun(skippableSuites, originalTests, suitePathRoot)
+  const repositoryRoot = getRepositoryRootFromTest(originalTests[0], rootDir)
+  const jestSuitesToRun = getJestSuitesToRun(skippableSuites, originalTests, repositoryRoot, rootDir)
   hasFilteredSkippableSuites = true
-  log.debug('%d out of %d suites are going to run.', jestSuitesToRun.suitesToRun.length, originalTests.length)
+  log.debug(
+    'Jest discovered %d suites; skipped %d using %d skippable candidates; %d suites will run.',
+    originalTests.length,
+    jestSuitesToRun.skippedSuites.length,
+    skippableSuites.length,
+    jestSuitesToRun.suitesToRun.length
+  )
   hasUnskippableSuites = jestSuitesToRun.hasUnskippableSuites
   hasForcedToRunSuites = jestSuitesToRun.hasForcedToRunSuites
 
@@ -1877,7 +1903,7 @@ function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
     ? getTestContexts(originalTests)
     : undefined
   coverageBackfillFiles = isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage()
-    ? getCoverageBackfillFiles(skippableSuitesCoverage, suitePathRoot, getTestSuitePath)
+    ? getCoverageBackfillFiles(skippableSuitesCoverage, repositoryRoot, getTestSuitePath)
     : undefined
 
   itrSkippedSuitesCh.publish({ skippedSuites: jestSuitesToRun.skippedSuites, frameworkVersion })
@@ -2205,11 +2231,13 @@ function getCliWrapper (isNewJestVersion) {
       resetSuiteSkippingRunState()
       hasFinishedTestSession = false
 
+      let shouldResetLibraryConfiguration = true
       try {
         const { err, libraryConfig } = await getChannelPromise(libraryConfigurationCh, {
           frameworkVersion: jestVersion,
         })
         if (!err) {
+          shouldResetLibraryConfiguration = false
           isCodeCoverageEnabled = libraryConfig.isCodeCoverageEnabled
           isCoverageReportUploadEnabled = libraryConfig.isCoverageReportUploadEnabled
           isItrEnabled = libraryConfig.isItrEnabled
@@ -2225,6 +2253,10 @@ function getCliWrapper (isNewJestVersion) {
         }
       } catch (err) {
         log.error('Jest library configuration error', err)
+      } finally {
+        if (shouldResetLibraryConfiguration) {
+          resetLibraryConfiguration()
+        }
       }
 
       const {

package/packages/datadog-instrumentations/src/mariadb.js

@@ -135,7 +135,7 @@ function wrapPoolMethod (createConnection) {
 
 function wrapPoolGetConnectionMethod (getConnection) {
   return function wrappedGetConnection (...args) {
-    const cb = args[args.length - 1]
+    const cb = args.at(-1)
     if (typeof cb !== 'function') return getConnection.apply(this, args)
 
     const ctx = {}

package/packages/datadog-instrumentations/src/mocha/main.js

@@ -553,7 +553,6 @@ addHook({
 
     const runner = run.apply(this, args)
 
-    // eslint-disable-next-line unicorn/no-array-for-each
     this.files.forEach((path) => {
       const isUnskippable = isMarkedAsUnskippable({ path })
       if (isUnskippable) {
@@ -915,7 +914,6 @@ addHook({
         status = 'skip'
       } else {
         // has to check every test in the test file
-        // eslint-disable-next-line unicorn/no-array-for-each
         suitesInTestFile.forEach(suite => {
           suite.eachTest(test => {
             if (test.state === 'failed' || test.timedOut) {

package/packages/datadog-instrumentations/src/mocha/utils.js

@@ -229,7 +229,6 @@ function getSuitesByTestFile (root) {
         suitesByTestFile[suite.file] = [suite]
       }
     }
-    // eslint-disable-next-line unicorn/no-array-for-each
     suite.suites.forEach(suite => {
       getSuites(suite)
     })
@@ -920,7 +919,6 @@ function getOnPendingHandler () {
 function getRunTestsWrapper (runTests, config) {
   return function (suite) {
     if (config.isTestManagementTestsEnabled) {
-      // eslint-disable-next-line unicorn/no-array-for-each
       suite.tests.forEach((test) => {
         const { isAttemptToFix, isDisabled, isQuarantined } = getTestProperties(test, config.testManagementTests)
         if (isAttemptToFix && !test.isPending()) {
@@ -944,7 +942,6 @@ function getRunTestsWrapper (runTests, config) {
     }
 
     if (config.isImpactedTestsEnabled) {
-      // eslint-disable-next-line unicorn/no-array-for-each
       suite.tests.forEach((test) => {
         isModifiedCh.publish({
           modifiedFiles: config.modifiedFiles,
@@ -968,7 +965,6 @@ function getRunTestsWrapper (runTests, config) {
 
     if (config.isKnownTestsEnabled) {
       // by the time we reach `this.on('test')`, it is too late. We need to add retries here
-      // eslint-disable-next-line unicorn/no-array-for-each
       suite.tests.forEach((test) => {
         if (!test.isPending() && isNewTest(test, config.knownTests)) {
           test._ddIsNew = true

package/packages/datadog-instrumentations/src/mongodb.js

@@ -20,11 +20,11 @@ const collectionMethodsWithFilter = [
   'replaceOne',
 ] // findOne is ignored because it calls to find
 
-const collectionMethodsWithTwoFilters = [
+const collectionMethodsWithTwoFilters = new Set([
   'findOneAndUpdate',
   'updateMany',
   'updateOne',
-]
+])
 
 const startCh = channel('datadog:mongodb:collection:filter:start')
 
@@ -36,7 +36,7 @@ addHook({ name: 'mongodb', versions: ['>=3.3 <5', '5', '>=6'] }, mongodb => {
   for (const methodName of [...collectionMethodsWithFilter, ...collectionMethodsWithTwoFilters]) {
     if (!(methodName in mongodb.Collection.prototype)) continue
 
-    const useTwoArguments = collectionMethodsWithTwoFilters.includes(methodName)
+    const useTwoArguments = collectionMethodsWithTwoFilters.has(methodName)
 
     shimmer.wrap(mongodb.Collection.prototype, methodName, method => {
       return function (...args) {

package/packages/datadog-instrumentations/src/mongoose.js

@@ -55,11 +55,11 @@ const collectionMethodsWithFilter = [
   'remove',
 ]
 
-const collectionMethodsWithTwoFilters = [
+const collectionMethodsWithTwoFilters = new Set([
   'findOneAndUpdate',
   'updateMany',
   'updateOne',
-]
+])
 
 addHook({
   name: 'mongoose',
@@ -67,7 +67,7 @@ addHook({
   file: 'lib/model.js',
 }, Model => {
   for (const methodName of [...collectionMethodsWithFilter, ...collectionMethodsWithTwoFilters]) {
-    const useTwoArguments = collectionMethodsWithTwoFilters.includes(methodName)
+    const useTwoArguments = collectionMethodsWithTwoFilters.has(methodName)
     if (!(methodName in Model)) continue
 
     shimmer.wrap(Model, methodName, method => {

package/packages/datadog-instrumentations/src/mquery.js

@@ -20,14 +20,14 @@ const methods = [
   'where',
 ]
 
-const methodsOptionalArgs = ['findOneAndUpdate']
+const methodsOptionalArgs = new Set(['findOneAndUpdate'])
 
 function getFilters (args, methodName) {
   const [arg0, arg1] = args
 
   const filters = arg0 !== null && typeof arg0 === 'object' ? [arg0] : []
 
-  if (arg1 !== null && typeof arg1 === 'object' && methodsOptionalArgs.includes(methodName)) {
+  if (arg1 !== null && typeof arg1 === 'object' && methodsOptionalArgs.has(methodName)) {
     filters.push(arg1)
   }
 

package/packages/datadog-instrumentations/src/mysql.js

@@ -84,7 +84,7 @@ addHook({ name: 'mysql', file: 'lib/Pool.js', versions: ['>=2'] }, Pool => {
     const finish = () => finishPoolQueryCh.publish(ctx)
 
     return startPoolQueryCh.runStores(ctx, () => {
-      const cb = args[args.length - 1]
+      const cb = args.at(-1)
       if (typeof cb === 'function') {
         args[args.length - 1] = shimmer.wrapCallback(cb, cb => function (...args) {
           return finishPoolQueryCh.runStores(ctx, cb, this, ...args)

package/packages/datadog-instrumentations/src/next.js

@@ -1,6 +1,9 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
+const nomenclature = require('../../dd-trace/src/service-naming')
+const spanEndingHook = require('../../dd-trace/src/opentelemetry/span-ending-hook')
+const { RESOURCE_NAME } = require('../../../ext/tags')
 const { channel, addHook } = require('./helpers/instrument')
 
 const startChannel = channel('apm:next:request:start')
@@ -21,6 +24,27 @@ const NEXT_REQUEST_META = Symbol.for('NextInternalRequestMeta')
 const META_IS_MIDDLEWARE = 'middlewareInvoke'
 const encounteredMiddleware = new WeakSet()
 
+// `next.span_type` value Next.js sets on its own OTel root request span; the whole detection surface.
+const NEXT_BASE_SERVER_HANDLE_REQUEST = 'BaseServer.handleRequest'
+
+// In OTel-bridge mode (`plugins: false` + `new tracer.TracerProvider().register()`) Next emits its
+// own OTel spans and renames the root request span to `${method} ${route}` at finish, which the
+// bridge routes into the DD operation name and leaves the resource as the bare method — the reverse
+// of Datadog's contract. Correct it via the bridge's pre-finish hook. See span-ending-hook.js.
+spanEndingHook.hook = (ddSpan) => {
+  const tags = ddSpan.context().getTags()
+  if (tags['next.span_type'] !== NEXT_BASE_SERVER_HANDLE_REQUEST) return
+
+  const method = tags['http.method']
+  const route = tags['next.route'] ?? tags['http.route']
+  // Next already wrote the RSC-aware `${method} ${route}` into `next.span_name`; prefer it so we
+  // mirror Next's own naming, and only construct the resource when it is absent.
+  const resource = tags['next.span_name'] ?? (route ? `${method} ${route}` : method)
+
+  ddSpan.setOperationName(nomenclature.opName('web', 'server', 'next'))
+  ddSpan.setTag(RESOURCE_NAME, resource)
+}
+
 function wrapHandleRequest (handleRequest) {
   return function (req, res, pathname, query) {
     return instrument(req, res, () => handleRequest.apply(this, arguments))

package/packages/datadog-instrumentations/src/nyc.js

@@ -84,8 +84,6 @@ addHook({
             onDone: resolve,
           })
         })
-      }).catch(() => {
-        // Ignore errors - report generation failed
       })
     }