dd-trace 5.131.1 → 5.133.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.131.1",
+  "version": "5.133.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -109,7 +109,7 @@
     "test:integration:webdriverio": "mocha --timeout 60000 \"integration-tests/webdriverio/${SPEC:-*}.spec.js\"",
     "test:integration:webdriverio:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/webdriverio/${SPEC:-*}.spec.js\"",
     "test:integration:vitest": "mocha --timeout 60000 \"integration-tests/vitest/${SPEC:-vitest*}.spec.js\"",
-    "test:integration:vitest:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/vitest/${SPEC:-vitest*}.spec.js\"",
+    "test:integration:vitest:coverage": "node ./integration-tests/vitest/run-with-coverage.js --timeout 60000 \"integration-tests/vitest/${SPEC:-vitest*}.spec.js\"",
     "test:integration:testopt": "mocha --timeout 120000 \"integration-tests/ci-visibility/*.spec.js\"",
     "test:integration:testopt:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 120000 \"integration-tests/ci-visibility/*.spec.js\"",
     "test:integration:profiler": "mocha --timeout 180000 \"integration-tests/profiler/*.spec.js\"",
@@ -143,7 +143,7 @@
   "bugs": {
     "url": "https://github.com/DataDog/dd-trace-js/issues"
   },
-  "homepage": "https://github.com/DataDog/dd-trace-js#readme",
+  "homepage": "https://github.com/DataDog/dd-trace-js",
   "engines": {
     "node": ">=18"
   },
@@ -169,6 +169,8 @@
     "loader-hook.mjs",
     "openfeature.d.ts",
     "openfeature.js",
+    "openfeature/rules-based.js",
+    "openfeature/rules-based.d.ts",
     "packages/*/index.js",
     "packages/*/index.electron.js",
     "packages/*/lib/**/*",
@@ -193,7 +195,7 @@
     "@datadog/native-appsec": "11.0.3",
     "@datadog/native-iast-taint-tracking": "4.2.1",
     "@datadog/native-metrics": "4.0.0",
-    "@datadog/pprof": "5.19.0",
+    "@datadog/pprof": "5.20.0",
     "@datadog/wasm-js-rewriter": "5.0.4",
     "@opentelemetry/api": ">=1.0.0 <1.10.0",
     "@opentelemetry/api-logs": "<1.0.0",
