dd-trace 5.22.0 → 5.23.0

package/LICENSE-3rdparty.csv

@@ -14,6 +14,7 @@ require,import-in-the-middle,Apache license 2.0,Copyright 2021 Datadog Inc.
 require,int64-buffer,MIT,Copyright 2015-2016 Yusuke Kawasaki
 require,istanbul-lib-coverage,BSD-3-Clause,Copyright 2012-2015 Yahoo! Inc.
 require,jest-docblock,MIT,Copyright Meta Platforms, Inc. and affiliates.
+require,jsonpath-plus,MIT,Copyright (c) 2011-2019 Stefan Goessner, Subbu Allamaraju, Mike Brevoort, Robert Krahn, Brett Zamir, Richard Schneider
 require,koalas,MIT,Copyright 2013-2017 Brian Woodward
 require,limiter,MIT,Copyright 2011 John Hurliman
 require,lodash.sortby,MIT,Copyright JS Foundation and other contributors
@@ -26,6 +27,7 @@ require,pprof-format,MIT,Copyright 2022 Stephen Belanger
 require,protobufjs,BSD-3-Clause,Copyright 2016 Daniel Wirtz
 require,tlhunter-sorted-set,MIT,Copyright (c) 2023 Datadog Inc.
 require,retry,MIT,Copyright 2011 Tim Koschützki Felix Geisendörfer
+require,rfdc,MIT,Copyright 2019 David Mark Clements
 require,semver,ISC,Copyright Isaac Z. Schlueter and Contributors
 require,shell-quote,mit,Copyright (c) 2013 James Halliday
 dev,@types/node,MIT,Copyright Authors

package/index.d.ts

@@ -729,6 +729,26 @@ declare namespace tracer {
      * The selection and priority order of context propagation injection and extraction mechanisms.
      */
     propagationStyle?: string[] | PropagationStyle
+
+    /**
+     * Cloud payload report as tags
+     */
+    cloudPayloadTagging?: {
+      /**
+       *  Additional JSONPath queries to replace with `redacted` in request payloads
+       *  Undefined or invalid JSONPath queries disable the feature for requests.
+       */
+      request?: string,
+      /**
+       *  Additional JSONPath queries to replace with `redacted` in response payloads
+       *  Undefined or invalid JSONPath queries disable the feature for responses.
+       */
+      response?: string,
+      /**
+       *  Maximum depth of payload traversal for tags
+       */
+      maxDepth?: number
+    }
   }
 
   /**
@@ -1010,14 +1030,6 @@ declare namespace tracer {
        * @default code => code < 500
        */
       validateStatus?: (code: number) => boolean;
-
-      /**
-       * Enable injection of tracing headers into requests signed with AWS IAM headers.
-       * Disable this if you get AWS signature errors (HTTP 403).
-       *
-       * @default false
-       */
-      enablePropagationWithAmazonHeaders?: boolean;
     }
 
     /** @hidden */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.22.0",
+  "version": "5.23.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -13,12 +13,15 @@
     "type:doc": "cd docs && yarn && yarn build",
     "type:test": "cd docs && yarn && yarn test",
     "lint": "node scripts/check_licenses.js && eslint . && yarn audit --groups dependencies",
+    "lint-fix": "node scripts/check_licenses.js && eslint . --fix && yarn audit --groups dependencies",
     "services": "node ./scripts/install_plugin_modules && node packages/dd-trace/test/setup/services",
     "test": "SERVICES=* yarn services && mocha --expose-gc 'packages/dd-trace/test/setup/node.js' 'packages/*/test/**/*.spec.js'",
     "test:appsec": "mocha -r \"packages/dd-trace/test/setup/mocha.js\" --exclude \"packages/dd-trace/test/appsec/**/*.plugin.spec.js\" \"packages/dd-trace/test/appsec/**/*.spec.js\"",
     "test:appsec:ci": "nyc --no-clean --include \"packages/dd-trace/src/appsec/**/*.js\" --exclude \"packages/dd-trace/test/appsec/**/*.plugin.spec.js\" -- npm run test:appsec",
     "test:appsec:plugins": "mocha -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/dd-trace/test/appsec/**/*.@($(echo $PLUGINS)).plugin.spec.js\"",
     "test:appsec:plugins:ci": "yarn services && nyc --no-clean --include \"packages/dd-trace/src/appsec/**/*.js\" -- npm run test:appsec:plugins",
