dd-trace 5.101.0 → 5.103.0

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

@@ -9,23 +9,23 @@ const deserializeChannel = dc.channel('apm:protobufjs:deserialize-end')
 
 function wrapSerialization (messageClass) {
   if (messageClass?.encode) {
-    shimmer.wrap(messageClass, 'encode', original => function () {
+    shimmer.wrap(messageClass, 'encode', original => function (...args) {
       if (!serializeChannel.hasSubscribers) {
-        return original.apply(this, arguments)
+        return original.apply(this, args)
       }
       serializeChannel.publish({ messageClass: this })
-      return original.apply(this, arguments)
+      return original.apply(this, args)
     })
   }
 }
 
 function wrapDeserialization (messageClass) {
   if (messageClass?.decode) {
-    shimmer.wrap(messageClass, 'decode', original => function () {
+    shimmer.wrap(messageClass, 'decode', original => function (...args) {
       if (!deserializeChannel.hasSubscribers) {
-        return original.apply(this, arguments)
+        return original.apply(this, args)
       }
-      const result = original.apply(this, arguments)
+      const result = original.apply(this, args)
       deserializeChannel.publish({ messageClass: result })
       return result
     })
@@ -34,8 +34,8 @@ function wrapDeserialization (messageClass) {
 
 function wrapSetup (messageClass) {
   if (messageClass?.setup) {
-    shimmer.wrap(messageClass, 'setup', original => function () {
-      const result = original.apply(this, arguments)
+    shimmer.wrap(messageClass, 'setup', original => function (...args) {
+      const result = original.apply(this, args)
 
       wrapSerialization(messageClass)
       wrapDeserialization(messageClass)
@@ -74,8 +74,8 @@ function wrapReflection (protobuf) {
   ]
 
   for (const method of reflectionMethods) {
-    shimmer.wrap(method.target, method.name, original => function () {
-      const result = original.apply(this, arguments)
+    shimmer.wrap(method.target, method.name, original => function (...args) {
+      const result = original.apply(this, args)
       if (result.nested) {
         for (const type in result.nested) {
           wrapSetup(result.nested[type])
@@ -97,8 +97,8 @@ addHook({
   name: 'protobufjs',
   versions: ['>=6.8.0'],
 }, protobuf => {
-  shimmer.wrap(protobuf.Root.prototype, 'load', original => function () {
-    const result = original.apply(this, arguments)
+  shimmer.wrap(protobuf.Root.prototype, 'load', original => function (...args) {
+    const result = original.apply(this, args)
     if (isPromise(result)) {
       return result.then(root => {
         wrapProtobufClasses(root)
@@ -110,14 +110,14 @@ addHook({
     return result
   })
 
-  shimmer.wrap(protobuf.Root.prototype, 'loadSync', original => function () {
-    const root = original.apply(this, arguments)
+  shimmer.wrap(protobuf.Root.prototype, 'loadSync', original => function (...args) {
+    const root = original.apply(this, args)
     wrapProtobufClasses(root)
     return root
   })
 
-  shimmer.wrap(protobuf, 'Type', Original => function () {
-    const typeInstance = new Original(...arguments)
+  shimmer.wrap(protobuf, 'Type', Original => function (...args) {
+    const typeInstance = new Original(...args)
     wrapSetup(typeInstance)
     return typeInstance
   })

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

@@ -13,6 +13,7 @@ const errorCh = channel('apm:redis:command:error')
 let createClientUrl
 let createClientName
 const instanceInfo = new WeakMap()
+const connectionInfoCache = new WeakMap()
 
 function wrapAddCommand (addCommand) {
   return function (command) {
@@ -20,10 +21,7 @@ function wrapAddCommand (addCommand) {
       return addCommand.apply(this, arguments)
     }
 
-    const name = command[0]
-    const args = command.slice(1)
-
-    const ctx = getStartCtx(this, name, args)
+    const ctx = getStartCtx(this, command[0], command, 1)
     return startCh.runStores(ctx, () => {
       const res = addCommand.apply(this, arguments)
 
@@ -35,7 +33,7 @@ function wrapAddCommand (addCommand) {
 }
 
 function wrapCommandQueueClass (cls) {
-  const ret = class RedisCommandQueue extends cls {
+  return class RedisCommandQueue extends cls {
     constructor (...args) {
       super(...args)
       let url = { host: 'localhost', port: 6379 }
@@ -50,7 +48,6 @@ function wrapCommandQueueClass (cls) {
       instanceInfo.set(this, { connectionName: createClientName, url })
     }
   }
-  return ret
 }
 
 function wrapCreateClient (request) {
@@ -137,22 +134,33 @@ addHook({ name: 'redis', versions: ['>=0.12 <2.6'] }, redis => {
   return redis
 })
 
-function getStartCtx (client, command, args) {
-  const { url, connectionName } = instanceInfo.get(client) || {}
+function getStartCtx (client, command, args, argsStartIndex) {
+  let cached = connectionInfoCache.get(client)
+  if (cached === undefined) {
+    const info = instanceInfo.get(client)
+    cached = {
+      connectionOptions:
+        client.connection_options || client.connection_option || client.connectionOption || info?.url,
+      connectionName: info?.connectionName,
+    }
+    connectionInfoCache.set(client, cached)
+  }
 
   return {
     db: client.selected_db,
     command,
     args,
-    connectionOptions: client.connection_options || client.connection_option || client.connectionOption || url,
-    connectionName,
+    argsStartIndex,
+    connectionOptions: cached.connectionOptions,
+    connectionName: cached.connectionName,
   }
 }
 
 function wrapCallback (finishCh, errorCh, ctx, callback) {
-  return shimmer.wrapFunction(callback, callback => function (err) {
+  if (typeof callback !== 'function') return callback
+  return function (err) {
     return finish(finishCh, errorCh, ctx, err, callback, this, arguments)
-  })
+  }
 }
 
 function finish (finishCh, errorCh, ctx, error, callback, thisArg, args) {

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

@@ -72,11 +72,11 @@ function wrapFn (fn) {
 }
 
 function wrapNext (req, next) {
-  return shimmer.wrapFunction(next, next => function () {
+  return shimmer.wrapFunction(next, next => function (...args) {
     nextChannel.publish({ req })
     finishChannel.publish({ req })
 
-    next.apply(this, arguments)
+    next.apply(this, args)
   })
 }
 

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

@@ -45,17 +45,17 @@ function createWrapRouterMethod (name, compile) {
   function wrapLayerHandle (layer, original) {
     original._name = original._name || layer.name
 
-    return shimmer.wrapFunction(original, original => function () {
-      if (!enterChannel.hasSubscribers) return original.apply(this, arguments)
+    return shimmer.wrapFunction(original, original => function (...args) {
+      if (!enterChannel.hasSubscribers) return original.apply(this, args)
 
       const matchers = getLayerMatchers(layer)
-      const lastIndex = arguments.length - 1
+      const lastIndex = args.length - 1
       const name = original._name || original.name
-      const req = arguments[arguments.length > 3 ? 1 : 0]
-      const next = arguments[lastIndex]
+      const req = args[args.length > 3 ? 1 : 0]
+      const next = args[lastIndex]
 
       if (typeof next === 'function') {
-        arguments[lastIndex] = wrapNext(req, next)
+        args[lastIndex] = wrapNext(req, next)
       }
 
       let route
@@ -77,7 +77,7 @@ function createWrapRouterMethod (name, compile) {
       enterChannel.publish({ name, req, route, layer })
 
       try {
-        return original.apply(this, arguments)
+        return original.apply(this, args)
       } catch (error) {
         errorChannel.publish({ req, error })
         nextChannel.publish({ req })
@@ -251,8 +251,8 @@ addHook({ name: 'router', versions: ['>=2'] }, Router => {
   const wrapRouterMethod = createWrapRouterMethod('router', getCompileToRegexp())
 
   const WrappedRouter = shimmer.wrapFunction(Router, function (originalRouter) {
-    return function wrappedMethod () {
-      const router = originalRouter.apply(this, arguments)
+    return function wrappedMethod (...args) {
+      const router = originalRouter.apply(this, args)
 
       shimmer.wrap(router, 'handle', function wrapHandle (originalHandle) {
         return function wrappedHandle (req, res, next) {
@@ -310,8 +310,8 @@ addHook({
 })
 
 function wrapParam (original) {
-  return function wrappedProcessParams () {
-    arguments[1] = shimmer.wrapFunction(arguments[1], (originalFn) => {
+  return function wrappedProcessParams (...args) {
+    args[1] = shimmer.wrapFunction(args[1], (originalFn) => {
       return function wrappedFn (req, res) {
         if (routerParamStartCh.hasSubscribers && Object.keys(req.params).length && !visitedParams.has(req.params)) {
           visitedParams.add(req.params)
@@ -332,7 +332,7 @@ function wrapParam (original) {
       }
     })
 
-    return original.apply(this, arguments)
+    return original.apply(this, args)
   }
 }
 

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

@@ -8,8 +8,8 @@ const paymentIntentCreateFinishCh = channel('datadog:stripe:paymentIntent:create
 const constructEventFinishCh = channel('datadog:stripe:constructEvent:finish')
 
 function wrapSessionCreate (create) {
-  return function wrappedSessionCreate () {
-    const promise = create.apply(this, arguments)
+  return function wrappedSessionCreate (...args) {
+    const promise = create.apply(this, args)
 
     if (!checkoutSessionCreateFinishCh.hasSubscribers) return promise
 
@@ -21,8 +21,8 @@ function wrapSessionCreate (create) {
 }
 
 function wrapPaymentIntentCreate (create) {
-  return function wrappedPaymentIntentCreate () {
-    const promise = create.apply(this, arguments)
+  return function wrappedPaymentIntentCreate (...args) {
+    const promise = create.apply(this, args)
 
     if (!paymentIntentCreateFinishCh.hasSubscribers) return promise
 
@@ -34,8 +34,8 @@ function wrapPaymentIntentCreate (create) {
 }
 
 function wrapConstructEvent (constructEvent) {
-  return function wrappedConstructEvent () {
-    const result = constructEvent.apply(this, arguments)
+  return function wrappedConstructEvent (...args) {
+    const result = constructEvent.apply(this, args)
 
     // no need to check for hasSubscribers,
     // if it's false, the publish function will be noop
@@ -46,8 +46,8 @@ function wrapConstructEvent (constructEvent) {
 }
 
 function wrapConstructEventAsync (constructEventAsync) {
-  return function wrappedConstructEventAsync () {
-    const promise = constructEventAsync.apply(this, arguments)
+  return function wrappedConstructEventAsync (...args) {
+    const promise = constructEventAsync.apply(this, args)
 
     if (!constructEventFinishCh.hasSubscribers) return promise
 
@@ -77,8 +77,8 @@ function instrumentStripeInstance (stripe) {
 // returns nothing; without 'new' it delegates to 'new Stripe(...)' and returns
 // that result. We need to instrument whichever object actually got populated
 function wrapLegacyStripe (Stripe) {
-  return function wrappedStripe () {
-    const result = Stripe.apply(this, arguments)
+  return function wrappedStripe (...args) {
+    const result = Stripe.apply(this, args)
     const stripe = this instanceof Stripe ? this : result
     instrumentStripeInstance(stripe)
     return stripe
@@ -88,8 +88,8 @@ function wrapLegacyStripe (Stripe) {
 // stripe >=22: the constructor is a factory that always returns a fresh Stripe
 // instance regardless of 'new', so we just instrument and forward the result
 function wrapStripe (Stripe) {
-  return function wrappedStripe () {
-    const stripe = Stripe.apply(this, arguments)
+  return function wrappedStripe (...args) {
+    const stripe = Stripe.apply(this, args)
     instrumentStripeInstance(stripe)
     return stripe
   }

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

@@ -4,6 +4,7 @@
 const realSetTimeout = setTimeout
 
 const path = require('node:path')
+const { performance } = require('node:perf_hooks')
 
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
@@ -12,6 +13,8 @@ const {
   VITEST_WORKER_LOGS_PAYLOAD_CODE,
   DYNAMIC_NAME_RE,
   getTestSuitePath,
+  getEfdRetryCount,
+  getMaxEfdRetryCount,
   recordAttemptToFixExecution,
   collectTestOptimizationSummariesFromTraces,
   logAttemptToFixTestExecution,
@@ -61,6 +64,10 @@ const disabledTasks = new WeakSet()
 const quarantinedTasks = new WeakSet()
 const attemptToFixTasks = new WeakSet()
 const modifiedTasks = new WeakSet()
+const efdDeterminedRetries = new WeakMap()
+const efdSlowAbortedTasks = new WeakSet()
+const efdExecutionStartByTask = new WeakMap()
+const efdSkippedRetryResults = new WeakMap()
 const attemptToFixExecutions = new Map()
 const loggedAttemptToFixTests = new Set()
 let isRetryReasonEfd = false
@@ -71,6 +78,7 @@ let isFlakyTestRetriesEnabled = false
 let flakyTestRetriesCount = 0
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
+let earlyFlakeDetectionSlowTestRetries = {}
 let isEarlyFlakeDetectionFaulty = false
 let isKnownTestsEnabled = false
 let isTestManagementTestsEnabled = false
@@ -87,6 +95,13 @@ let vitestPool = null
 
 const BREAKPOINT_HIT_GRACE_PERIOD_MS = 400
 
+function getConfiguredEfdRetryCount (slowTestRetries, fallbackRetryCount) {
+  if (!slowTestRetries || !Object.keys(slowTestRetries).length) {
+    return fallbackRetryCount
+  }
+  return getMaxEfdRetryCount(slowTestRetries)
+}
+
 function getTestCommand () {
   return `vitest ${process.argv.slice(2).join(' ')}`
 }
@@ -110,6 +125,7 @@ function getProvidedContext () {
       _ddIsDiEnabled,
       _ddKnownTests: knownTests,
       _ddEarlyFlakeDetectionNumRetries: numRepeats,
+      _ddEarlyFlakeDetectionSlowTestRetries: slowTestRetries,
       _ddIsKnownTestsEnabled: isKnownTestsEnabled,
       _ddIsTestManagementTestsEnabled: isTestManagementTestsEnabled,
       _ddTestManagementAttemptToFixRetries: testManagementAttemptToFixRetries,
@@ -125,6 +141,7 @@ function getProvidedContext () {
       isEarlyFlakeDetectionEnabled: _ddIsEarlyFlakeDetectionEnabled,
       knownTests,
       numRepeats,
+      slowTestRetries: slowTestRetries ?? {},
       isKnownTestsEnabled,
       isTestManagementTestsEnabled,
       testManagementAttemptToFixRetries,
@@ -141,6 +158,7 @@ function getProvidedContext () {
       isEarlyFlakeDetectionEnabled: false,
       knownTests: {},
       numRepeats: 0,
+      slowTestRetries: {},
       isKnownTestsEnabled: false,
       isTestManagementTestsEnabled: false,
       testManagementAttemptToFixRetries: 0,
@@ -219,12 +237,8 @@ function getSessionStatus (state) {
 
 // From https://github.com/vitest-dev/vitest/blob/51c04e2f44d91322b334f8ccbcdb368facc3f8ec/packages/runner/src/run.ts#L243-L250
 function getVitestTestStatus (test, retryCount) {
-  if (test.result.state !== 'fail') {
-    if (!test.repeats) {
-      return 'pass'
-    } else if (test.repeats && (test.retry ?? 0) === retryCount) {
-      return 'pass'
-    }
+  if (test.result.state !== 'fail' && (!test.repeats || (test.retry ?? 0) === retryCount)) {
+    return 'pass'
   }
   return 'fail'
 }
@@ -291,8 +305,8 @@ function recordFinalAttemptToFixExecution (task, status, providedContext) {
  * @returns {Function}
  */
 function wrapTestScopedFn (task, fn) {
-  return shimmer.wrapFunction(fn, fn => function () {
-    return testFnCh.runStores(taskToCtx.get(task), () => fn.apply(this, arguments))
+  return shimmer.wrapFunction(fn, fn => function (...args) {
+    return testFnCh.runStores(taskToCtx.get(task), () => fn.apply(this, args))
   })
 }
 
@@ -331,6 +345,7 @@ function getSortWrapper (sort, frameworkVersion) {
         flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
         isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+        earlyFlakeDetectionSlowTestRetries = libraryConfig.earlyFlakeDetectionSlowTestRetries ?? {}
         isDiEnabled = libraryConfig.isDiEnabled
         isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
         isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
@@ -389,7 +404,9 @@ function getSortWrapper (sort, frameworkVersion) {
               workspaceProject._provided._ddIsKnownTestsEnabled = isKnownTestsEnabled
               workspaceProject._provided._ddKnownTests = knownTests
               workspaceProject._provided._ddIsEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
-              workspaceProject._provided._ddEarlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
+              workspaceProject._provided._ddEarlyFlakeDetectionNumRetries =
+                getConfiguredEfdRetryCount(earlyFlakeDetectionSlowTestRetries, earlyFlakeDetectionNumRetries)
+              workspaceProject._provided._ddEarlyFlakeDetectionSlowTestRetries = earlyFlakeDetectionSlowTestRetries
             } catch {
               log.warn('Could not send known tests to workers so Early Flake Detection will not work.')
             }
@@ -527,13 +544,13 @@ function getFinishWrapper (exitOrClose) {
 
 function getCliOrStartVitestWrapper (frameworkVersion) {
   return function (oldCliOrStartVitest) {
-    return function () {
+    return function (...args) {
       if (!testSessionStartCh.hasSubscribers || isSessionStarted) {
-        return oldCliOrStartVitest.apply(this, arguments)
+        return oldCliOrStartVitest.apply(this, args)
       }
       isSessionStarted = true
       testSessionStartCh.publish({ command: getTestCommand(), frameworkVersion })
-      return oldCliOrStartVitest.apply(this, arguments)
+      return oldCliOrStartVitest.apply(this, args)
     }
   }
 }
@@ -644,11 +661,11 @@ function getStartVitestWrapper (cliApiPackage, frameworkVersion) {
   const forksPoolWorker = getForksPoolWorkerExport(cliApiPackage)
   if (forksPoolWorker) {
     // function is async
-    shimmer.wrap(forksPoolWorker.value.prototype, 'start', start => function () {
+    shimmer.wrap(forksPoolWorker.value.prototype, 'start', start => function (...args) {
       vitestPool = 'child_process'
       this.env.DD_VITEST_WORKER = '1'
 
-      return start.apply(this, arguments)
+      return start.apply(this, args)
     })
     shimmer.wrap(forksPoolWorker.value.prototype, 'on', getWrappedOn)
   }
@@ -656,10 +673,10 @@ function getStartVitestWrapper (cliApiPackage, frameworkVersion) {
   const threadsPoolWorker = getThreadsPoolWorkerExport(cliApiPackage)
   if (threadsPoolWorker) {
     // function is async
-    shimmer.wrap(threadsPoolWorker.value.prototype, 'start', start => function () {
+    shimmer.wrap(threadsPoolWorker.value.prototype, 'start', start => function (...args) {
       vitestPool = 'worker_threads'
       this.env.DD_VITEST_WORKER = '1'
-      return start.apply(this, arguments)
+      return start.apply(this, args)
     })
     shimmer.wrap(threadsPoolWorker.value.prototype, 'on', getWrappedOn)
   }
@@ -721,7 +738,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
         onDone: (isImpacted) => {
           if (isImpacted) {
             if (isEarlyFlakeDetectionEnabled) {
-              isRetryReasonEfd = task.repeats !== numRepeats
+              isRetryReasonEfd = true
               task.repeats = numRepeats
             }
             modifiedTasks.add(task)
@@ -739,7 +756,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
         onDone: (isNew) => {
           if (isNew && !attemptToFixTasks.has(task)) {
             if (isEarlyFlakeDetectionEnabled && !modifiedTasks.has(task)) {
-              isRetryReasonEfd = task.repeats !== numRepeats
+              isRetryReasonEfd = true
               task.repeats = numRepeats
             }
             newTasks.add(task)
@@ -811,6 +828,7 @@ function wrapVitestTestRunner (VitestTestRunner) {
       isTestManagementTestsEnabled,
       testManagementTests,
       isFlakyTestRetriesEnabled,
+      slowTestRetries,
     } = getProvidedContext()
 
     if (isKnownTestsEnabled) {
@@ -832,6 +850,39 @@ function wrapVitestTestRunner (VitestTestRunner) {
     }
 
     const { retry: numAttempt, repeats: numRepetition } = retryInfo
+    const isEfdManagedTask = isEarlyFlakeDetectionEnabled && taskToStatuses.has(task) && !attemptToFixTasks.has(task)
+
+    if (isEfdManagedTask && numRepetition > 0 && !efdDeterminedRetries.has(task)) {
+      const previousExecutionStart = efdExecutionStartByTask.get(task)
+      const duration = previousExecutionStart === undefined
+        ? task.result?.duration ?? 0
+        : performance.now() - previousExecutionStart
+      const retryCount = getEfdRetryCount(duration, slowTestRetries)
+      efdDeterminedRetries.set(task, retryCount)
+      task.repeats = retryCount
+      if (retryCount === 0) {
+        efdSlowAbortedTasks.add(task)
+      }
+    }
+
+    const efdRetryCount = efdDeterminedRetries.get(task)
+    if (isEfdManagedTask && efdRetryCount !== undefined && numRepetition > efdRetryCount) {
+      if (task.result) {
+        efdSkippedRetryResults.set(task, {
+          ...task.result,
+          errors: task.result.errors?.slice(),
+        })
+      }
+      if (vitestSetFn) {
+        const noop = function () {}
+        noop.__ddTraceWrapped = true
+        vitestSetFn(task, noop)
+      }
+      return onBeforeTryTask.apply(this, arguments)
+    }
+    if (isEfdManagedTask) {
+      efdExecutionStartByTask.set(task, performance.now())
+    }
 
     // We finish the previous test here because we know it has failed already
     if (numAttempt > 0) {
@@ -963,8 +1014,8 @@ function wrapVitestTestRunner (VitestTestRunner) {
           for (let i = 0; i < hookArray.length; i++) {
             const currentFn = hookArray[i]
             const originalFn = originalHookFns.get(currentFn) || currentFn
-            const wrappedFn = shimmer.wrapFunction(originalFn, fn => function () {
-              const result = testFnCh.runStores(taskToCtx.get(task), () => fn.apply(this, arguments))
+            const wrappedFn = shimmer.wrapFunction(originalFn, fn => function (...args) {
+              const result = testFnCh.runStores(taskToCtx.get(task), () => fn.apply(this, args))
 
               if (hookType === 'beforeEach') {
                 return wrapBeforeEachCleanupResult(task, result)
@@ -985,23 +1036,50 @@ function wrapVitestTestRunner (VitestTestRunner) {
 
   // test finish (only passed tests)
   shimmer.wrap(VitestTestRunner.prototype, 'onAfterTryTask', onAfterTryTask =>
-    async function (task, { retry: retryCount }) {
+    async function (task, retryInfo) {
       if (!testPassCh.hasSubscribers && !testErrorCh.hasSubscribers && !testSkipCh.hasSubscribers) {
         return onAfterTryTask.apply(this, arguments)
       }
       const result = await onAfterTryTask.apply(this, arguments)
 
-      const { testManagementAttemptToFixRetries } = getProvidedContext()
+      const {
+        isEarlyFlakeDetectionEnabled,
+        testManagementAttemptToFixRetries,
+        slowTestRetries,
+      } = getProvidedContext()
 
-      const status = getVitestTestStatus(task, retryCount)
+      const status = getVitestTestStatus(task, retryInfo.retry)
       const ctx = taskToCtx.get(task)
 
       const { isDiEnabled } = getProvidedContext()
 
-      if (isDiEnabled && retryCount > 1) {
+      if (efdSkippedRetryResults.has(task)) {
+        task.result = efdSkippedRetryResults.get(task)
+        efdSkippedRetryResults.delete(task)
+        return result
+      }
+
+      if (isDiEnabled && retryInfo.retry > 1) {
         await waitForHitProbe()
       }
 
+      if (
+        isEarlyFlakeDetectionEnabled &&
+        (retryInfo.repeats ?? 0) === 0 &&
+        taskToStatuses.has(task) &&
+        !attemptToFixTasks.has(task) &&
+        !efdDeterminedRetries.has(task)
+      ) {
+        const executionStart = efdExecutionStartByTask.get(task)
+        const duration = executionStart === undefined ? task.result?.duration ?? 0 : performance.now() - executionStart
+        const retryCount = getEfdRetryCount(duration, slowTestRetries)
+        efdDeterminedRetries.set(task, retryCount)
+        task.repeats = retryCount
+        if (retryCount === 0) {
+          efdSlowAbortedTasks.add(task)
+        }
+      }
+
       let attemptToFixPassed = false
       let attemptToFixFailed = false
       if (attemptToFixTasks.has(task)) {
@@ -1234,6 +1312,7 @@ addHook({
             testPassCh.publish({
               task,
               finalStatus: isSkippedByTestManagement ? 'skip' : 'pass',
+              earlyFlakeAbortReason: efdSlowAbortedTasks.has(task) ? 'slow' : undefined,
               ...testCtx.currentStore,
             })
           }
@@ -1255,8 +1334,9 @@ addHook({
             providedContext.isEarlyFlakeDetectionEnabled && (newTasks.has(task) || modifiedTasks.has(task))
           if (isEfdRetry) {
             const statuses = taskToStatuses.get(task)
-            // statuses only includes repetitions (not the initial run), so we check against numRepeats (not +1)
-            if (statuses && statuses.length === providedContext.numRepeats &&
+            const efdRetryCount = efdDeterminedRetries.get(task) ?? providedContext.numRepeats
+            // statuses only includes repetitions (not the initial run), so we check against retry count (not +1)
+            if (efdRetryCount > 0 && statuses && statuses.length === efdRetryCount &&
               statuses.every(status => status === 'fail')) {
               hasFailedAllRetries = true
             }
@@ -1297,6 +1377,7 @@ addHook({
               hasFailedAllRetries,
               attemptToFixFailed,
               finalStatus,
+              earlyFlakeAbortReason: efdSlowAbortedTasks.has(task) ? 'slow' : undefined,
               ...testCtx.currentStore,
             })
           }

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

@@ -33,8 +33,8 @@ addHook({ name: 'winston', file: 'lib/winston/logger.js', versions: ['>=3'] }, L
     }
   })
 
-  shimmer.wrap(Logger.prototype, 'configure', configure => function () {
-    const configureResponse = configure.apply(this, arguments)
+  shimmer.wrap(Logger.prototype, 'configure', configure => function (...args) {
+    const configureResponse = configure.apply(this, args)
     // After the original `configure`, because it resets transports
     if (addTransport.hasSubscribers) {
       addTransport.publish(this)
@@ -55,8 +55,8 @@ addHook({ name: 'winston', file: 'lib/winston/logger.js', versions: ['1', '2'] }
 })
 
 function wrapMethod (method, logCh) {
-  return function methodWithTrace () {
-    const result = method.apply(this, arguments)
+  return function methodWithTrace (...args) {
+    const result = method.apply(this, args)
 
     if (logCh.hasSubscribers) {
       for (const name in this.transports) {

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

@@ -62,24 +62,24 @@ const setSocketCh = channel('tracing:ws:server:connect:setSocket')
 let kWebSocketSymbol
 
 function wrapHandleUpgrade (handleUpgrade) {
-  return function () {
-    const [req, socket, , cb] = arguments
+  return function (...args) {
+    const [req, socket, , cb] = args
     if (!serverCh.start.hasSubscribers || typeof cb !== 'function') {
-      return handleUpgrade.apply(this, arguments)
+      return handleUpgrade.apply(this, args)
     }
 
     const ctx = { req, socket }
 
-    arguments[3] = function () {
+    args[3] = function (...args) {
       return serverCh.asyncStart.runStores(ctx, () => {
         try {
-          return cb.apply(this, arguments)
+          return cb.apply(this, args)
         } finally {
           serverCh.asyncEnd.publish(ctx)
         }
-      }, this, ...arguments)
+      }, this, ...args)
     }
-    return serverCh.traceSync(handleUpgrade, ctx, this, ...arguments)
+    return serverCh.traceSync(handleUpgrade, ctx, this, ...args)
   }
 }