dd-trace 5.100.0 → 5.102.0

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

@@ -32,41 +32,41 @@ addHook({
   versions: ['>=2'],
   file: 'lib/knex-builder/Knex.js',
 }, Knex => {
-  shimmer.wrap(Knex.Client.prototype, 'raw', raw => function () {
+  shimmer.wrap(Knex.Client.prototype, 'raw', raw => function (...args) {
     if (!startRawQueryCh.hasSubscribers) {
-      return raw.apply(this, arguments)
+      return raw.apply(this, args)
     }
 
-    const sql = arguments[0]
+    const sql = args[0]
 
     // Skip query done by Knex to get the value used for undefined
     if (sql === 'DEFAULT') {
-      return raw.apply(this, arguments)
+      return raw.apply(this, args)
     }
 
     const context = { sql, dialect: this.dialect }
     return startRawQueryCh.runStores(context, () => {
-      const rawResult = raw.apply(this, arguments)
-      shimmer.wrap(rawResult, 'then', originalThen => function () {
+      const rawResult = raw.apply(this, args)
+      shimmer.wrap(rawResult, 'then', originalThen => function (...args) {
         return rawQuerySubscribes.runStores(context, () => {
-          arguments[0] = wrapCallbackWithFinish(arguments[0], finish, context)
-          if (arguments[1]) arguments[1] = wrapCallbackWithFinish(arguments[1], finish, context)
+          args[0] = wrapCallbackWithFinish(args[0], finish, context)
+          if (args[1]) args[1] = wrapCallbackWithFinish(args[1], finish, context)
 
-          const originalThenResult = originalThen.apply(this, arguments)
+          const originalThenResult = originalThen.apply(this, args)
 
-          shimmer.wrap(originalThenResult, 'catch', originalCatch => function () {
-            arguments[0] = wrapCallbackWithFinish(arguments[0], finish, context)
-            return originalCatch.apply(this, arguments)
+          shimmer.wrap(originalThenResult, 'catch', originalCatch => function (...args) {
+            args[0] = wrapCallbackWithFinish(args[0], finish, context)
+            return originalCatch.apply(this, args)
           })
 
           return originalThenResult
         })
       })
 
-      shimmer.wrap(rawResult, 'asCallback', originalAsCallback => function () {
+      shimmer.wrap(rawResult, 'asCallback', originalAsCallback => function (...args) {
         return rawQuerySubscribes.runStores(context, () => {
-          arguments[0] = wrapCallbackWithFinish(arguments[0], finish, context)
-          return originalAsCallback.apply(this, arguments)
+          args[0] = wrapCallbackWithFinish(args[0], finish, context)
+          return originalAsCallback.apply(this, args)
         })
       })
 
@@ -80,7 +80,7 @@ addHook({
 function wrapCallbackWithFinish (callback, finish, context) {
   if (typeof callback !== 'function') return callback
 
-  return shimmer.wrapFunction(callback, callback => function () {
-    finish(context, () => callback.apply(this, arguments))
+  return shimmer.wrapFunction(callback, callback => function (...args) {
+    finish(context, () => callback.apply(this, args))
   })
 }

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

@@ -14,8 +14,8 @@ const routeChannel = channel('apm:koa:request:route')
 const originals = new WeakMap()
 
 function wrapCallback (callback) {
-  return function callbackWithTrace () {
-    const handleRequest = callback.apply(this, arguments)
+  return function callbackWithTrace (...args) {
+    const handleRequest = callback.apply(this, args)
 
     if (typeof handleRequest !== 'function') return handleRequest
 
@@ -28,14 +28,14 @@ function wrapCallback (callback) {
 }
 
 function wrapUse (use) {
-  return function useWithTrace () {
-    const result = use.apply(this, arguments)
+  return function useWithTrace (...args) {
+    const result = use.apply(this, args)
 
-    if (!Array.isArray(this.middleware)) return result
+    if (Array.isArray(this.middleware)) {
+      const fn = this.middleware.pop()
 
-    const fn = this.middleware.pop()
-
-    this.middleware.push(wrapMiddleware(fn))
+      this.middleware.push(wrapMiddleware(fn))
+    }
 
     return result
   }
@@ -54,8 +54,8 @@ function wrapRegister (register) {
 }
 
 function wrapRouterUse (use) {
-  return function useWithTrace () {
-    const router = use.apply(this, arguments)
+  return function useWithTrace (...args) {
+    const router = use.apply(this, args)
 
     for (const layer of router.stack) {
       wrapStack(layer)
@@ -144,10 +144,10 @@ function fulfill (ctx, error) {
 }
 
 function wrapNext (req, next) {
-  return shimmer.wrapFunction(next, next => function () {
+  return shimmer.wrapFunction(next, next => function (...args) {
     nextChannel.publish({ req })
 
-    return next.apply(this, arguments)
+    return next.apply(this, args)
   })
 }
 

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

@@ -71,12 +71,12 @@ addHook({ name: 'ldapjs', versions: ['>=2'] }, ldapjs => {
     return search.apply(this, arguments)
   })
 
-  shimmer.wrap(ldapjs.Client.prototype, '_send', _send => function () {
-    const callbackIndex = getCallbackArgIndex(arguments)
+  shimmer.wrap(ldapjs.Client.prototype, '_send', _send => function (...args) {
+    const callbackIndex = getCallbackArgIndex(args)
     if (callbackIndex > -1) {
-      const callback = arguments[callbackIndex]
+      const callback = args[callbackIndex]
       // eslint-disable-next-line n/handle-callback-err
-      arguments[callbackIndex] = shimmer.wrapFunction(callback, callback => function (err, corkedEmitter) {
+      args[callbackIndex] = shimmer.wrapFunction(callback, callback => function (err, corkedEmitter) {
         if (corkedEmitter !== null && typeof corkedEmitter === 'object' && typeof corkedEmitter.on === 'function') {
           wrapEmitter(corkedEmitter)
         }
@@ -84,7 +84,7 @@ addHook({ name: 'ldapjs', versions: ['>=2'] }, ldapjs => {
       })
     }
 
-    return _send.apply(this, arguments)
+    return _send.apply(this, args)
   })
 
   shimmer.wrap(ldapjs.Client.prototype, 'bind', bind => function (dn, password, controls, callback) {

package/packages/datadog-instrumentations/src/light-my-request.js

@@ -69,8 +69,8 @@ function wrapDispatchFunc (dispatchFunc) {
     // Also wrap end() as fallback
     const originalEnd = res.end
     if (originalEnd) {
-      res.end = function wrappedEnd () {
-        const result = originalEnd.apply(this, arguments)
+      res.end = function wrappedEnd (...args) {
+        const result = originalEnd.apply(this, args)
         // Trigger finish if events don't fire
         setImmediate(onFinish)
         return result

package/packages/datadog-instrumentations/src/limitd-client.js

@@ -4,10 +4,10 @@ const shimmer = require('../../datadog-shimmer')
 const { addHook, AsyncResource } = require('./helpers/instrument')
 
 function wrapRequest (original) {
-  return function () {
-    const id = arguments.length - 1
-    arguments[id] = AsyncResource.bind(arguments[id])
-    return original.apply(this, arguments)
+  return function (...args) {
+    const id = args.length - 1
+    args[id] = AsyncResource.bind(args[id])
+    return original.apply(this, args)
   }
 }
 

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

@@ -12,13 +12,13 @@ addHook({ name: 'lodash', versions: ['>=4'] }, lodash => {
     lodash,
     instrumentedLodashFn,
     lodashFn => {
-      return function () {
+      return function (...args) {
         if (!lodashOperationCh.hasSubscribers) {
-          return lodashFn.apply(this, arguments)
+          return lodashFn.apply(this, args)
         }
 
-        const result = lodashFn.apply(this, arguments)
-        const message = { operation: lodashFn.name, arguments, result }
+        const result = lodashFn.apply(this, args)
+        const message = { operation: lodashFn.name, arguments: args, result }
         lodashOperationCh.publish(message)
 
         return message.result

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

@@ -12,13 +12,13 @@ const errorCh = channel('apm:mariadb:query:error')
 const skipCh = channel('apm:mariadb:pool:skip')
 
 function wrapCommandStart (start, ctx) {
-  return shimmer.wrapFunction(start, start => function () {
-    if (!startCh.hasSubscribers) return start.apply(this, arguments)
+  return shimmer.wrapFunction(start, start => function (...args) {
+    if (!startCh.hasSubscribers) return start.apply(this, args)
 
     const { reject, resolve } = this
     shimmer.wrap(this, 'resolve', function wrapResolve () {
-      return function () {
-        return finishCh.runStores(ctx, resolve, this, ...arguments)
+      return function (...args) {
+        return finishCh.runStores(ctx, resolve, this, ...args)
       }
     })
 
@@ -32,7 +32,7 @@ function wrapCommandStart (start, ctx) {
       }
     })
 
-    return startCh.runStores(ctx, start, this, ...arguments)
+    return startCh.runStores(ctx, start, this, ...args)
   })
 }
 
@@ -128,25 +128,25 @@ function wrapPoolBase (PoolBase) {
 // so instead we just skip instrumentation completely to avoid memory leaks
 // and/or orphan spans.
 function wrapPoolMethod (createConnection) {
-  return function () {
-    return skipCh.runStores({}, createConnection, this, ...arguments)
+  return function (...args) {
+    return skipCh.runStores({}, createConnection, this, ...args)
   }
 }
 
 function wrapPoolGetConnectionMethod (getConnection) {
-  return function wrappedGetConnection () {
-    const cb = arguments[arguments.length - 1]
-    if (typeof cb !== 'function') return getConnection.apply(this, arguments)
+  return function wrappedGetConnection (...args) {
+    const cb = args[args.length - 1]
+    if (typeof cb !== 'function') return getConnection.apply(this, args)
 
     const ctx = {}
 
-    arguments[arguments.length - 1] = function () {
-      return connectionFinishCh.runStores(ctx, cb, this, ...arguments)
+    args[args.length - 1] = function (...args) {
+      return connectionFinishCh.runStores(ctx, cb, this, ...args)
     }
 
     connectionStartCh.publish(ctx)
 
-    return getConnection.apply(this, arguments)
+    return getConnection.apply(this, args)
   }
 }
 

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

@@ -18,8 +18,8 @@ addHook({ name: 'memcached', versions: ['>=2.2'] }, Memcached => {
 
     const client = this
 
-    const wrappedQueryCompiler = function () {
-      const query = queryCompiler.apply(this, arguments)
+    const wrappedQueryCompiler = function (...args) {
+      const query = queryCompiler.apply(this, args)
 
       const ctx = { client, server, query }
       startCh.runStores(ctx, () => {

package/packages/datadog-instrumentations/src/microgateway-core.js

@@ -14,8 +14,8 @@ const versions = ['>=2.1 <=3.0.0']
 const requestContexts = new WeakMap()
 
 function wrapConfigProxyFactory (configProxyFactory) {
-  return function () {
-    const configProxy = configProxyFactory.apply(this, arguments)
+  return function (...args) {
+    const configProxy = configProxyFactory.apply(this, args)
 
     return function (req, res, next) {
       const ctx = { req, res }

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

@@ -3,8 +3,11 @@
 const { addHook, channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 const { getCallSites } = require('../../../dd-trace/src/plugins/util/stacktrace')
+const { DD_MAJOR } = require('../../../../version')
 const { testToStartLine } = require('./utils')
 
+const MINIMUM_MOCHA_VERSION = DD_MAJOR >= 6 ? '>=8.0.0' : '>=5.2.0'
+
 const parameterizedTestCh = channel('ci:mocha:test:parameterize')
 const patched = new WeakSet()
 
@@ -17,9 +20,9 @@ addHook({
 
   patched.add(mochaEach)
 
-  return shimmer.wrapFunction(mochaEach, mochaEach => function () {
-    const [params] = arguments
-    const { it, ...rest } = mochaEach.apply(this, arguments)
+  return shimmer.wrapFunction(mochaEach, mochaEach => function (...args) {
+    const [params] = args
+    const { it, ...rest } = mochaEach.apply(this, args)
     return {
       it: function (title) {
         parameterizedTestCh.publish({ title, params })
@@ -33,7 +36,7 @@ addHook({
 // support for start line
 addHook({
   name: 'mocha',
-  versions: ['>=5.2.0'],
+  versions: [MINIMUM_MOCHA_VERSION],
   file: 'lib/suite.js',
 }, (Suite) => {
   shimmer.wrap(Suite.prototype, 'addTest', addTest => function (test) {

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

@@ -1,6 +1,8 @@
 'use strict'
 
 const { createCoverageMap } = require('../../../../vendor/dist/istanbul-lib-coverage')
+const satisfies = require('../../../../vendor/dist/semifies')
+const { DD_MAJOR } = require('../../../../version')
 const { addHook, channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 const { isMarkedAsUnskippable } = require('../../../datadog-plugin-jest/src/util')
@@ -41,7 +43,10 @@ const {
 
 require('./common')
 
+const MINIMUM_MOCHA_VERSION = DD_MAJOR >= 6 ? '>=8.0.0' : '>=5.2.0'
+
 const patched = new WeakSet()
+let hasWarnedDeprecatedMochaVersion = false
 
 const unskippableSuites = []
 let suitesToSkip = []
@@ -79,6 +84,20 @@ const itrSkippedSuitesCh = channel('ci:mocha:itr:skipped-suites')
 
 const getCodeCoverageCh = channel('ci:nyc:get-coverage')
 
+function warnDeprecatedMochaVersion (frameworkVersion) {
+  if (DD_MAJOR >= 6 || hasWarnedDeprecatedMochaVersion || !frameworkVersion ||
+      !satisfies(frameworkVersion, '<8.0.0')) {
+    return
+  }
+
+  hasWarnedDeprecatedMochaVersion = true
+  // eslint-disable-next-line no-console
+  console.warn(
+    'dd-trace support for Mocha<8.0.0 is deprecated and will be removed in dd-trace v6. ' +
+      'Please upgrade Mocha to >=8.0.0.'
+  )
+}
+
 // Tests from workers do not come with `isFailed` method
 function isTestFailed (test) {
   if (test.isFailed) {
@@ -307,6 +326,7 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
     }
     config.isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
     config.earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+    config.earlyFlakeDetectionSlowTestRetries = libraryConfig.earlyFlakeDetectionSlowTestRetries ?? {}
     config.earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
     config.isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
     config.isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
@@ -345,20 +365,22 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
 // It is called but skipped in parallel mode.
 addHook({
   name: 'mocha',
-  versions: ['>=5.2.0'],
+  versions: [MINIMUM_MOCHA_VERSION],
   file: 'lib/mocha.js',
 }, (Mocha, frameworkVersion) => {
-  shimmer.wrap(Mocha.prototype, 'run', run => function () {
+  warnDeprecatedMochaVersion(frameworkVersion)
+
+  shimmer.wrap(Mocha.prototype, 'run', run => function (...args) {
     // Workers do not need to request any data, just run the tests
     if (!testFinishCh.hasSubscribers || getEnvironmentVariable('MOCHA_WORKER_ID') || this.options.parallel) {
-      return run.apply(this, arguments)
+      return run.apply(this, args)
     }
 
     // `options.delay` does not work in parallel mode, so we can't delay the execution this way
     // This needs to be both here and in `runMocha` hook. Read the comment in `runMocha` hook for more info.
     this.options.delay = true
 
-    const runner = run.apply(this, arguments)
+    const runner = run.apply(this, args)
 
     // eslint-disable-next-line unicorn/no-array-for-each
     this.files.forEach((path) => {
@@ -401,15 +423,15 @@ addHook({
 
 addHook({
   name: 'mocha',
-  versions: ['>=5.2.0'],
+  versions: [MINIMUM_MOCHA_VERSION],
   file: 'lib/cli/run-helpers.js',
 }, (run) => {
   // `runMocha` is an async function
-  shimmer.wrap(run, 'runMocha', runMocha => function () {
+  shimmer.wrap(run, 'runMocha', runMocha => function (...args) {
     if (!testFinishCh.hasSubscribers) {
-      return runMocha.apply(this, arguments)
+      return runMocha.apply(this, args)
     }
-    const mocha = arguments[0]
+    const mocha = args[0]
 
     /**
      * This attaches `run` to the global context, which we'll call after
@@ -423,7 +445,7 @@ addHook({
       mocha.options.delay = true
     }
 
-    return runMocha.apply(this, arguments)
+    return runMocha.apply(this, args)
   })
   return run
 })
@@ -432,7 +454,7 @@ addHook({
 // This hook is used to generate session, module, suite and test events
 addHook({
   name: 'mocha',
-  versions: ['>=5.2.0'],
+  versions: [MINIMUM_MOCHA_VERSION],
   file: 'lib/runner.js',
 }, function (Runner, frameworkVersion) {
   if (patched.has(Runner)) return Runner
@@ -441,9 +463,9 @@ addHook({
 
   shimmer.wrap(Runner.prototype, 'runTests', runTests => getRunTestsWrapper(runTests, config))
 
-  shimmer.wrap(Runner.prototype, 'run', run => function () {
+  shimmer.wrap(Runner.prototype, 'run', run => function (...args) {
     if (!testFinishCh.hasSubscribers) {
-      return run.apply(this, arguments)
+      return run.apply(this, args)
     }
 
     const { suitesByTestFile, numSuitesByTestFile } = getSuitesByTestFile(this.suite)
@@ -531,7 +553,7 @@ addHook({
       }
     })
 
-    return run.apply(this, arguments)
+    return run.apply(this, args)
   })
 
   return Runner
@@ -541,7 +563,7 @@ addHook({
 // Used to set the correct async resource to the test.
 addHook({
   name: 'mocha',
-  versions: ['>=5.2.0'],
+  versions: [MINIMUM_MOCHA_VERSION],
   file: 'lib/runnable.js',
 }, (runnablePackage) => runnableWrapper(runnablePackage, config))
 
@@ -701,6 +723,7 @@ addHook({
       if (config.knownTests?.mocha) {
         const testSuiteKnownTests = config.knownTests.mocha[testPath] || []
         newWorkerArgs._ddEfdNumRetries = config.earlyFlakeDetectionNumRetries
+        newWorkerArgs._ddEfdSlowTestRetries = config.earlyFlakeDetectionSlowTestRetries
         newWorkerArgs._ddIsEfdEnabled = config.isEarlyFlakeDetectionEnabled
         newWorkerArgs._ddIsKnownTestsEnabled = true
         newWorkerArgs._ddKnownTests = {