+    "test:debugger": "tap packages/dd-trace/test/debugger/**/*.spec.js",
+    "test:debugger:ci": "npm run test:debugger -- --coverage --nyc-arg=--include=\"packages/dd-trace/src/debugger/**/*.js\"",
     "test:trace:core": "tap packages/dd-trace/test/*.spec.js \"packages/dd-trace/test/{ci-visibility,datastreams,encode,exporters,opentelemetry,opentracing,plugins,service-naming,telemetry}/**/*.spec.js\"",
     "test:trace:core:ci": "npm run test:trace:core -- --coverage --nyc-arg=--include=\"packages/dd-trace/src/**/*.js\"",
     "test:instrumentations": "mocha -r 'packages/dd-trace/test/setup/mocha.js' 'packages/datadog-instrumentations/test/**/*.spec.js'",
@@ -36,6 +39,7 @@
     "test:integration:appsec": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/appsec/*.spec.js\"",
     "test:integration:cucumber": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/cucumber/*.spec.js\"",
     "test:integration:cypress": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/cypress/*.spec.js\"",
+    "test:integration:debugger": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/debugger/*.spec.js\"",
     "test:integration:jest": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/jest/*.spec.js\"",
     "test:integration:mocha": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/mocha/*.spec.js\"",
     "test:integration:playwright": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/playwright/*.spec.js\"",
@@ -83,10 +87,11 @@
     "crypto-randomuuid": "^1.0.0",
     "dc-polyfill": "^0.1.4",
     "ignore": "^5.2.4",
-    "import-in-the-middle": "^1.8.1",
+    "import-in-the-middle": "1.11.2",
     "int64-buffer": "^0.1.9",
     "istanbul-lib-coverage": "3.2.0",
     "jest-docblock": "^29.7.0",
+    "jsonpath-plus": "^9.0.0",
     "koalas": "^1.0.2",
     "limiter": "1.1.5",
     "lodash.sortby": "^4.7.0",
@@ -94,10 +99,11 @@
     "module-details-from-path": "^1.0.3",
     "msgpack-lite": "^0.1.26",
     "opentracing": ">=0.12.1",
-    "path-to-regexp": "^0.1.2",
+    "path-to-regexp": "^0.1.10",
     "pprof-format": "^2.1.0",
     "protobufjs": "^7.2.5",
     "retry": "^0.13.1",
+    "rfdc": "^1.3.1",
     "semver": "^7.5.4",
     "shell-quote": "^1.8.1",
     "tlhunter-sorted-set": "^0.1.0"

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

@@ -35,7 +35,8 @@ const {
   mergeCoverage,
   fromCoverageMapToCoverage,
   getTestSuitePath,
-  CUCUMBER_WORKER_TRACE_PAYLOAD_CODE
+  CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
+  getIsFaultyEarlyFlakeDetection
 } = require('../../dd-trace/src/plugins/util/test')
 
 const isMarkedAsUnskippable = (pickle) => {
@@ -51,7 +52,9 @@ const patched = new WeakSet()
 const lastStatusByPickleId = new Map()
 const numRetriesByPickleId = new Map()
 const numAttemptToAsyncResource = new Map()
+const newTestsByTestFullname = new Map()
 
+let eventDataCollector = null
 let pickleByFile = {}
 const pickleResultByFile = {}
 
@@ -64,6 +67,8 @@ let isUnskippable = false
 let isSuitesSkippingEnabled = false
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
+let earlyFlakeDetectionFaultyThreshold = 0
+let isEarlyFlakeDetectionFaulty = false
 let isFlakyTestRetriesEnabled = false
 let numTestRetries = 0
 let knownTests = []
@@ -129,15 +134,35 @@ function getChannelPromise (channelToPublishTo) {
   })
 }
 
+function getShouldBeSkippedSuite (pickle, suitesToSkip) {
+  const testSuitePath = getTestSuitePath(pickle.uri, process.cwd())
+  const isUnskippable = isMarkedAsUnskippable(pickle)
+  const isSkipped = suitesToSkip.includes(testSuitePath)
+
+  return [isSkipped && !isUnskippable, testSuitePath]
+}
+
+// From cucumber@>=11
+function getFilteredPicklesNew (coordinator, suitesToSkip) {
+  return coordinator.sourcedPickles.reduce((acc, sourcedPickle) => {
+    const { pickle } = sourcedPickle
+    const [shouldBeSkipped, testSuitePath] = getShouldBeSkippedSuite(pickle, suitesToSkip)
+
+    if (shouldBeSkipped) {
+      acc.skippedSuites.add(testSuitePath)
+    } else {
+      acc.picklesToRun.push(sourcedPickle)
+    }
+    return acc
+  }, { skippedSuites: new Set(), picklesToRun: [] })
+}
+
 function getFilteredPickles (runtime, suitesToSkip) {
   return runtime.pickleIds.reduce((acc, pickleId) => {
-    const test = runtime.eventDataCollector.getPickle(pickleId)
-    const testSuitePath = getTestSuitePath(test.uri, process.cwd())
-
-    const isUnskippable = isMarkedAsUnskippable(test)
-    const isSkipped = suitesToSkip.includes(testSuitePath)
+    const pickle = runtime.eventDataCollector.getPickle(pickleId)
+    const [shouldBeSkipped, testSuitePath] = getShouldBeSkippedSuite(pickle, suitesToSkip)
 
-    if (isSkipped && !isUnskippable) {
+    if (shouldBeSkipped) {
       acc.skippedSuites.add(testSuitePath)
     } else {
       acc.picklesToRun.push(pickleId)
@@ -146,9 +171,21 @@ function getFilteredPickles (runtime, suitesToSkip) {
   }, { skippedSuites: new Set(), picklesToRun: [] })
 }
 
-function getPickleByFile (runtime) {
-  return runtime.pickleIds.reduce((acc, pickleId) => {
-    const test = runtime.eventDataCollector.getPickle(pickleId)
+// From cucumber@>=11
+function getPickleByFileNew (coordinator) {
+  return coordinator.sourcedPickles.reduce((acc, { pickle }) => {
+    if (acc[pickle.uri]) {
+      acc[pickle.uri].push(pickle)
+    } else {
+      acc[pickle.uri] = [pickle]
+    }
+    return acc
+  }, {})
+}
+
+function getPickleByFile (runtimeOrCoodinator) {
+  return runtimeOrCoodinator.pickleIds.reduce((acc, pickleId) => {
+    const test = runtimeOrCoodinator.eventDataCollector.getPickle(pickleId)
     if (acc[test.uri]) {
       acc[test.uri].push(test)
     } else {
@@ -294,17 +331,31 @@ function testCaseHook (TestCaseRunner) {
   return TestCaseRunner
 }
 
-function getWrappedStart (start, frameworkVersion, isParallel = false) {
+// Valid for old and new cucumber versions
+function getCucumberOptions (adapterOrCoordinator) {
+  if (adapterOrCoordinator.adapter) {
+    return adapterOrCoordinator.adapter.worker?.options || adapterOrCoordinator.adapter.options
+  }
+  return adapterOrCoordinator.options
+}
+
+function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordinator = false) {
   return async function () {
     if (!libraryConfigurationCh.hasSubscribers) {
       return start.apply(this, arguments)
     }
+    const options = getCucumberOptions(this)
+
+    if (!isParallel && this.adapter?.options) {
+      isParallel = options.parallel > 0
+    }
     let errorSkippableRequest
 
     const configurationResponse = await getChannelPromise(libraryConfigurationCh)
 
     isEarlyFlakeDetectionEnabled = configurationResponse.libraryConfig?.isEarlyFlakeDetectionEnabled
     earlyFlakeDetectionNumRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionNumRetries
+    earlyFlakeDetectionFaultyThreshold = configurationResponse.libraryConfig?.earlyFlakeDetectionFaultyThreshold
     isSuitesSkippingEnabled = configurationResponse.libraryConfig?.isSuitesSkippingEnabled
     isFlakyTestRetriesEnabled = configurationResponse.libraryConfig?.isFlakyTestRetriesEnabled
     numTestRetries = configurationResponse.libraryConfig?.flakyTestRetriesCount
@@ -325,28 +376,49 @@ function getWrappedStart (start, frameworkVersion, isParallel = false) {
       skippableSuites = skippableResponse.skippableSuites
 
       if (!errorSkippableRequest) {
-        const filteredPickles = getFilteredPickles(this, skippableSuites)
+        const filteredPickles = isCoordinator
+          ? getFilteredPicklesNew(this, skippableSuites)
+          : getFilteredPickles(this, skippableSuites)
+
         const { picklesToRun } = filteredPickles
-        isSuitesSkipped = picklesToRun.length !== this.pickleIds.length
+        const oldPickles = isCoordinator ? this.sourcedPickles : this.pickleIds
+
+        isSuitesSkipped = picklesToRun.length !== oldPickles.length
 
         log.debug(
-          () => `${picklesToRun.length} out of ${this.pickleIds.length} suites are going to run.`
+          () => `${picklesToRun.length} out of ${oldPickles.length} suites are going to run.`
         )
 
-        this.pickleIds = picklesToRun
+        if (isCoordinator) {
+          this.sourcedPickles = picklesToRun
+        } else {
+          this.pickleIds = picklesToRun
+        }
 
         skippedSuites = Array.from(filteredPickles.skippedSuites)
         itrCorrelationId = skippableResponse.itrCorrelationId
       }
     }
 
-    pickleByFile = getPickleByFile(this)
+    pickleByFile = isCoordinator ? getPickleByFileNew(this) : getPickleByFile(this)
+
+    if (isEarlyFlakeDetectionEnabled) {
+      const isFaulty = getIsFaultyEarlyFlakeDetection(
+        Object.keys(pickleByFile),
+        knownTests.cucumber || {},
+        earlyFlakeDetectionFaultyThreshold
+      )
+      if (isFaulty) {
+        isEarlyFlakeDetectionEnabled = false
+        isEarlyFlakeDetectionFaulty = true
+      }
+    }
 
     const processArgv = process.argv.slice(2).join(' ')
     const command = process.env.npm_lifecycle_script || `cucumber-js ${processArgv}`
 
-    if (isFlakyTestRetriesEnabled && !this.options.retry && numTestRetries > 0) {
-      this.options.retry = numTestRetries
+    if (isFlakyTestRetriesEnabled && !options.retry && numTestRetries > 0) {
+      options.retry = numTestRetries
     }
 
     sessionAsyncResource.runInAsyncScope(() => {
@@ -388,48 +460,65 @@ function getWrappedStart (start, frameworkVersion, isParallel = false) {
         hasUnskippableSuites: isUnskippable,
         hasForcedToRunSuites: isForcedToRun,
         isEarlyFlakeDetectionEnabled,
+        isEarlyFlakeDetectionFaulty,
         isParallel
       })
     })
+    eventDataCollector = null
     return success
   }
 }
 
-function getWrappedRunTest (runTestFunction) {
-  return async function (pickleId) {
-    const test = this.eventDataCollector.getPickle(pickleId)
+// Generates suite start and finish events in the main process.
+// Handles EFD in both the main process and the worker process.
+function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = false, isWorker = false) {
+  return async function () {
+    let pickle
+    if (isNewerCucumberVersion) {
+      pickle = arguments[0].pickle
+    } else {
+      pickle = this.eventDataCollector.getPickle(arguments[0])
+    }
 
-    const testFileAbsolutePath = test.uri
+    const testFileAbsolutePath = pickle.uri
     const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
 
-    if (!pickleResultByFile[testFileAbsolutePath]) { // first test in suite
-      isUnskippable = isMarkedAsUnskippable(test)
+    // If it's a worker, suite events are handled in `getWrappedParseWorkerMessage`
+    if (!isWorker && !pickleResultByFile[testFileAbsolutePath]) { // first test in suite
+      isUnskippable = isMarkedAsUnskippable(pickle)
       isForcedToRun = isUnskippable && skippableSuites.includes(testSuitePath)
 
-      testSuiteStartCh.publish({ testSuitePath, isUnskippable, isForcedToRun, itrCorrelationId })
+      testSuiteStartCh.publish({
+        testFileAbsolutePath,
+        isUnskippable,
+        isForcedToRun,
+        itrCorrelationId
+      })
     }
 
     let isNew = false
 
     if (isEarlyFlakeDetectionEnabled) {
-      isNew = isNewTest(testSuitePath, test.name)
+      isNew = isNewTest(testSuitePath, pickle.name)
       if (isNew) {
-        numRetriesByPickleId.set(pickleId, 0)
+        numRetriesByPickleId.set(pickle.id, 0)
       }
     }
-    const runTestCaseResult = await runTestFunction.apply(this, arguments)
+    // TODO: for >=11 we could use `runTestCaseResult` instead of accumulating results in `lastStatusByPickleId`
+    let runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
 
-    const testStatuses = lastStatusByPickleId.get(pickleId)
+    const testStatuses = lastStatusByPickleId.get(pickle.id)
     const lastTestStatus = testStatuses[testStatuses.length - 1]
     // If it's a new test and it hasn't been skipped, we run it again
     if (isEarlyFlakeDetectionEnabled && lastTestStatus !== 'skip' && isNew) {
       for (let retryIndex = 0; retryIndex < earlyFlakeDetectionNumRetries; retryIndex++) {
-        numRetriesByPickleId.set(pickleId, retryIndex + 1)
-        await runTestFunction.apply(this, arguments)
+        numRetriesByPickleId.set(pickle.id, retryIndex + 1)
+        runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
       }
     }
     let testStatus = lastTestStatus
-    if (isEarlyFlakeDetectionEnabled) {
+    let shouldBePassedByEFD = false
+    if (isNew && isEarlyFlakeDetectionEnabled) {
       /**
        * If Early Flake Detection (EFD) is enabled the logic is as follows:
        * - If all attempts for a test are failing, the test has failed and we will let the test process fail.
@@ -439,6 +528,8 @@ function getWrappedRunTest (runTestFunction) {
        */
       testStatus = getTestStatusFromRetries(testStatuses)
       if (testStatus === 'pass') {
+        // for cucumber@>=11, setting `this.success` does not work, so we have to change the returned value
+        shouldBePassedByEFD = true
         this.success = true
       }
     }
