dd-trace 5.101.0 → 5.102.0

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

@@ -6,8 +6,8 @@ const { wrapThen } = require('./helpers/promise')
 
 function createGetNewLibraryCopyWrap (originalLib) {
   return function wrapGetNewLibraryCopy (getNewLibraryCopy) {
-    return function getNewLibraryCopyWithTrace () {
-      const libraryCopy = getNewLibraryCopy.apply(this, arguments)
+    return function getNewLibraryCopyWithTrace (...args) {
+      const libraryCopy = getNewLibraryCopy.apply(this, args)
       shimmer.wrap(libraryCopy.prototype, '_then', wrapThen)
       shimmer.wrap(libraryCopy, 'getNewLibraryCopy', createGetNewLibraryCopyWrap(originalLib))
       return libraryCopy

package/packages/datadog-instrumentations/src/body-parser.js

@@ -6,7 +6,7 @@ const { channel, addHook, AsyncResource } = require('./helpers/instrument')
 const bodyParserReadCh = channel('datadog:body-parser:read:finish')
 
 function publishRequestBodyAndNext (req, res, next) {
-  return shimmer.wrapFunction(next, next => function () {
+  return shimmer.wrapFunction(next, next => function (...args) {
     if (bodyParserReadCh.hasSubscribers && req) {
       const abortController = new AbortController()
       const body = req.body
@@ -16,7 +16,7 @@ function publishRequestBodyAndNext (req, res, next) {
       if (abortController.signal.aborted) return
     }
 
-    return next.apply(this, arguments)
+    return next.apply(this, args)
   })
 }
 

package/packages/datadog-instrumentations/src/cassandra-driver.js

@@ -100,13 +100,13 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'], patchDefault: false }
 })
 
 addHook({ name: 'cassandra-driver', versions: ['>=3.3'], file: 'lib/request-execution.js' }, RequestExecution => {
-  shimmer.wrap(RequestExecution.prototype, '_sendOnConnection', _sendOnConnection => function () {
+  shimmer.wrap(RequestExecution.prototype, '_sendOnConnection', _sendOnConnection => function (...args) {
     if (!startCh.hasSubscribers) {
-      return _sendOnConnection.apply(this, arguments)
+      return _sendOnConnection.apply(this, args)
     }
     startCtx = { hostname: this._connection.address, port: this._connection.port, ...startCtx }
     connectCh.publish(startCtx)
-    return _sendOnConnection.apply(this, arguments)
+    return _sendOnConnection.apply(this, args)
   })
   return RequestExecution
 })
@@ -122,9 +122,9 @@ addHook({ name: 'cassandra-driver', versions: ['3.3 - 4.3'], file: 'lib/request-
       return start.apply(this, arguments)
     }
 
-    arguments[0] = function () {
+    arguments[0] = function (...args) {
       startCtx = { hostname: execution._connection.address, port: execution._connection.port, ...startCtx }
-      return connectCh.runStores(startCtx, getHostCallback, this, ...arguments)
+      return connectCh.runStores(startCtx, getHostCallback, this, ...args)
     }
 
     return start.apply(this, arguments)
@@ -143,9 +143,9 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 3.2'], file: 'lib/request-ha
       return send.apply(this, arguments)
     }
 
-    arguments[2] = function () {
+    arguments[2] = function (...args) {
       startCtx = { hostname: handler.connection.address, port: handler.connection.port, ...startCtx }
-      return connectCh.runStores(startCtx, callback, this, ...arguments)
+      return connectCh.runStores(startCtx, callback, this, ...args)
     }
 
     return send.apply(this, arguments)

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

@@ -82,12 +82,12 @@ function createContextFromChildProcessInfo (childProcessInfo) {
 
 function wrapChildProcessSyncMethod (returnError, shell = false) {
   return function wrapMethod (childProcessMethod) {
-    return function () {
-      if (!childProcessChannel.start.hasSubscribers || arguments.length === 0) {
-        return childProcessMethod.apply(this, arguments)
+    return function (...args) {
+      if (!childProcessChannel.start.hasSubscribers || args.length === 0) {
+        return childProcessMethod.apply(this, args)
       }
 
-      const callArgs = [...arguments]
+      const callArgs = [...args]
       const childProcessInfo = normalizeArgs(callArgs, shell)
       const context = createContextFromChildProcessInfo(childProcessInfo)
       context.callArgs = callArgs
@@ -118,12 +118,12 @@ function wrapChildProcessSyncMethod (returnError, shell = false) {
 }
 
 function wrapChildProcessCustomPromisifyMethod (customPromisifyMethod, shell) {
-  return function () {
-    if (!childProcessChannel.start.hasSubscribers || arguments.length === 0) {
-      return customPromisifyMethod.apply(this, arguments)
+  return function (...args) {
+    if (!childProcessChannel.start.hasSubscribers || args.length === 0) {
+      return customPromisifyMethod.apply(this, args)
     }
 
-    const callArgs = [...arguments]
+    const callArgs = [...args]
     const childProcessInfo = normalizeArgs(callArgs, shell)
 
     const context = createContextFromChildProcessInfo(childProcessInfo)
@@ -170,12 +170,12 @@ function wrapChildProcessCustomPromisifyMethod (customPromisifyMethod, shell) {
 
 function wrapChildProcessAsyncMethod (ChildProcess, shell = false) {
   return function wrapMethod (childProcessMethod) {
-    function wrappedChildProcessMethod () {
-      if (!childProcessChannel.start.hasSubscribers || arguments.length === 0) {
-        return childProcessMethod.apply(this, arguments)
+    function wrappedChildProcessMethod (...args) {
+      if (!childProcessChannel.start.hasSubscribers || args.length === 0) {
+        return childProcessMethod.apply(this, args)
       }
 
-      const callArgs = [...arguments]
+      const callArgs = [...args]
       const childProcessInfo = normalizeArgs(callArgs, shell)
 
       const context = createContextFromChildProcessInfo(childProcessInfo)

package/packages/datadog-instrumentations/src/confluentinc-kafka-javascript.js

@@ -47,8 +47,8 @@ function instrumentBaseModule (module) {
   // Helper function to wrap producer classes
   function wrapProducerClass (ProducerClass, className) {
     return shimmer.wrap(module, className, function wrapProducer (Original) {
-      return function wrappedProducer () {
-        const producer = new Original(...arguments)
+      return function wrappedProducer (...args) {
+        const producer = new Original(...args)
 
         // Hook the produce method
         if (typeof producer?.produce === 'function') {
@@ -94,9 +94,9 @@ function instrumentBaseModule (module) {
   // Helper function to wrap consumer classes
   function wrapConsumerClass (ConsumerClass, className) {
     return shimmer.wrap(module, className, function wrapConsumer (Original) {
-      return function wrappedConsumer () {
-        const consumer = new Original(...arguments)
-        const groupId = this.groupId || (arguments[0]?.['group.id'])
+      return function wrappedConsumer (...args) {
+        const consumer = new Original(...args)
+        const groupId = this.groupId || (args[0]?.['group.id'])
 
         // Wrap the consume method
         if (typeof consumer?.consume === 'function') {
@@ -196,11 +196,11 @@ function instrumentKafkaJS (kafkaJS) {
         // Wrap the producer method if it exists
         if (typeof kafka?.producer === 'function') {
           shimmer.wrap(kafka, 'producer', function wrapProducerMethod (producerMethod) {
-            return function wrappedProducerMethod () {
-              const producer = producerMethod.apply(this, arguments)
+            return function wrappedProducerMethod (...args) {
+              const producer = producerMethod.apply(this, args)
 
-              if (!brokers && arguments?.[0]?.['bootstrap.servers']) {
-                kafka._ddBrokers = arguments[0]['bootstrap.servers']
+              if (!brokers && args?.[0]?.['bootstrap.servers']) {
+                kafka._ddBrokers = args[0]['bootstrap.servers']
               }
 
               // Wrap the send method of the producer

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

@@ -59,16 +59,16 @@ function wrapLayerHandle (layer) {
 
   const original = layer.handle
 
-  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 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)
     }
 
     const route = layer.route
@@ -76,7 +76,7 @@ function wrapLayerHandle (layer) {
     enterChannel.publish({ name, req, route })
 
     try {
-      return original.apply(this, arguments)
+      return original.apply(this, args)
     } catch (error) {
       errorChannel.publish({ req, error })
       nextChannel.publish({ req })

package/packages/datadog-instrumentations/src/cookie-parser.js

@@ -6,7 +6,7 @@ const { channel, addHook } = require('./helpers/instrument')
 const cookieParserReadCh = channel('datadog:cookie-parser:read:finish')
 
 function publishRequestCookieAndNext (req, res, next) {
-  return shimmer.wrapFunction(next, next => function cookieParserWrapper () {
+  return shimmer.wrapFunction(next, next => function cookieParserWrapper (...args) {
     if (cookieParserReadCh.hasSubscribers && req) {
       const abortController = new AbortController()
 
@@ -17,7 +17,7 @@ function publishRequestCookieAndNext (req, res, next) {
       if (abortController.signal.aborted) return
     }
 
-    return next.apply(this, arguments)
+    return next.apply(this, args)
   })
 }
 
@@ -25,8 +25,8 @@ addHook({
   name: 'cookie-parser',
   versions: ['>=1.0.0'],
 }, cookieParser => {
-  return shimmer.wrapFunction(cookieParser, cookieParser => function () {
-    const cookieMiddleware = cookieParser.apply(this, arguments)
+  return shimmer.wrapFunction(cookieParser, cookieParser => function (...args) {
+    const cookieMiddleware = cookieParser.apply(this, args)
 
     return shimmer.wrapFunction(cookieMiddleware, cookieMiddleware => function (req, res, next) {
       arguments[2] = publishRequestCookieAndNext(req, res, next)

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

@@ -6,8 +6,8 @@ const { channel, addHook } = require('./helpers/instrument')
 const cookieParseCh = channel('datadog:cookie:parse:finish')
 
 function wrapParse (originalParse) {
-  return function () {
-    const cookies = originalParse.apply(this, arguments)
+  return function (...args) {
+    const cookies = originalParse.apply(this, args)
     if (cookieParseCh.hasSubscribers && cookies) {
       cookieParseCh.publish({ cookies })
     }

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

@@ -77,25 +77,25 @@ function wrap (prefix, fn) {
   const finishCh = channel(prefix + ':finish')
   const errorCh = channel(prefix + ':error')
 
-  const wrapped = function () {
+  return function (...args) {
     if (!startCh.hasSubscribers) {
-      return fn.apply(this, arguments)
+      return fn.apply(this, args)
     }
 
-    const callbackIndex = findCallbackIndex(arguments, 1)
+    const callbackIndex = findCallbackIndex(args, 1)
 
-    if (callbackIndex < 0) return fn.apply(this, arguments)
+    if (callbackIndex < 0) return fn.apply(this, args)
 
     const ctx = { bucket: { name: this.name || this._name }, seedNodes: this._dd_hosts }
     return startCh.runStores(ctx, () => {
-      const cb = arguments[callbackIndex]
+      const cb = args[callbackIndex]
 
-      arguments[callbackIndex] = shimmer.wrapFunction(cb, (cb) => {
-        return wrapCallbackFinish(cb, this, arguments, errorCh, finishCh, ctx, prefix)
+      args[callbackIndex] = shimmer.wrapFunction(cb, (cb) => {
+        return wrapCallbackFinish(cb, this, args, errorCh, finishCh, ctx, prefix)
       })
 
       try {
-        return fn.apply(this, arguments)
+        return fn.apply(this, args)
       } catch (error) {
         ctx.error = error
         void error.stack // trigger getting the stack at the original throwing point
@@ -105,7 +105,6 @@ function wrap (prefix, fn) {
       }
     })
   }
-  return wrapped
 }
 
 // semver >=2 <3
@@ -174,12 +173,12 @@ function wrapCBandPromise (fn, name, startData, thisArg, args) {
 
 function wrapWithName (name) {
   return function (operation) {
-    return function () { // no arguments used by us
+    return function (...args) { // no arguments used by us
       return wrapCBandPromise(operation, name, {
         collection: { name: this._name || '_default' },
         bucket: { name: this._scope._bucket._name },
         seedNodes: this._dd_connStr,
-      }, this, arguments)
+      }, this, args)
     }
   }
 }
@@ -240,8 +239,6 @@ addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.12'] }, Buc
   wrapAllNames(['upsert', 'insert', 'replace', 'append', 'prepend'], name => {
     shimmer.wrap(Bucket.prototype, name, fn => wrap(`apm:couchbase:${name}`, fn))
   })
-
-  return Bucket
 })
 
 addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^2.6.12'] }, Cluster => {
@@ -251,42 +248,36 @@ addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^2.6.12'] }, Cl
 
   shimmer.wrap(Cluster.prototype, 'query', query => wrapQuery(query))
   shimmer.wrap(Cluster.prototype, 'openBucket', openBucket => {
-    return function () {
-      const bucket = openBucket.apply(this, arguments)
+    return function (...args) {
+      const bucket = openBucket.apply(this, args)
       const hosts = this.dsnObj.hosts
       bucket._dd_hosts = hosts.map(hostAndPort => hostAndPort.join(':')).join(',')
       return bucket
     }
   })
-  return Cluster
 })
 
 // semver >=3 <3.2.0
 
 addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^3.0.7', '^3.1.3'] }, Bucket => {
   shimmer.wrap(Bucket.prototype, 'collection', getCollection => {
-    return function () {
-      const collection = getCollection.apply(this, arguments)
+    return function (...args) {
+      const collection = getCollection.apply(this, args)
       const connStr = this._cluster._connStr
       collection._dd_connStr = connStr
       return collection
     }
   })
-
-  return Bucket
 })
 
 addHook({ name: 'couchbase', file: 'lib/collection.js', versions: ['^3.0.7', '^3.1.3'] }, Collection => {
   wrapAllNames(['upsert', 'insert', 'replace'], name => {
     shimmer.wrap(Collection.prototype, name, wrapWithName(name))
   })
-
-  return Collection
 })
 
 addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^3.0.7', '^3.1.3'] }, Cluster => {
   shimmer.wrap(Cluster.prototype, 'query', wrapV3Query)
-  return Cluster
 })
 
 // semver >=3.2.2
@@ -298,27 +289,22 @@ addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.2'] }
   wrapAllNames(['upsert', 'insert', 'replace'], name => {
     shimmer.wrap(Collection.prototype, name, wrapWithName(name))
   })
-
-  return collection
 })
 
 addHook({ name: 'couchbase', file: 'dist/bucket.js', versions: ['>=3.2.2'] }, bucket => {
   const Bucket = bucket.Bucket
   shimmer.wrap(Bucket.prototype, 'collection', getCollection => {
-    return function () {
-      const collection = getCollection.apply(this, arguments)
+    return function (...args) {
+      const collection = getCollection.apply(this, args)
       const connStr = this._cluster._connStr
       collection._dd_connStr = connStr
       return collection
     }
   })
-
-  return bucket
 })
 
 addHook({ name: 'couchbase', file: 'dist/cluster.js', versions: ['>=3.2.2'] }, (cluster) => {
   const Cluster = cluster.Cluster
 
   shimmer.wrap(Cluster.prototype, 'query', wrapV3Query)
-  return cluster
 })

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

@@ -47,12 +47,12 @@ addHook({ name: 'crypto' }, crypto => {
 
 function wrapCryptoMethod (channel) {
   function wrapMethod (cryptoMethod) {
-    return function () {
-      if (channel.hasSubscribers && arguments.length > 0) {
-        const algorithm = arguments[0]
+    return function (...args) {
+      if (channel.hasSubscribers && args.length > 0) {
+        const algorithm = args[0]
         channel.publish({ algorithm })
       }
-      return cryptoMethod.apply(this, arguments)
+      return cryptoMethod.apply(this, args)
     }
   }
   return wrapMethod

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const { performance } = require('node:perf_hooks')
+
 const { createCoverageMap } = require('../../../vendor/dist/istanbul-lib-coverage')
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
@@ -12,6 +14,7 @@ const {
   getTestSuitePath,
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
   getIsFaultyEarlyFlakeDetection,
+  getEfdRetryCount,
   recordAttemptToFixExecution,
   collectAttemptToFixExecutionsFromTraces,
   logAttemptToFixTestExecution,
@@ -62,6 +65,9 @@ const lastStatusByPickleId = new Map()
 /** For ATR: statuses keyed by stable scenario id (uri:name) so retries accumulate correctly */
 const atrStatusesByScenarioKey = new Map()
 const numRetriesByPickleId = new Map()
+const efdRetryCountByPickleId = new Map()
+const efdSlowAbortedPickleIds = new Set()
+const testCaseStartedTimesById = new Map()
 const numAttemptToCtx = new Map()
 const newTestsByTestFullname = new Map()
 const attemptToFixTestsByTestFullname = new Map()
@@ -82,6 +88,7 @@ let isUnskippable = false
 let isSuitesSkippingEnabled = false
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
+let earlyFlakeDetectionSlowTestRetries = {}
 let earlyFlakeDetectionFaultyThreshold = 0
 let isEarlyFlakeDetectionFaulty = false
 let isFlakyTestRetriesEnabled = false
@@ -290,9 +297,9 @@ function wrapRun (pl, isLatestVersion, version) {
 
   patched.add(pl)
 
-  shimmer.wrap(pl.prototype, 'run', run => function () {
+  shimmer.wrap(pl.prototype, 'run', run => function (...args) {
     if (!testFinishCh.hasSubscribers) {
-      return run.apply(this, arguments)
+      return run.apply(this, args)
     }
 
     let numAttempt = 0
@@ -360,9 +367,10 @@ function wrapRun (pl, isLatestVersion, version) {
       }
       this.eventBroadcaster.on('envelope', onEnvelope)
       let promise
+      const executionStart = performance.now()
 
       testFnCh.runStores(ctx, () => {
-        promise = run.apply(this, arguments)
+        promise = run.apply(this, args)
       })
       promise.finally(async () => {
         this.eventBroadcaster.removeListener('envelope', onEnvelope)
@@ -424,15 +432,31 @@ function wrapRun (pl, isLatestVersion, version) {
           isEfdRetry = numRetries > 0
         }
 
+        if (
+          isEarlyFlakeDetectionEnabled &&
+          status !== 'skip' &&
+          (isNew || isModified) &&
+          !isEfdRetry &&
+          !efdRetryCountByPickleId.has(this.pickle.id)
+        ) {
+          const retryCount = getEfdRetryCount(performance.now() - executionStart, earlyFlakeDetectionSlowTestRetries)
+          efdRetryCountByPickleId.set(this.pickle.id, retryCount)
+          if (retryCount === 0) {
+            efdSlowAbortedPickleIds.add(this.pickle.id)
+          }
+        }
+
+        const efdRetryCount = efdRetryCountByPickleId.get(this.pickle.id) ?? earlyFlakeDetectionNumRetries
+
         // Check if all EFD retries failed
         if (isEfdRetry && (isNew || isModified)) {
           const statuses = lastStatusByPickleId.get(this.pickle.id)
-          if (statuses.length === earlyFlakeDetectionNumRetries + 1) {
+          if (statuses.length === efdRetryCount + 1) {
             const { fail } = statuses.reduce((acc, status) => {
               acc[status]++
               return acc
             }, { pass: 0, fail: 0 })
-            if (fail === earlyFlakeDetectionNumRetries + 1) {
+            if (fail === efdRetryCount + 1) {
               hasFailedAllRetries = true
             }
           }
@@ -480,7 +504,7 @@ function wrapRun (pl, isLatestVersion, version) {
         const isLastAtrRetry = isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry && numTestRetries > 0
 
         const statuses = lastStatusByPickleId.get(this.pickle.id)
-        const isLastEfdRetry = isEfdRetry && statuses?.length === earlyFlakeDetectionNumRetries + 1
+        const isLastEfdRetry = isEfdRetry && statuses?.length === efdRetryCount + 1
         const isLastAttemptToFixRetry = isAttemptToFix && statuses?.length === testManagementAttemptToFixRetries + 1
 
         // Intermediate (non-last EFD or ATF retries) executions do not report a final status
@@ -514,6 +538,7 @@ function wrapRun (pl, isLatestVersion, version) {
           isDisabled,
           isQuarantined,
           isModified,
+          earlyFlakeAbortReason: efdSlowAbortedPickleIds.has(this.pickle.id) ? 'slow' : undefined,
           ...attemptCtx.currentStore,
           finalStatus,
         })
@@ -526,11 +551,11 @@ function wrapRun (pl, isLatestVersion, version) {
       })
     }
   })
-  shimmer.wrap(pl.prototype, 'runStep', runStep => function () {
+  shimmer.wrap(pl.prototype, 'runStep', runStep => function (...args) {
     if (!testFinishCh.hasSubscribers) {
-      return runStep.apply(this, arguments)
+      return runStep.apply(this, args)
     }
-    const testStep = arguments[0]
+    const testStep = args[0]
     let resource
 
     if (isLatestVersion) {
@@ -542,7 +567,7 @@ function wrapRun (pl, isLatestVersion, version) {
     const ctx = { resource }
     return testStepStartCh.runStores(ctx, () => {
       try {
-        const promise = runStep.apply(this, arguments)
+        const promise = runStep.apply(this, args)
 
         promise.then((result) => {
           const finalResult = satisfies(version, '>=12.0.0') ? result.result : result
@@ -603,6 +628,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
 
     isEarlyFlakeDetectionEnabled = configurationResponse.libraryConfig?.isEarlyFlakeDetectionEnabled
     earlyFlakeDetectionNumRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionNumRetries
+    earlyFlakeDetectionSlowTestRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionSlowTestRetries ?? {}
     earlyFlakeDetectionFaultyThreshold = configurationResponse.libraryConfig?.earlyFlakeDetectionFaultyThreshold
     isSuitesSkippingEnabled = configurationResponse.libraryConfig?.isSuitesSkippingEnabled
     isFlakyTestRetriesEnabled = configurationResponse.libraryConfig?.isFlakyTestRetriesEnabled
@@ -692,6 +718,10 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
 
     atrStatusesByScenarioKey.clear()
     attemptToFixTestsByTestFullname.clear()
+    efdRetryCountByPickleId.clear()
+    efdSlowAbortedPickleIds.clear()
+    testCaseStartedTimesById.clear()
+    newTestsByTestFullname.clear()
     sessionStartCh.publish({ command, frameworkVersion })
 
     if (!errorSkippableRequest && skippedSuites.length) {
@@ -816,7 +846,9 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       }
     }
     // TODO: for >=11 we could use `runTestCaseResult` instead of accumulating results in `lastStatusByPickleId`
+    const firstExecutionStart = performance.now()
     let runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
+    const firstExecutionDurationMs = performance.now() - firstExecutionStart
 
     // Restore dryRun so it doesn't affect subsequent tests in the same worker
     this.options.dryRun = originalDryRun
@@ -835,7 +867,15 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
 
     // If it's a new test and it hasn't been skipped, we run it again
     if (isEarlyFlakeDetectionEnabled && lastTestStatus !== 'skip' && (isNew || isModified)) {
-      for (let retryIndex = 0; retryIndex < earlyFlakeDetectionNumRetries; retryIndex++) {
+      let efdRetryCount = efdRetryCountByPickleId.get(pickle.id)
+      if (efdRetryCount === undefined) {
+        efdRetryCount = getEfdRetryCount(firstExecutionDurationMs, earlyFlakeDetectionSlowTestRetries)
+        efdRetryCountByPickleId.set(pickle.id, efdRetryCount)
+        if (efdRetryCount === 0) {
+          efdSlowAbortedPickleIds.add(pickle.id)
+        }
+      }
+      for (let retryIndex = 0; retryIndex < efdRetryCount; retryIndex++) {
         numRetriesByPickleId.set(pickle.id, retryIndex + 1)
         // eslint-disable-next-line no-await-in-loop
         runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
@@ -952,6 +992,9 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
     let pickle
 
     if (parsed.testCaseStarted) {
+      if (parsed.testCaseStarted.id) {
+        testCaseStartedTimesById.set(parsed.testCaseStarted.id, performance.now())
+      }
       if (isNewVersion) {
         pickle = this.inProgress[worker.id].pickle
       } else {
@@ -973,6 +1016,10 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
 
     // after calling `parseWorkerMessageFunction`, the test status can already be read
     if (parsed.testCaseFinished) {
+      const testCaseStartedId = parsed.testCaseFinished.testCaseStartedId
+      const testCaseStartedAt = testCaseStartedTimesById.get(testCaseStartedId)
+      testCaseStartedTimesById.delete(testCaseStartedId)
+
       let worstTestStepResult
       if (isNewVersion && eventDataCollector) {
         pickle = this.inProgress[worker.id].pickle
@@ -1003,8 +1050,19 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
           testStatuses = [status]
           newTestsByTestFullname.set(testFullname, testStatuses)
         }
+        let efdRetryCount = efdRetryCountByPickleId.get(pickle.id)
+        if (efdRetryCount === undefined) {
+          const firstExecutionDurationMs = testCaseStartedAt === undefined ? 0 : performance.now() - testCaseStartedAt
+          efdRetryCount = status === 'skip'
+            ? 0
+            : getEfdRetryCount(firstExecutionDurationMs, earlyFlakeDetectionSlowTestRetries)
+          efdRetryCountByPickleId.set(pickle.id, efdRetryCount)
+          if (efdRetryCount === 0 && status !== 'skip') {
+            efdSlowAbortedPickleIds.add(pickle.id)
+          }
+        }
         // We have finished all retries
-        if (testStatuses.length === earlyFlakeDetectionNumRetries + 1) {
+        if (testStatuses.length === efdRetryCount + 1) {
           const newTestFinalStatus = getTestStatusFromRetries(testStatuses)
           // we only push to `finished` if the retries have finished
           finished.push(newTestFinalStatus)
@@ -1143,9 +1201,9 @@ addHook({
   versions: ['>=11.0.0'],
   file: 'lib/formatter/helpers/event_data_collector.js',
 }, (eventDataCollectorPackage) => {
-  shimmer.wrap(eventDataCollectorPackage.default.prototype, 'parseEnvelope', parseEnvelope => function () {
+  shimmer.wrap(eventDataCollectorPackage.default.prototype, 'parseEnvelope', parseEnvelope => function (...args) {
     eventDataCollector = this
-    return parseEnvelope.apply(this, arguments)
+    return parseEnvelope.apply(this, args)
   })
   return eventDataCollectorPackage
 })
@@ -1164,18 +1222,20 @@ addHook({
     parseWorkerMessage => getWrappedParseWorkerMessage(parseWorkerMessage, true)
   )
   // EFD in parallel mode only supported in >=11.0.0
-  shimmer.wrap(adapterPackage.ChildProcessAdapter.prototype, 'startWorker', startWorker => function () {
+  shimmer.wrap(adapterPackage.ChildProcessAdapter.prototype, 'startWorker', startWorker => function (...args) {
     if (isKnownTestsEnabled && isValidKnownTests(knownTests)) {
       this.options.worldParameters._ddIsKnownTestsEnabled = true
       this.options.worldParameters._ddIsEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
       this.options.worldParameters._ddKnownTests = knownTests
       this.options.worldParameters._ddEarlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
+      this.options.worldParameters._ddEarlyFlakeDetectionSlowTestRetries = earlyFlakeDetectionSlowTestRetries
     } else {
       isEarlyFlakeDetectionEnabled = false
       isKnownTestsEnabled = false
       this.options.worldParameters._ddIsEarlyFlakeDetectionEnabled = false
       this.options.worldParameters._ddIsKnownTestsEnabled = false
       this.options.worldParameters._ddEarlyFlakeDetectionNumRetries = 0
+      this.options.worldParameters._ddEarlyFlakeDetectionSlowTestRetries = {}
     }
 
     if (isImpactedTestsEnabled) {
@@ -1192,7 +1252,7 @@ addHook({
       this.options.worldParameters._ddTestManagementAttemptToFixRetries = testManagementAttemptToFixRetries
     }
 
-    return startWorker.apply(this, arguments)
+    return startWorker.apply(this, args)
   })
   return adapterPackage
 })
@@ -1222,6 +1282,7 @@ addHook({
       isEarlyFlakeDetectionEnabled = !!this.options.worldParameters._ddIsEarlyFlakeDetectionEnabled
       if (isEarlyFlakeDetectionEnabled) {
         earlyFlakeDetectionNumRetries = this.options.worldParameters._ddEarlyFlakeDetectionNumRetries
+        earlyFlakeDetectionSlowTestRetries = this.options.worldParameters._ddEarlyFlakeDetectionSlowTestRetries ?? {}
       }
       isImpactedTestsEnabled = !!this.options.worldParameters._ddImpactedTestsEnabled
       if (isImpactedTestsEnabled) {