@@ -202,11 +204,11 @@
   "devDependencies": {
     "@actions/core": "^3.0.1",
     "@actions/github": "^9.1.1",
-    "@babel/helpers": "^8.0.5",
+    "@babel/helpers": "^8.0.7",
     "@eslint/eslintrc": "^3.3.7",
     "@eslint/js": "^10.0.1",
     "@eslint/plugin-kit": "^0.7.3",
-    "@datadog/openfeature-node-server": "2.4.0",
+    "@datadog/openfeature-node-server": "2.5.0",
     "@msgpack/msgpack": "^3.1.3",
     "@openfeature/core": "^1.12.0",
     "@openfeature/server-sdk": "~1.23.0",
@@ -218,20 +220,20 @@
     "@yarnpkg/lockfile": "^1.1.0",
     "benchmark": "^2.1.4",
     "body-parser": "^2.3.0",
-    "bun": "1.4.2",
+    "bun": "1.4.3",
     "c8": "^12.0.0",
     "codeowners-audit": "^2.9.0",
-    "eslint": "^10.11.0",
+    "eslint": "^10.13.0",
     "eslint-plugin-cypress": "^7.0.2",
     "eslint-plugin-import-x": "^4.16.2",
-    "eslint-plugin-jsdoc": "^64.5.4",
+    "eslint-plugin-jsdoc": "^65.3.12",
     "eslint-plugin-mocha": "^12.0.2",
-    "eslint-plugin-n": "^18.4.0",
+    "eslint-plugin-n": "^18.5.0",
     "eslint-plugin-promise": "^7.3.0",
     "eslint-plugin-regexp": "^3.3.1",
     "eslint-plugin-sonarjs": "^4.2.2",
     "eslint-plugin-unicorn": "^74.0.0",
-    "express": "^5.1.0",
+    "express": "^5.3.0",
     "glob": "^10.4.5",
     "globals": "^17.13.0",
     "graphql": "*",

package/packages/datadog-core/src/storage.js

@@ -56,12 +56,28 @@ const isACFActive = (() => {
 if (!isACFActive) {
   const superGetStore = AsyncLocalStorage.prototype.getStore
   const superEnterWith = AsyncLocalStorage.prototype.enterWith
+  // @ts-expect-error Node calls this undocumented AsyncLocalStorage hook.
+  const superPropagate = AsyncLocalStorage.prototype._propagate
 
   // Without ACF, ALS writes the entered value onto the async resource. Keep the
   // real store off the resource by entering a small handle and mapping it to
   // the store through a WeakMap, then reversing the lookup on read.
   const stores = new WeakMap()
 
+  /**
+   * Node can omit the trigger resource while the inspector is paused. Guard
+   * the shared hook because every enabled AsyncLocalStorage receives the call.
+   *
+   * @param {object} resource
+   * @param {object | undefined} triggerResource
+   * @param {string} type
+   */
+  AsyncLocalStorage.prototype._propagate = function _propagate (resource, triggerResource, type) {
+    if (triggerResource) {
+      superPropagate.call(this, resource, triggerResource, type)
+    }
+  }
+
   /**
    * @param {Store<unknown>} [store]
    */

package/packages/datadog-esbuild/index.js

@@ -8,6 +8,7 @@ const { pathToFileURL, fileURLToPath } = require('node:url')
 const instrumentations = require('../datadog-instrumentations/src/helpers/instrumentations')
 const extractPackageAndModulePath = require('../datadog-instrumentations/src/helpers/extract-package-and-module-path')
 const hooks = require('../datadog-instrumentations/src/helpers/hooks')
+const { getValueFromEnvSources } = require('../dd-trace/src/config/helper')
 const log = require('./src/log')
 const { createEsmResolver } = require('./src/resolver')
 const { isESMFile, processModule } = require('./src/utils')
@@ -60,6 +61,7 @@ for (const builtin of builtinModules) {
 
 // eslint-disable-next-line eslint-rules/eslint-process-env
 const DD_IAST_ENABLED = process.env.DD_IAST_ENABLED?.toLowerCase() === 'true' || process.env.DD_IAST_ENABLED === '1'
+const DD_BUNDLER_INJECT_GIT_METADATA = getValueFromEnvSources('DD_BUNDLER_INJECT_GIT_METADATA') !== false
 
 module.exports.name = 'datadog-esbuild'
 
@@ -143,26 +145,30 @@ globalThis.__dirname ??= $dd_dirname(globalThis.__filename);
 ${build.initialOptions.banner.js}`
   }
 
-  // Get git metadata at build time and add it to the banner for both ESM and CommonJS builds
-  const gitMetadata = getGitMetadata()
-  if (gitMetadata.repositoryURL || gitMetadata.commitSHA) {
-    build.initialOptions.banner ??= {}
-    build.initialOptions.banner.js ??= ''
+  // Bake DD_GIT_* into the banner unless DD_BUNDLER_INJECT_GIT_METADATA=false (stable artifact hashes).
+  if (DD_BUNDLER_INJECT_GIT_METADATA) {
+    const gitMetadata = getGitMetadata()
+    if (gitMetadata.repositoryURL || gitMetadata.commitSHA) {
+      build.initialOptions.banner ??= {}
+      build.initialOptions.banner.js ??= ''
 
-    build.initialOptions.banner.js = `if (typeof process === 'object' && process !== null &&
+      build.initialOptions.banner.js = `if (typeof process === 'object' && process !== null &&
     process.env !== null && typeof process.env === 'object') {
   ${gitMetadata.repositoryURL ? `process.env.DD_GIT_REPOSITORY_URL = '${gitMetadata.repositoryURL}';` : ''}
   ${gitMetadata.commitSHA ? `process.env.DD_GIT_COMMIT_SHA = '${gitMetadata.commitSHA}';` : ''}
 }
 ${build.initialOptions.banner.js}`
 
-    log.debug(
-      'Automatically injected git metadata (DD_GIT_REPOSITORY_URL: %s, DD_GIT_COMMIT_SHA: %s)',
-      gitMetadata.repositoryURL || 'not available',
-      gitMetadata.commitSHA || 'not available'
-    )
+      log.debug(
+        'Automatically injected git metadata (DD_GIT_REPOSITORY_URL: %s, DD_GIT_COMMIT_SHA: %s)',
+        gitMetadata.repositoryURL || 'not available',
+        gitMetadata.commitSHA || 'not available'
+      )
+    } else {
+      log.warn('No git metadata available - skipping injection')
+    }
   } else {
-    log.warn('No git metadata available - skipping injection')
+    log.debug('Skipping git metadata injection (DD_BUNDLER_INJECT_GIT_METADATA=false)')
   }
 
   let resolver

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

@@ -42,9 +42,9 @@ function wrapExecuteWithCallback (executeWithCallback) {
 function wrapProcess (process) {
   return function (...args) {
     const cb = args[0]
-    if (!ch.start.hasSubscribers || typeof cb !== 'function') return process.apply(this, args)
-
-    if (this[kTracingCallbackCommand]) return process.apply(this, args)
+    if (!ch.start.hasSubscribers || typeof cb !== 'function' || this[kTracingCallbackCommand]) {
+      return process.apply(this, args)
+    }
 
     const ctx = getContext(this)
 

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

@@ -228,11 +228,11 @@ for (const hook of getHooks('ai').values()) {
 
         // The SDK builds a model from a string id, in which case only the resolved instance is
         // worth wrapping; when the caller passed an instance, that is the one the SDK calls.
-        if (typeof model !== 'string' && model !== ctx.result) {
+        if (typeof model === 'string' || model === ctx.result) {
+          wrapModel(ctx.result)
+        } else {
           wrapModel(model)
           wrappedModels.add(ctx.result)
-        } else {
-          wrapModel(ctx.result)
         }
       },
     })

package/packages/datadog-instrumentations/src/aws-durable-execution-sdk-js.js

@@ -2,7 +2,6 @@
 
 const { channel, tracingChannel } = require('dc-polyfill')
 const shimmer = require('../../datadog-shimmer')
-const { addHook, getHooks } = require('./helpers/instrument')
 const LAZY_DURABLE_PROMISE_METHODS = require('./aws-durable-execution-sdk-js-context-methods')
 
 for (const method of LAZY_DURABLE_PROMISE_METHODS) {
@@ -102,8 +101,3 @@ function observeDurablePromise (dp, onSettle) {
   instrumentDurablePromiseProto(Object.getPrototypeOf(dp))
   dp[ON_SETTLE] = onSettle
 }
-
-for (const hook of getHooks('@aws/durable-execution-sdk-js').values()) {
-  hook.file = null
-  addHook(hook, exports => exports)
-}

package/packages/datadog-instrumentations/src/aws-sdk.js

@@ -2,12 +2,14 @@
 
 const shimmer = require('../../datadog-shimmer')
 const { channel, addHook } = require('./helpers/instrument')
+const sendSonic = require('./nova-sonic')
 
 const patchedClientConfigProtocols = new WeakSet()
 const patchedCommandPrototypes = new WeakSet()
+const patchedSmithyClients = new WeakSet()
 
 // Resource identifiers that already match the channel-suffix slug. Anything
-// else falls back to `'default'`. Hoisted out of the per-call hot path so we
+// else falls back to `'aws'`. Hoisted out of the per-call hot path so we
 // don't allocate a fresh Array literal + run `.includes` on every AWS send.
 const KNOWN_CHANNEL_SUFFIXES = new Set([
   'cloudwatchlogs',
@@ -161,6 +163,9 @@ function wrapSmithySend (send) {
     const channels = getChannelBag(channelSuffix)
     const clientName = getClientName(this.constructor)
     const operation = getOperationName(command.constructor)
+    if (channelSuffix === 'bedrockruntime' && operation === 'invokeModelWithBidirectionalStream') {
+      return sendSonic(send, this, command, args)
+    }
     const request = {
       operation,
       params: command.input,
@@ -320,18 +325,24 @@ function getChannelSuffix (name) {
   // some resource identifiers have spaces between ex: bedrock runtime
   name = String(name).replaceAll(' ', '')
   if (KNOWN_CHANNEL_SUFFIXES.has(name)) return name
-  return CHANNEL_SUFFIX_ALIASES.get(name) ?? 'default'
+  return CHANNEL_SUFFIX_ALIASES.get(name) ?? 'aws'
 }
 
-addHook({ name: '@smithy/smithy-client', versions: ['>=1.0.3'] }, smithy => {
-  shimmer.wrap(smithy.Client.prototype, 'send', wrapSmithySend)
+/** @param {{ Client: Function }} smithy */
+function patchSmithyClient (smithy) {
+  const prototype = smithy.Client.prototype
+  // Recent smithy-client releases re-export core/client. Loading both entry points must not
+  // install two observers on the same send (and consume/charge every duplex event twice).
+  if (!patchedSmithyClients.has(prototype)) {
+    shimmer.wrap(prototype, 'send', wrapSmithySend)
+    patchedSmithyClients.add(prototype)
+  }
   return smithy
-})
+}
 
-addHook({ name: '@aws-sdk/smithy-client', versions: ['>=3'] }, smithy => {
-  shimmer.wrap(smithy.Client.prototype, 'send', wrapSmithySend)
-  return smithy
-})
+addHook({ name: '@smithy/smithy-client', versions: ['>=1.0.3'] }, patchSmithyClient)
+
+addHook({ name: '@aws-sdk/smithy-client', versions: ['>=3'] }, patchSmithyClient)
 
 // `@aws-sdk/client-*` >= 3.1046.0 dropped `@smithy/smithy-client` and now
 // extends from `@smithy/core/client` directly. The `Client.send` contract is
@@ -341,10 +352,7 @@ addHook({
   name: '@smithy/core',
   file: 'dist-cjs/submodules/client/index.js',
   versions: ['>=3.24.0'],
-}, smithyCoreClient => {
-  shimmer.wrap(smithyCoreClient.Client.prototype, 'send', wrapSmithySend)
-  return smithyCoreClient
-})
+}, patchSmithyClient)
 
 addHook({ name: 'aws-sdk', versions: ['>=2.3.0'] }, AWS => {
   shimmer.wrap(AWS.config, 'setPromisesDependency', setPromisesDependency => {

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

@@ -11,6 +11,7 @@ const finishCh = channel('apm:cassandra-driver:query:finish')
 const errorCh = channel('apm:cassandra-driver:query:error')
 const connectCh = channel('apm:cassandra-driver:query:connect')
 
+/** @type {Record<string, unknown> & { error?: Error }} */
 let startCtx = {}
 
 addHook({ name: 'cassandra-driver', versions: ['>=3.0.0'] }, cassandra => {
@@ -24,23 +25,23 @@ addHook({ name: 'cassandra-driver', versions: ['>=3.0.0'] }, cassandra => {
     startCtx = { keyspace: this.keyspace, query: queries, contactPoints: this.options && this.options.contactPoints }
     return startCh.runStores(startCtx, () => {
       if (typeof cb === 'function') {
-        arguments[lastIndex] = wrapCallback(finishCh, errorCh, startCtx, cb)
+        arguments[lastIndex] = wrapCallback(startCtx, cb)
       }
 
       try {
         const res = batch.apply(this, arguments)
         if (typeof res === 'function') {
-          return wrapCallback(finishCh, errorCh, startCtx, res)
+          return wrapCallback(startCtx, res)
         }
         if (!res) {
           return res
         }
         return res.then(
-          () => finish(finishCh, errorCh, startCtx),
-          err => finish(finishCh, errorCh, startCtx, err)
+          () => finish(startCtx),
+          err => finish(startCtx, err)
         )
       } catch (e) {
-        finish(finishCh, errorCh, startCtx, e)
+        finish(startCtx, e)
         throw e
       }
     })
@@ -58,8 +59,8 @@ addHook({ name: 'cassandra-driver', versions: ['>=4.4'], patchDefault: false },
       const promise = _execute.apply(this, arguments)
 
       promise.then(
-        () => finish(finishCh, errorCh, startCtx),
-        err => finish(finishCh, errorCh, startCtx, err)
+        () => finish(startCtx),
+        err => finish(startCtx, err)
       )
       return promise
     })
@@ -74,10 +75,7 @@ const isValid = (args) => {
 addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'], patchDefault: false }, (cassandra) => {
   shimmer.wrap(cassandra.Client.prototype, '_innerExecute', _innerExecute =>
     function (query, params, execOptions, callback) {
-      if (!startCh.hasSubscribers) {
-        return _innerExecute.apply(this, arguments)
-      }
-      if (!isValid(arguments)) {
+      if (!startCh.hasSubscribers || !isValid(arguments)) {
         return _innerExecute.apply(this, arguments)
       }
 
@@ -87,13 +85,13 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'], patchDefault: false }
         const cb = arguments[lastIndex]
 
         if (typeof cb === 'function') {
-          arguments[lastIndex] = wrapCallback(finishCh, errorCh, startCtx, cb)
+          arguments[lastIndex] = wrapCallback(startCtx, cb)
         }
 
         try {
           return _innerExecute.apply(this, arguments)
         } catch (e) {
-          finish(finishCh, errorCh, startCtx, e)
+          finish(startCtx, e)
           throw e
         }
       })
@@ -156,7 +154,11 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 3.2'], file: 'lib/request-ha
   return RequestHandler
 })
 
-function finish (finishCh, errorCh, ctx, error) {
+/**
+ * @param {Record<string, unknown> & { error?: Error }} ctx
+ * @param {Error} [error]
+ */
+function finish (ctx, error) {
   if (error) {
     ctx.error = error
     errorCh.publish(ctx)
@@ -164,19 +166,22 @@ function finish (finishCh, errorCh, ctx, error) {
   finishCh.runStores(ctx, () => {})
 }
 
-function wrapCallback (finishCh, errorCh, ctx, callback) {
+/**
+ * @param {Record<string, unknown> & { error?: Error }} ctx
+ * @param {Parameters<typeof finishCh.runStores>[1]} callback
+ */
+function wrapCallback (ctx, callback) {
   return shimmer.wrapCallback(callback, callback => function (err) {
     if (err) {
       ctx.error = err
       errorCh.publish(ctx)
     }
-    return finishCh.runStores(ctx, callback, this, ...arguments)
+    return finishCh.runStores(
+      ctx, /** @type {Parameters<typeof finishCh.runStores>[1]} */ (callback), this, ...arguments
+    )
   })
 }
 
 function isRequestValid (exec, args, length) {
-  if (!exec) return false
-  if (args.length !== length || typeof args[length - 1] !== 'function') return false
-
-  return true
+  return !!exec && args.length === length && typeof args[length - 1] === 'function'
 }

package/packages/datadog-instrumentations/src/claude-agent-sdk.js

@@ -2,7 +2,6 @@
 
 const { tracingChannel } = require('dc-polyfill')
 const shimmer = require('../../datadog-shimmer')
-const { addHook, getHooks } = require('./helpers/instrument')
 const queryChannel = tracingChannel('orchestrion:@anthropic-ai/claude-agent-sdk:query')
 
 const stepCh = tracingChannel('apm:claude-agent-sdk:step')
@@ -638,28 +637,15 @@ function wrapQueryAsyncIterator (asyncIterator, ctx) {
   }
 }
 
-let querySubscribed = false
+queryChannel.subscribe({
+  start: onQueryStart,
+  end (ctx) {
+    if (!ctx.claudeAgentSdkTracing) return
 
-for (const hook of getHooks('@anthropic-ai/claude-agent-sdk').values()) {
-  hook.file = null
+    const { result } = ctx
 
-  addHook(hook, exports => {
-    if (!querySubscribed) {
-      querySubscribed = true
-      queryChannel.subscribe({
-        start: onQueryStart,
-        end (ctx) {
-          if (!ctx.claudeAgentSdkTracing) return
+    ctx.streamResolved = false
 
-          const { result } = ctx
-
-          ctx.streamResolved = false
-
-          shimmer.wrap(result, Symbol.asyncIterator, asyncIterator => wrapQueryAsyncIterator(asyncIterator, ctx))
-        },
-      })
-    }
-
-    return exports
-  })
-}
+    shimmer.wrap(result, Symbol.asyncIterator, asyncIterator => wrapQueryAsyncIterator(asyncIterator, ctx))
+  },
+})

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

@@ -102,7 +102,7 @@ const efdRetryCountByPickleId = new Map()
 const efdSlowAbortedPickleIds = new Set()
 const finishedParallelSuites = new Set()
 const numAttemptToCtx = new Map()
-const newTestsByTestFullname = new Map()
+const efdStatusesByPickleId = new Map()
 const attemptToFixTestsByTestFullname = new Map()
 const modifiedTestsByPickleId = new Map()
 const runnerToRetryState = new WeakMap()
@@ -200,13 +200,13 @@ function getSuiteStatusFromTestStatuses (testStatuses) {
   return 'pass'
 }
 
-function publishWorkerEfdRetryCount (pickle, retryCount) {
+function publishWorkerEfdRetryCount (pickle, retryCount, isModified) {
   const message = {
     [DD_EFD_RETRY_COUNT_MESSAGE]: {
       pickleId: pickle.id,
       retryCount,
+      isModified,
       testFileAbsolutePath: pickle.uri,
-      testName: pickle.name,
     },
   }
 
@@ -220,10 +220,12 @@ function publishWorkerEfdRetryCount (pickle, retryCount) {
   }
 
   try {
-    const { isMainThread, parentPort } = require('node:worker_threads')
+    const { isMainThread, parentPort, workerData } = require('node:worker_threads')
     if (isMainThread || !parentPort) return
 
-    parentPort.postMessage(message)
+    // Share Cucumber's envelope port so EFD metadata arrives before test results.
+    const port = workerData?.port ?? parentPort
+    port.postMessage(message)
   } catch {
     // ignore IPC errors
   }
@@ -385,14 +387,16 @@ function handleParallelTestCaseFinished (pickle, worstTestStepResult, usesNumeri
   const testFileAbsolutePath = pickle.uri
   const finished = (pickleResultByFile[testFileAbsolutePath] ||= [])
 
-  if (shouldRunEarlyFlakeDetection() && isNew) {
-    const testFullname = `${pickle.uri}:${pickle.name}`
-    let testStatuses = newTestsByTestFullname.get(testFullname)
+  const isAttemptToFix = isTestManagementTestsEnabled &&
+    getTestProperties(getTestSuitePath(testFileAbsolutePath, process.cwd()), pickle.name).attemptToFix
+
+  if (!isAttemptToFix && shouldRunEarlyFlakeDetection() && (isNew || modifiedTestsByPickleId.get(pickle.id))) {
+    let testStatuses = efdStatusesByPickleId.get(pickle.id)
     if (testStatuses) {
       testStatuses.push(status)
     } else {
       testStatuses = [status]
-      newTestsByTestFullname.set(testFullname, testStatuses)
+      efdStatusesByPickleId.set(pickle.id, testStatuses)
     }
     let efdRetryCount = efdRetryCountByPickleId.get(pickle.id)
     if (efdRetryCount === undefined) {
@@ -404,11 +408,8 @@ function handleParallelTestCaseFinished (pickle, worstTestStepResult, usesNumeri
         efdSlowAbortedPickleIds.add(pickle.id)
       }
     }
-    maybeRecordFinalParallelEfdStatus({ pickleId: pickle.id, testFileAbsolutePath, testFullname })
-  } else if (
-    isTestManagementTestsEnabled &&
-    getTestProperties(getTestSuitePath(testFileAbsolutePath, process.cwd()), pickle.name).attemptToFix
-  ) {
+    maybeRecordFinalParallelEfdStatus({ pickleId: pickle.id, testFileAbsolutePath })
+  } else if (isAttemptToFix) {
     const testFullname = `${pickle.uri}:${pickle.name}`
     let testStatuses = attemptToFixTestsByTestFullname.get(testFullname)
     if (testStatuses) {
@@ -495,8 +496,14 @@ function finishParallelSuiteIfDone (testFileAbsolutePath) {
   const finished = pickleResultByFile[testFileAbsolutePath]
   const expectedPickles = pickleByFile[testFileAbsolutePath]
 
-  if (!finished || !expectedPickles || finished.length !== expectedPickles.length) return
-  if (finishedParallelSuites.has(testFileAbsolutePath)) return
+  if (
+    !finished ||
+    !expectedPickles ||
+    finished.length !== expectedPickles.length ||
+    finishedParallelSuites.has(testFileAbsolutePath)
+  ) {
+    return
+  }
 
   finishedParallelSuites.add(testFileAbsolutePath)
   testSuiteFinishCh.publish({
@@ -505,29 +512,30 @@ function finishParallelSuiteIfDone (testFileAbsolutePath) {
   })
 }
 
-function maybeRecordFinalParallelEfdStatus ({ pickleId, testFileAbsolutePath, testFullname }) {
+function maybeRecordFinalParallelEfdStatus ({ pickleId, testFileAbsolutePath }) {
   const efdRetryCount = efdRetryCountByPickleId.get(pickleId)
-  const testStatuses = newTestsByTestFullname.get(testFullname)
+  const testStatuses = efdStatusesByPickleId.get(pickleId)
   const finished = pickleResultByFile[testFileAbsolutePath]
 
-  if (efdRetryCount === undefined || !testStatuses || !finished) return
-  if (testStatuses.length !== efdRetryCount + 1) return
+  if (efdRetryCount === undefined || !testStatuses || !finished || testStatuses.length !== efdRetryCount + 1) return
 
-  finished.push(getTestStatusFromRetries(testStatuses))
-  newTestsByTestFullname.delete(testFullname)
+  finished.push(efdRetryCount === 0 ? testStatuses[0] : getTestStatusFromRetries(testStatuses))
+  efdStatusesByPickleId.delete(pickleId)
   finishParallelSuiteIfDone(testFileAbsolutePath)
 }
 
 function handleEfdRetryCountMessage (message) {
-  const { pickleId, retryCount, testFileAbsolutePath, testName } = message
+  const { pickleId, retryCount, isModified, testFileAbsolutePath } = message
 
-  if (!pickleId || typeof retryCount !== 'number' || !testFileAbsolutePath || !testName) return
+  if (!pickleId || !testFileAbsolutePath) return
+
+  if (isModified) modifiedTestsByPickleId.set(pickleId, true)
+  if (typeof retryCount !== 'number') return
 
   efdRetryCountByPickleId.set(pickleId, retryCount)
   maybeRecordFinalParallelEfdStatus({
     pickleId,
     testFileAbsolutePath,
-    testFullname: `${testFileAbsolutePath}:${testName}`,
   })
 }
 
@@ -912,12 +920,13 @@ function wrapRun (pl, isLatestVersion, version) {
           isNew = newTestPickleIds.has(this.pickle.id)
         }
 
-        if (isNew || isModified) {
+        if (!isAttemptToFix && (isNew || isModified)) {
           isEfdRetry = numRetries > 0
         }
 
         if (
           shouldRunEarlyFlakeDetection() &&
+          !isAttemptToFix &&
           status !== 'skip' &&
           (isNew || isModified) &&
           !isEfdRetry &&
@@ -1265,7 +1274,8 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     efdRetryCountByPickleId.clear()
     efdSlowAbortedPickleIds.clear()
     finishedParallelSuites.clear()
-    newTestsByTestFullname.clear()
+    efdStatusesByPickleId.clear()
+    modifiedTestsByPickleId.clear()
     sessionStartCh.publish({ command, frameworkVersion })
 
     if (!errorSkippableRequest && skippedSuites.length) {
@@ -1478,10 +1488,15 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       }
     }
     const originalRetry = this.options.retry
-    const isManagedRetry = isAttemptToFix || (shouldRunEarlyFlakeDetection() && (isNew || isModified))
+    const isEfdTest = !isAttemptToFix && shouldRunEarlyFlakeDetection() && (isNew || isModified)
+    const isManagedRetry = isAttemptToFix || isEfdTest
     if (isManagedRetry) {
       this.options.retry = 0
     }
+    if (isWorker && isModified && isEfdTest) {
+      // The coordinator must recognize modified EFD tests before their first result arrives.
+      publishWorkerEfdRetryCount(pickle, undefined, true)
+    }
     // TODO: for >=11 we could use `runTestCaseResult` instead of accumulating results in `lastStatusByPickleId`
     const firstExecutionStart = performance.now()
     let runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
@@ -1493,7 +1508,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     const testStatuses = lastStatusByPickleId.get(pickle.id)
     const lastTestStatus = testStatuses.at(-1)
 
-    // New tests should not be marked as attempt to fix, so EFD + Attempt to fix should not be enabled at the same time
+    // Attempt to Fix owns retries for managed tests, including modified tests.
     if (isAttemptToFix && lastTestStatus !== 'skip') {
       for (let retryIndex = 0; retryIndex < testManagementAttemptToFixRetries; retryIndex++) {
         numRetriesByPickleId.set(pickle.id, retryIndex + 1)
@@ -1502,8 +1517,8 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       }
     }
 
-    // If it's a new test and it hasn't been skipped, we run it again
-    if (shouldRunEarlyFlakeDetection() && lastTestStatus !== 'skip' && (isNew || isModified)) {
+    // Retry eligible new or modified tests unless their first attempt was skipped.
+    if (isEfdTest && lastTestStatus !== 'skip') {
       let efdRetryCount = efdRetryCountByPickleId.get(pickle.id)
       if (efdRetryCount === undefined) {
         efdRetryCount = getEfdRetryCountForDuration(firstExecutionDurationMs, earlyFlakeDetectionRetryPolicy)
@@ -1525,7 +1540,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     let shouldBePassedByEFD = false
     let shouldBePassedByTestManagement = false
     let shouldBeFailedByAttemptToFix = false
-    if ((isNew || isModified) && shouldRunEarlyFlakeDetection()) {
+    if (isEfdTest) {
       /**
        * 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.
@@ -1587,7 +1602,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       return shouldBePassedByTestManagement
     }
 
-    if (isNewerCucumberVersion && shouldRunEarlyFlakeDetection() && (isNew || isModified)) {
+    if (isNewerCucumberVersion && isEfdTest) {
       return shouldBePassedByEFD
     }