dd-trace 5.101.0 → 5.102.0

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

@@ -26,13 +26,13 @@ const {
   recordAttemptToFixExecution,
   logAttemptToFixTestExecution,
   logTestOptimizationSummary,
+  getEfdRetryCount,
 } = require('../../dd-trace/src/plugins/util/test')
 const {
   SEED_SUFFIX_RE,
   getFormattedJestTestParameters,
   getJestTestName,
   getJestSuitesToRun,
-  getEfdRetryCount,
 } = require('../../datadog-plugin-jest/src/util')
 const { addHook, channel } = require('./helpers/instrument')
 
@@ -521,13 +521,13 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       const setNameToParams = (name, params) => { this.nameToParams[name] = [...params] }
 
       if (event.name === 'setup' && this.global.test) {
-        shimmer.wrap(this.global.test, 'each', each => function () {
-          const testParameters = getFormattedJestTestParameters(arguments)
-          const eachBind = each.apply(this, arguments)
-          return function () {
-            const [testName] = arguments
+        shimmer.wrap(this.global.test, 'each', each => function (...args) {
+          const testParameters = getFormattedJestTestParameters(args)
+          const eachBind = each.apply(this, args)
+          return function (...args) {
+            const [testName] = args
             setNameToParams(testName, testParameters)
-            return eachBind.apply(this, arguments)
+            return eachBind.apply(this, args)
           }
         })
       }
@@ -624,16 +624,16 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             } else {
               originalHookFns.set(hook, hookFn)
             }
-            const newHookFn = shimmer.wrapFunction(hookFn, hookFn => function () {
-              return testFnCh.runStores(ctx, () => hookFn.apply(this, arguments))
+            const newHookFn = shimmer.wrapFunction(hookFn, hookFn => function (...args) {
+              return testFnCh.runStores(ctx, () => hookFn.apply(this, args))
             })
             hook.fn = newHookFn
           }
           const originalFn = event.test.fn
           originalTestFns.set(event.test, originalFn)
 
-          const newFn = shimmer.wrapFunction(event.test.fn, testFn => function () {
-            return testFnCh.runStores(ctx, () => testFn.apply(this, arguments))
+          const newFn = shimmer.wrapFunction(event.test.fn, testFn => function (...args) {
+            return testFnCh.runStores(ctx, () => testFn.apply(this, args))
           })
 
           event.test.fn = newFn
@@ -648,8 +648,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         } else {
           originalHookFns.set(event.hook, hookFn)
         }
-        event.hook.fn = shimmer.wrapFunction(hookFn, hookFn => function () {
-          return testSuiteHookFnCh.runStores(ctx, () => hookFn.apply(this, arguments))
+        event.hook.fn = shimmer.wrapFunction(hookFn, hookFn => function (...args) {
+          return testSuiteHookFnCh.runStores(ctx, () => hookFn.apply(this, args))
         })
       }
 
@@ -1544,14 +1544,14 @@ function coverageReporterWrapper (coverageReporter) {
    * in which case we'll leave it.
    */
   // `_addUntestedFiles` is an async function
-  shimmer.wrap(CoverageReporter.prototype, '_addUntestedFiles', addUntestedFiles => function () {
+  shimmer.wrap(CoverageReporter.prototype, '_addUntestedFiles', addUntestedFiles => function (...args) {
     if (DD_TEST_TIA_KEEP_COV_CONFIG) {
-      return addUntestedFiles.apply(this, arguments)
+      return addUntestedFiles.apply(this, args)
     }
     if (isCodeCoverageEnabledBecauseOfUs) {
       return Promise.resolve()
     }
-    return addUntestedFiles.apply(this, arguments)
+    return addUntestedFiles.apply(this, args)
   })
 
   return coverageReporter
@@ -1594,8 +1594,8 @@ addHook({
   name: '@jest/test-sequencer',
   versions: ['>=28'],
 }, (sequencerPackage, frameworkVersion) => {
-  shimmer.wrap(sequencerPackage.default.prototype, 'shard', shard => function () {
-    const shardedTests = shard.apply(this, arguments)
+  shimmer.wrap(sequencerPackage.default.prototype, 'shard', shard => function (...args) {
+    const shardedTests = shard.apply(this, args)
 
     if (!shardedTests.length || !isSuitesSkippingEnabled || !skippableSuites.length) {
       return shardedTests
@@ -1642,10 +1642,10 @@ addHook({
 
 function jestAdapterWrapper (jestAdapter, jestVersion) {
   const adapter = jestAdapter.default ?? jestAdapter
-  const newAdapter = shimmer.wrapFunction(adapter, adapter => function () {
-    const environment = arguments[2]
+  const newAdapter = shimmer.wrapFunction(adapter, adapter => function (...args) {
+    const environment = args[2]
     if (!environment || !environment.testEnvironmentOptions) {
-      return adapter.apply(this, arguments)
+      return adapter.apply(this, args)
     }
     testSuiteStartCh.publish({
       testSuite: environment.testSuite,
@@ -1655,7 +1655,7 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
       frameworkVersion: jestVersion,
       testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
     })
-    return adapter.apply(this, arguments).then(suiteResults => {
+    return adapter.apply(this, args).then(suiteResults => {
       const { numFailingTests, skipped, failureMessage: errorMessage } = suiteResults
       let status = 'pass'
       if (skipped) {
@@ -1773,8 +1773,8 @@ function jestConfigAsyncWrapper (jestConfig) {
 }
 
 function jestConfigSyncWrapper (jestConfig) {
-  return shimmer.wrap(jestConfig, 'readConfigs', readConfigs => function () {
-    const readConfigsResult = readConfigs.apply(this, arguments)
+  return shimmer.wrap(jestConfig, 'readConfigs', readConfigs => function (...args) {
+    const readConfigsResult = readConfigs.apply(this, args)
     configureTestEnvironment(readConfigsResult)
     return readConfigsResult
   })
@@ -1983,10 +1983,10 @@ addHook({
 })
 
 function onMessageWrapper (onMessage) {
-  return function () {
-    const response = arguments[0]
+  return function (...args) {
+    const response = args[0]
     if (!Array.isArray(response)) {
-      return onMessage.apply(this, arguments)
+      return onMessage.apply(this, args)
     }
 
     const [code, data] = response
@@ -2013,7 +2013,7 @@ function onMessageWrapper (onMessage) {
       }
       return
     }
-    return onMessage.apply(this, arguments)
+    return onMessage.apply(this, args)
   }
 }
 
@@ -2077,8 +2077,8 @@ function wrapWorker (worker) {
 }
 
 function enqueueWrapper (enqueue) {
-  return function () {
-    shimmer.wrap(arguments[0], 'onStart', onStart => function (worker) {
+  return function (...args) {
+    shimmer.wrap(args[0], 'onStart', onStart => function (worker) {
       if (worker) {
         const currentChannel = worker._child || worker._worker
         const previousChannel = wrappedWorkerChannels.get(worker)
@@ -2095,7 +2095,7 @@ function enqueueWrapper (enqueue) {
       }
       return onStart.apply(this, arguments)
     })
-    return enqueue.apply(this, arguments)
+    return enqueue.apply(this, args)
   }
 }
 

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

@@ -34,16 +34,16 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
     }
   }
 
-  shimmer.wrap(Kafka.prototype, 'producer', createProducer => function () {
-    const producer = createProducer.apply(this, arguments)
+  shimmer.wrap(Kafka.prototype, 'producer', createProducer => function (...args) {
+    const producer = createProducer.apply(this, args)
     const send = producer.send
     const bootstrapServers = this._brokers
 
     const kafkaClusterIdPromise = getKafkaClusterId(this)
 
-    producer.send = function () {
+    producer.send = function (...args) {
       const wrappedSend = (clusterId) => {
-        const { topic, messages = [] } = arguments[0]
+        const { topic, messages = [] } = args[0]
 
         const ctx = {
           bootstrapServers,
@@ -61,7 +61,7 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
 
         return producerStartCh.runStores(ctx, () => {
           try {
-            const result = send.apply(this, arguments)
+            const result = send.apply(this, args)
             result.then(
               (res) => {
                 ctx.result = res
@@ -110,9 +110,9 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
     return producer
   })
 
-  shimmer.wrap(Kafka.prototype, 'consumer', createConsumer => function () {
+  shimmer.wrap(Kafka.prototype, 'consumer', createConsumer => function (...args) {
     if (!consumerStartCh.hasSubscribers) {
-      return createConsumer.apply(this, arguments)
+      return createConsumer.apply(this, args)
     }
 
     const kafkaClusterIdPromise = getKafkaClusterId(this)
@@ -129,7 +129,7 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
       return { topic, partition, messages, groupId, clusterId }
     }
 
-    const consumer = createConsumer.apply(this, arguments)
+    const consumer = createConsumer.apply(this, args)
 
     consumer.on(consumer.events.COMMIT_OFFSETS, (event) => {
       const { payload: { groupId: commitGroupId, topics } } = event
@@ -149,7 +149,7 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
     })
 
     const run = consumer.run
-    const groupId = arguments[0].groupId
+    const groupId = args[0].groupId
 
     consumer.run = function ({ eachMessage, eachBatch, ...runArgs }) {
       const wrapConsume = (clusterId) => {

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

@@ -20,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 })

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

@@ -326,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
@@ -369,17 +370,17 @@ addHook({
 }, (Mocha, frameworkVersion) => {
   warnDeprecatedMochaVersion(frameworkVersion)
 
-  shimmer.wrap(Mocha.prototype, 'run', run => function () {
+  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) => {
@@ -426,11 +427,11 @@ addHook({
   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
@@ -444,7 +445,7 @@ addHook({
       mocha.options.delay = true
     }
 
-    return runMocha.apply(this, arguments)
+    return runMocha.apply(this, args)
   })
   return run
 })
@@ -462,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)
@@ -552,7 +553,7 @@ addHook({
       }
     })
 
-    return run.apply(this, arguments)
+    return run.apply(this, args)
   })
 
   return Runner
@@ -722,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 = {