@@ -449,8 +540,9 @@ function getWrappedRunTest (runTestFunction) {
       pickleResultByFile[testFileAbsolutePath].push(testStatus)
     }
 
-    // last test in suite
-    if (pickleResultByFile[testFileAbsolutePath].length === pickleByFile[testFileAbsolutePath].length) {
+    // If it's a worker, suite events are handled in `getWrappedParseWorkerMessage`
+    if (!isWorker && pickleResultByFile[testFileAbsolutePath].length === pickleByFile[testFileAbsolutePath].length) {
+      // last test in suite
       const testSuiteStatus = getSuiteStatusFromTestStatuses(pickleResultByFile[testFileAbsolutePath])
       if (global.__coverage__) {
         const coverageFiles = getCoveredFilenamesFromCoverage(global.__coverage__)
@@ -469,11 +561,15 @@ function getWrappedRunTest (runTestFunction) {
       testSuiteFinishCh.publish({ status: testSuiteStatus, testSuitePath })
     }
 
+    if (isNewerCucumberVersion && isEarlyFlakeDetectionEnabled && isNew) {
+      return shouldBePassedByEFD
+    }
+
     return runTestCaseResult
   }
 }
 
-function getWrappedParseWorkerMessage (parseWorkerMessageFunction) {
+function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion) {
   return function (worker, message) {
     // If the message is an array, it's a dd-trace message, so we need to stop cucumber processing,
     // or cucumber will throw an error
@@ -488,29 +584,43 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction) {
       }
     }
 
-    const { jsonEnvelope } = message
-    if (!jsonEnvelope) {
+    let envelope
+
+    if (isNewVersion) {
+      envelope = message.envelope
+    } else {
+      envelope = message.jsonEnvelope
+    }
+
+    if (!envelope) {
       return parseWorkerMessageFunction.apply(this, arguments)
     }
-    let parsed = jsonEnvelope
+    let parsed = envelope
 
     if (typeof parsed === 'string') {
       try {
-        parsed = JSON.parse(jsonEnvelope)
+        parsed = JSON.parse(envelope)
       } catch (e) {
         // ignore errors and continue
         return parseWorkerMessageFunction.apply(this, arguments)
       }
     }
+    let pickle
+
     if (parsed.testCaseStarted) {
-      const { pickleId } = this.eventDataCollector.testCaseMap[parsed.testCaseStarted.testCaseId]
-      const pickle = this.eventDataCollector.getPickle(pickleId)
+      if (isNewVersion) {
+        pickle = this.inProgress[worker.id].pickle
+      } else {
+        const { pickleId } = this.eventDataCollector.testCaseMap[parsed.testCaseStarted.testCaseId]
+        pickle = this.eventDataCollector.getPickle(pickleId)
+      }
+      // THIS FAILS IN PARALLEL MODE
       const testFileAbsolutePath = pickle.uri
       // First test in suite
       if (!pickleResultByFile[testFileAbsolutePath]) {
         pickleResultByFile[testFileAbsolutePath] = []
         testSuiteStartCh.publish({
-          testSuitePath: getTestSuitePath(testFileAbsolutePath, process.cwd())
+          testFileAbsolutePath
         })
       }
     }
@@ -519,14 +629,47 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction) {
 
     // after calling `parseWorkerMessageFunction`, the test status can already be read
     if (parsed.testCaseFinished) {
-      const { pickle, worstTestStepResult } =
-        this.eventDataCollector.getTestCaseAttempt(parsed.testCaseFinished.testCaseStartedId)
+      let worstTestStepResult
+      if (isNewVersion && eventDataCollector) {
+        pickle = this.inProgress[worker.id].pickle
+        worstTestStepResult =
+          eventDataCollector.getTestCaseAttempt(parsed.testCaseFinished.testCaseStartedId).worstTestStepResult
+      } else {
+        const testCase = this.eventDataCollector.getTestCaseAttempt(parsed.testCaseFinished.testCaseStartedId)
+        worstTestStepResult = testCase.worstTestStepResult
+        pickle = testCase.pickle
+      }
 
       const { status } = getStatusFromResultLatest(worstTestStepResult)
+      let isNew = false
+
+      if (isEarlyFlakeDetectionEnabled) {
+        isNew = isNewTest(pickle.uri, pickle.name)
+      }
 
       const testFileAbsolutePath = pickle.uri
       const finished = pickleResultByFile[testFileAbsolutePath]
-      finished.push(status)
+
+      if (isNew) {
+        const testFullname = `${pickle.uri}:${pickle.name}`
+        let testStatuses = newTestsByTestFullname.get(testFullname)
+        if (!testStatuses) {
+          testStatuses = [status]
+          newTestsByTestFullname.set(testFullname, testStatuses)
+        } else {
+          testStatuses.push(status)
+        }
+        // We have finished all retries
+        if (testStatuses.length === earlyFlakeDetectionNumRetries + 1) {
+          const newTestFinalStatus = getTestStatusFromRetries(testStatuses)
+          // we only push to `finished` if the retries have finished
+          finished.push(newTestFinalStatus)
+        }
+      } else {
+        // TODO: can we get error message?
+        const finished = pickleResultByFile[testFileAbsolutePath]
+        finished.push(status)
+      }
 
       if (finished.length === pickleByFile[testFileAbsolutePath].length) {
         testSuiteFinishCh.publish({
@@ -556,13 +699,16 @@ addHook({
 
 // From 7.3.0 onwards, runPickle becomes runTestCase. Not executed in parallel mode.
 // `getWrappedStart` generates session start and finish events
-// `getWrappedRunTest` generates suite start and finish events
+// `getWrappedRunTestCase` generates suite start and finish events and handles EFD.
+// TODO (fix): there is a lib/runtime/index in >=11.0.0, but we don't instrument it because it's not useful for us
+// This causes a info log saying "Found incompatible integration version".
 addHook({
   name: '@cucumber/cucumber',
-  versions: ['>=7.3.0'],
+  versions: ['>=7.3.0 <11.0.0'],
   file: 'lib/runtime/index.js'
 }, (runtimePackage, frameworkVersion) => {
-  shimmer.wrap(runtimePackage.default.prototype, 'runTestCase', runTestCase => getWrappedRunTest(runTestCase))
+  shimmer.wrap(runtimePackage.default.prototype, 'runTestCase', runTestCase => getWrappedRunTestCase(runTestCase))
+
   shimmer.wrap(runtimePackage.default.prototype, 'start', start => getWrappedStart(start, frameworkVersion))
 
   return runtimePackage
@@ -570,13 +716,13 @@ addHook({
 
 // Not executed in parallel mode.
 // `getWrappedStart` generates session start and finish events
-// `getWrappedRunTest` generates suite start and finish events
+// `getWrappedRunTestCase` generates suite start and finish events and handles EFD.
 addHook({
   name: '@cucumber/cucumber',
   versions: ['>=7.0.0 <7.3.0'],
   file: 'lib/runtime/index.js'
 }, (runtimePackage, frameworkVersion) => {
-  shimmer.wrap(runtimePackage.default.prototype, 'runPickle', runPickle => getWrappedRunTest(runPickle))
+  shimmer.wrap(runtimePackage.default.prototype, 'runPickle', runPickle => getWrappedRunTestCase(runPickle))
   shimmer.wrap(runtimePackage.default.prototype, 'start', start => getWrappedStart(start, frameworkVersion))
 
   return runtimePackage
@@ -584,11 +730,10 @@ addHook({
 
 // Only executed in parallel mode.
 // `getWrappedStart` generates session start and finish events
-// `getWrappedGiveWork` generates suite start events and sets pickleResultByFile (used by suite finish events)
-// `getWrappedParseWorkerMessage` generates suite finish events
+// `getWrappedParseWorkerMessage` generates suite start and finish events
 addHook({
   name: '@cucumber/cucumber',
-  versions: ['>=8.0.0'],
+  versions: ['>=8.0.0 <11.0.0'],
   file: 'lib/runtime/parallel/coordinator.js'
 }, (coordinatorPackage, frameworkVersion) => {
   shimmer.wrap(coordinatorPackage.default.prototype, 'start', start => getWrappedStart(start, frameworkVersion, true))
@@ -599,3 +744,95 @@ addHook({
   )
   return coordinatorPackage
 })
+
+// >=11.0.0 hooks
+// `getWrappedRunTestCase` does two things:
+// - generates suite start and finish events in the main process,
+// - handles EFD in both the main process and the worker process.
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['>=11.0.0'],
+  file: 'lib/runtime/worker.js'
+}, (workerPackage) => {
+  shimmer.wrap(
+    workerPackage.Worker.prototype,
+    'runTestCase',
+    runTestCase => getWrappedRunTestCase(runTestCase, true, !!process.env.CUCUMBER_WORKER_ID)
+  )
+  return workerPackage
+})
+
+// `getWrappedStart` generates session start and finish events
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['>=11.0.0'],
+  file: 'lib/runtime/coordinator.js'
+}, (coordinatorPackage, frameworkVersion) => {
+  shimmer.wrap(
+    coordinatorPackage.Coordinator.prototype,
+    'run',
+    run => getWrappedStart(run, frameworkVersion, false, true)
+  )
+  return coordinatorPackage
+})
+
+// Necessary because `eventDataCollector` is no longer available in the runtime instance
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['>=11.0.0'],
+  file: 'lib/formatter/helpers/event_data_collector.js'
+}, (eventDataCollectorPackage) => {
+  shimmer.wrap(eventDataCollectorPackage.default.prototype, 'parseEnvelope', parseEnvelope => function () {
+    eventDataCollector = this
+    return parseEnvelope.apply(this, arguments)
+  })
+  return eventDataCollectorPackage
+})
+
+// Only executed in parallel mode for >=11, in the main process.
+// `getWrappedParseWorkerMessage` generates suite start and finish events
+// In `startWorker` we pass early flake detection info to the worker.
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['>=11.0.0'],
+  file: 'lib/runtime/parallel/adapter.js'
+}, (adapterPackage) => {
+  shimmer.wrap(
+    adapterPackage.ChildProcessAdapter.prototype,
+    'parseWorkerMessage',
+    parseWorkerMessage => getWrappedParseWorkerMessage(parseWorkerMessage, true)
+  )
+  // EFD in parallel mode only supported in >=11.0.0
+  shimmer.wrap(adapterPackage.ChildProcessAdapter.prototype, 'startWorker', startWorker => function () {
+    if (isEarlyFlakeDetectionEnabled) {
+      this.options.worldParameters._ddKnownTests = knownTests
+      this.options.worldParameters._ddEarlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
+    }
+
+    return startWorker.apply(this, arguments)
+  })
+  return adapterPackage
+})
+
+// Hook executed in the worker process when in parallel mode.
+// In this hook we read the information passed in `worldParameters` and make it available for
+// `getWrappedRunTestCase`.
+addHook({
+  name: '@cucumber/cucumber',
+  versions: ['>=11.0.0'],
+  file: 'lib/runtime/parallel/worker.js'
+}, (workerPackage) => {
+  shimmer.wrap(
+    workerPackage.ChildProcessWorker.prototype,
+    'initialize',
+    initialize => async function () {
+      await initialize.apply(this, arguments)
+      isEarlyFlakeDetectionEnabled = !!this.options.worldParameters._ddKnownTests
+      if (isEarlyFlakeDetectionEnabled) {
+        knownTests = this.options.worldParameters._ddKnownTests
+        earlyFlakeDetectionNumRetries = this.options.worldParameters._ddEarlyFlakeDetectionNumRetries
+      }
+    }
+  )
+  return workerPackage
+})