dd-trace 6.4.0 → 6.6.0

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

@@ -0,0 +1,74 @@
+'use strict'
+
+/**
+ * @template {unknown[]} T
+ * @param {(...args: T) => void} onDone
+ * @returns {(...args: T) => void}
+ */
+function getCompletion (onDone) {
+  let hasCompleted = false
+  return (...args) => {
+    if (hasCompleted) return
+
+    hasCompleted = true
+    onDone(...args)
+  }
+}
+
+/**
+ * @template {unknown[]} T
+ * @param {import('node:diagnostics_channel').Channel} channel
+ * @param {Record<string, unknown>} payload
+ * @param {(...args: T) => void} onDone
+ * @returns {void}
+ */
+function publishWithCompletion (channel, payload, onDone) {
+  const complete = getCompletion(onDone)
+  channel.publish({ ...payload, onDone: complete })
+  if (!channel.hasSubscribers) complete()
+}
+
+/**
+ * @template {unknown[]} T
+ * @param {import('node:diagnostics_channel').Channel} channel
+ * @param {Record<string, unknown> & { onDone?: (...args: T) => void }} payload
+ * @param {(...args: T) => void} onDone
+ * @returns {void}
+ */
+function runStoresWithCompletion (channel, payload, onDone) {
+  const complete = getCompletion(onDone)
+  payload.onDone = complete
+  channel.runStores(payload, () => {})
+  if (!channel.hasSubscribers) complete()
+}
+
+/**
+ * @template T
+ * @param {import('node:diagnostics_channel').Channel} channel
+ * @param {Record<string, unknown>} [payload]
+ * @returns {Promise<T>}
+ */
+function getChannelPromise (channel, payload = {}) {
+  return new Promise(resolve => {
+    publishWithCompletion(channel, payload, resolve)
+  })
+}
+
+/**
+ * @template T
+ * @param {import('node:diagnostics_channel').Channel} channel
+ * @param {Record<string, unknown>} [payload]
+ * @returns {Promise<T>}
+ */
+function getRunStoresPromise (channel, payload = {}) {
+  return new Promise(resolve => {
+    runStoresWithCompletion(channel, { ...payload }, resolve)
+  })
+}
+
+module.exports = {
+  getChannelPromise,
+  getRunStoresPromise,
+  publishWithCompletion,
+  runStoresWithCompletion,
+}

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/jest.js

@@ -46,6 +46,10 @@ const {
   addCoverageBackfillUntestedFiles,
   getCoverageBackfillFiles,
 } = require('./jest/coverage-backfill')
+const {
+  getChannelPromise,
+  publishWithCompletion,
+} = require('./helpers/channel')
 const { addHook, channel } = require('./helpers/instrument')
 
 const testSessionStartCh = channel('ci:jest:session:start')
@@ -1858,6 +1862,26 @@ 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
 
@@ -1951,6 +1975,9 @@ function shouldFinishBailTestSession (globalConfig, results) {
   return !!globalConfig?.bail && getNumBailFailures(results) >= globalConfig.bail
 }
 
+/**
+ * @param {Record<string, unknown> & { onDone?: () => void }} payload
+ */
 async function waitForTestSessionFinish (payload) {
   if (!testSessionFinishCh.hasSubscribers || hasFinishedTestSession) return
 
@@ -1958,8 +1985,9 @@ async function waitForTestSessionFinish (payload) {
 
   let timeoutId
 
+  let onDone
   const flushPromise = new Promise((resolve) => {
-    payload.onDone = () => {
+    onDone = () => {
       clearTimeout(timeoutId)
       resolve()
     }
@@ -1972,7 +2000,7 @@ async function waitForTestSessionFinish (payload) {
     timeoutId.unref?.()
   })
 
-  testSessionFinishCh.publish(payload)
+  publishWithCompletion(testSessionFinishCh, payload, onDone)
 
   const waitingResult = await Promise.race([flushPromise, timeoutPromise])
 
@@ -2137,12 +2165,6 @@ function getWrappedScheduleTests (scheduleTests, frameworkVersion) {
   }
 }
 
-function getChannelPromise (channelToPublishTo, payload = {}) {
-  return new Promise(resolve => {
-    channelToPublishTo.publish({ ...payload, onDone: resolve })
-  })
-}
-
 function searchSourceWrapper (searchSourcePackage, frameworkVersion) {
   const SearchSource = searchSourcePackage.default ?? searchSourcePackage
 
@@ -2211,11 +2233,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
@@ -2231,6 +2255,10 @@ function getCliWrapper (isNewJestVersion) {
         }
       } catch (err) {
         log.error('Jest library configuration error', err)
+      } finally {
+        if (shouldResetLibraryConfiguration) {
+          resetLibraryConfiguration()
+        }
       }
 
       const {
@@ -2491,9 +2519,7 @@ function getCliWrapper (isNewJestVersion) {
 
       if (codeCoverageReportCh.hasSubscribers) {
         const rootDir = result.globalConfig?.rootDir || process.cwd()
-        await new Promise((resolve) => {
-          codeCoverageReportCh.publish({ rootDir, onDone: resolve })
-        })
+        await getChannelPromise(codeCoverageReportCh, { rootDir })
       }
 
       logSessionSummary(ignoredFailuresSummary, getAttemptToFixExecutionsFromJestResults(result))
@@ -2511,6 +2537,10 @@ function shouldWaitForTestSuiteFinish (environment) {
   return isJestWorker && environment.globalConfig?.workerIdleMemoryLimit !== undefined
 }
 
+/**
+ * @param {Record<string, unknown>} payload
+ * @param {boolean} waitForFinish
+ */
 function publishTestSuiteFinish (payload, waitForFinish) {
   if (!testSuiteFinishCh.hasSubscribers) return
 
@@ -2519,12 +2549,9 @@ function publishTestSuiteFinish (payload, waitForFinish) {
     return
   }
 
-  return new Promise(resolve => {
-    testSuiteFinishCh.publish({
-      ...payload,
-      waitForFinish,
-      onDone: resolve,
-    })
+  return getChannelPromise(testSuiteFinishCh, {
+    ...payload,
+    waitForFinish,
   })
 }
 

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

@@ -3,6 +3,11 @@
 const { createCoverageMap } = require('../../../../vendor/dist/istanbul-lib-coverage')
 const satisfies = require('../../../../vendor/dist/semifies')
 const { DD_MAJOR } = require('../../../../version')
+const {
+  getRunStoresPromise,
+  publishWithCompletion,
+  runStoresWithCompletion,
+} = require('../helpers/channel')
 const { addHook, channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 const { isMarkedAsUnskippable } = require('../../../datadog-plugin-jest/src/util')
@@ -240,6 +245,41 @@ function resetSuiteSkippingRunState () {
   writeCoverageBackfillToCache({})
 }
 
+/**
+ * @param {((failures: number) => void) | undefined} callback
+ * @returns {{ onRunDone: (failures: number) => void, onFlushDone: () => void }}
+ */
+function getRunCompletionCallbacks (callback) {
+  let failures
+  let hasRunFinished = false
+  let hasFlushFinished = false
+  let hasCompleted = false
+  const onDone = callback || (() => {})
+
+  const completeIfReady = () => {
+    if (hasCompleted || !hasRunFinished || !hasFlushFinished) return
+
+    hasCompleted = true
+    onDone(failures)
+  }
+
+  return {
+    onRunDone: (runFailures) => {
+      if (hasRunFinished) return
+
+      failures = runFailures
+      hasRunFinished = true
+      completeIfReady()
+    },
+    onFlushDone: () => {
+      if (hasFlushFinished) return
+
+      hasFlushFinished = true
+      completeIfReady()
+    },
+  }
+}
+
 function getOnStartHandler (frameworkVersion) {
   return function () {
     const processArgv = process.argv.slice(2).join(' ')
@@ -251,7 +291,12 @@ function getOnStartHandler (frameworkVersion) {
   }
 }
 
-function getOnEndHandler (isParallel) {
+/**
+ * @param {boolean} isParallel
+ * @param {() => void} onDone
+ * @returns {() => void}
+ */
+function getOnEndHandler (isParallel, onDone) {
   return function () {
     let status = 'pass'
     let error
@@ -337,7 +382,7 @@ function getOnEndHandler (isParallel) {
       global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
     }
 
-    testSessionFinishCh.publish({
+    publishWithCompletion(testSessionFinishCh, {
       status,
       isSuitesSkipped,
       testCodeCoverageLinesTotal,
@@ -350,19 +395,13 @@ function getOnEndHandler (isParallel) {
       isEarlyFlakeDetectionFaulty: config.isEarlyFlakeDetectionFaulty,
       isTestManagementEnabled: config.isTestManagementTestsEnabled,
       isParallel,
-    })
+    }, onDone)
 
     logTestOptimizationSummary({ attemptToFixExecutions, newTestsWithDynamicNames })
     loggedAttemptToFixTests.clear()
   }
 }
 
-function getRunStoresPromise (channelToPublishTo, ctx) {
-  return new Promise(resolve => {
-    channelToPublishTo.runStores({ ...ctx, onDone: resolve }, () => {})
-  })
-}
-
 function applyKnownTestsResponse ({ err, knownTests }) {
   if (err) {
     config.knownTests = []
@@ -395,13 +434,14 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
   let skippableSuitesResponse
   resetSuiteSkippingRunState()
 
-  const onReceivedSkippableSuites = ({
-    err,
-    skippableSuites,
-    itrCorrelationId: responseItrCorrelationId,
-    skippableSuitesCoverage: responseSkippableSuitesCoverage,
-  }) => {
-    if (err) {
+  const onReceivedSkippableSuites = (response) => {
+    const {
+      err,
+      skippableSuites,
+      itrCorrelationId: responseItrCorrelationId,
+      skippableSuitesCoverage: responseSkippableSuitesCoverage,
+    } = response || {}
+    if (!response || err) {
       suitesToSkip = []
       skippableSuitesCoverage = {}
     } else {
@@ -443,12 +483,12 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
       return
     }
 
-    ctx.onDone = onReceivedSkippableSuites
-    skippableSuitesCh.runStores(ctx, () => {})
+    runStoresWithCompletion(skippableSuitesCh, ctx, onReceivedSkippableSuites)
   }
 
-  const onReceivedImpactedTests = ({ err, modifiedFiles: receivedModifiedFiles }) => {
-    if (err) {
+  const onReceivedImpactedTests = (response) => {
+    const { err, modifiedFiles: receivedModifiedFiles } = response || {}
+    if (!response || err) {
       config.modifiedFiles = []
       config.isImpactedTestsEnabled = false
     } else {
@@ -465,8 +505,7 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
 
   const continueAfterTestRequests = () => {
     if (config.isImpactedTestsEnabled) {
-      ctx.onDone = onReceivedImpactedTests
-      modifiedFilesCh.runStores(ctx, () => {})
+      runStoresWithCompletion(modifiedFilesCh, ctx, onReceivedImpactedTests)
     } else if (config.isSuitesSkippingEnabled) {
       requestSkippableSuites()
     } else {
@@ -476,8 +515,14 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
     }
   }
 
-  const onReceivedConfiguration = ({ err, isTestDynamicInstrumentationEnabled, libraryConfig, repositoryRoot }) => {
-    if (err || !skippableSuitesCh.hasSubscribers || !knownTestsCh.hasSubscribers) {
+  const onReceivedConfiguration = (response) => {
+    const {
+      err,
+      isTestDynamicInstrumentationEnabled,
+      libraryConfig,
+      repositoryRoot,
+    } = response || {}
+    if (!response || err || !skippableSuitesCh.hasSubscribers || !knownTestsCh.hasSubscribers) {
       return mochaGlobalRunCh.runStores(ctx, () => {
         onFinishRequest()
       })
@@ -526,9 +571,7 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
     })
   }
 
-  ctx.onDone = onReceivedConfiguration
-
-  libraryConfigurationCh.runStores(ctx, () => {})
+  runStoresWithCompletion(libraryConfigurationCh, ctx, onReceivedConfiguration)
 }
 
 // In this hook we delay the execution with options.delay to grab library configuration,
@@ -553,7 +596,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) {
@@ -642,6 +684,9 @@ addHook({
       return run.apply(this, args)
     }
 
+    const { onRunDone, onFlushDone } = getRunCompletionCallbacks(args[0])
+    args[0] = onRunDone
+
     const { suitesByTestFile, numSuitesByTestFile } = getSuitesByTestFile(this.suite)
     // Root-level tests (direct children of root, no describe wrapper) keyed by file.
     // Populated during the root 'suite' event so the normal finish path can include them
@@ -753,7 +798,7 @@ addHook({
       finishRootSuiteForFile(test.file)
     }
 
-    const onEnd = getOnEndHandler(false)
+    const onEnd = getOnEndHandler(false, onFlushDone)
 
     this.once('start', getOnStartHandler(frameworkVersion))
 
@@ -915,7 +960,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) {
@@ -1043,8 +1087,11 @@ addHook({
       return run.apply(this, arguments)
     }
 
+    const { onRunDone, onFlushDone } = getRunCompletionCallbacks(cb)
+    arguments[0] = onRunDone
+
     this.once('start', getOnStartHandler(frameworkVersion))
-    this.once('end', getOnEndHandler(true))
+    this.once('end', getOnEndHandler(true, onFlushDone))
 
     // Populate unskippable suites before config is fetched (matches serial mode at Mocha.prototype.run)
     for (const filePath of files) {
@@ -1084,7 +1131,7 @@ addHook({
         skippedSuites = skippedFiles
         skippedSuitesCoverage = getSkippedSuitesCoverageForRun()
         writeCoverageBackfillToCache(skippedSuitesCoverage, getCoverageRootDir())
-        run.apply(this, [cb, { files: filteredFiles }])
+        run.apply(this, [onRunDone, { files: filteredFiles }])
       } else {
         run.apply(this, arguments)
       }

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)