dd-trace 5.52.0 → 5.54.0

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

@@ -26,7 +26,7 @@ const {
   getOnHookEndHandler,
   getOnFailHandler,
   getOnPendingHandler,
-  testFileToSuiteAr,
+  testFileToSuiteCtx,
   newTests,
   testsQuarantined,
   getTestFullName,
@@ -53,7 +53,7 @@ const originalCoverageMap = createCoverageMap()
 let untestedCoverage
 
 // test channels
-const testStartCh = channel('ci:mocha:test:start')
+const testFinishCh = channel('ci:mocha:test:finish')
 
 // test suite channels
 const testSuiteStartCh = channel('ci:mocha:test-suite:start')
@@ -66,6 +66,7 @@ const libraryConfigurationCh = channel('ci:mocha:library-configuration')
 const knownTestsCh = channel('ci:mocha:known-tests')
 const skippableSuitesCh = channel('ci:mocha:test-suite:skippable')
 const testManagementTestsCh = channel('ci:mocha:test-management-tests')
+const impactedTestsCh = channel('ci:mocha:modified-tests')
 const workerReportTraceCh = channel('ci:mocha:worker-report:trace')
 const testSessionStartCh = channel('ci:mocha:session:start')
 const testSessionFinishCh = channel('ci:mocha:session:finish')
@@ -166,7 +167,7 @@ function getOnEndHandler (isParallel) {
       error = new Error(`Failed tests: ${this.failures}.`)
     }
 
-    testFileToSuiteAr.clear()
+    testFileToSuiteCtx.clear()
 
     let testCodeCoverageLinesTotal
     if (global.__coverage__) {
@@ -175,7 +176,7 @@ function getOnEndHandler (isParallel) {
           originalCoverageMap.merge(fromCoverageMapToCoverage(untestedCoverage))
         }
         testCodeCoverageLinesTotal = originalCoverageMap.getCoverageSummary().lines.pct
-      } catch (e) {
+      } catch {
         // ignore errors
       }
       // restore the original coverage
@@ -209,6 +210,26 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
     } else {
       config.testManagementTests = receivedTestManagementTests
     }
+    if (config.isImpactedTestsEnabled) {
+      impactedTestsCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedImpactedTests)
+      })
+    } else if (config.isSuitesSkippingEnabled) {
+      skippableSuitesCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
+      })
+    } else {
+      onFinishRequest()
+    }
+  }
+
+  const onReceivedImpactedTests = ({ err, modifiedTests: receivedModifiedTests }) => {
+    if (err) {
+      config.modifiedTests = []
+      config.isImpactedTestsEnabled = false
+    } else {
+      config.modifiedTests = receivedModifiedTests
+    }
     if (config.isSuitesSkippingEnabled) {
       skippableSuitesCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
@@ -237,7 +258,7 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
 
     runner.suite.suites = suitesToRun
 
-    skippedSuites = Array.from(filteredSuites.skippedSuites)
+    skippedSuites = [...filteredSuites.skippedSuites]
 
     onFinishRequest()
   }
@@ -254,6 +275,10 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
       testManagementTestsCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedTestManagementTests)
       })
+    } if (config.isImpactedTestsEnabled) {
+      impactedTestsCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedImpactedTests)
+      })
     } else if (config.isSuitesSkippingEnabled) {
       skippableSuitesCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
@@ -274,6 +299,7 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
     config.isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
     config.isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
     config.testManagementAttemptToFixRetries = libraryConfig.testManagementAttemptToFixRetries
+    config.isImpactedTestsEnabled = libraryConfig.isImpactedTestsEnabled
     // ITR and auto test retries are not supported in parallel mode yet
     config.isSuitesSkippingEnabled = !isParallel && libraryConfig.isSuitesSkippingEnabled
     config.isFlakyTestRetriesEnabled = !isParallel && libraryConfig.isFlakyTestRetriesEnabled
@@ -287,6 +313,10 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
       testManagementTestsCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedTestManagementTests)
       })
+    } else if (config.isImpactedTestsEnabled) {
+      impactedTestsCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedImpactedTests)
+      })
     } else if (config.isSuitesSkippingEnabled) {
       skippableSuitesCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
@@ -312,7 +342,7 @@ addHook({
 }, (Mocha) => {
   shimmer.wrap(Mocha.prototype, 'run', run => function () {
     // Workers do not need to request any data, just run the tests
-    if (!testStartCh.hasSubscribers || process.env.MOCHA_WORKER_ID || this.options.parallel) {
+    if (!testFinishCh.hasSubscribers || process.env.MOCHA_WORKER_ID || this.options.parallel) {
       return run.apply(this, arguments)
     }
 
@@ -367,7 +397,7 @@ addHook({
 }, (run) => {
   // `runMocha` is an async function
   shimmer.wrap(run, 'runMocha', runMocha => function () {
-    if (!testStartCh.hasSubscribers) {
+    if (!testFinishCh.hasSubscribers) {
       return runMocha.apply(this, arguments)
     }
     const mocha = arguments[0]
@@ -403,7 +433,7 @@ addHook({
   shimmer.wrap(Runner.prototype, 'runTests', runTests => getRunTestsWrapper(runTests, config))
 
   shimmer.wrap(Runner.prototype, 'run', run => function () {
-    if (!testStartCh.hasSubscribers) {
+    if (!testFinishCh.hasSubscribers) {
       return run.apply(this, arguments)
     }
 
@@ -430,20 +460,18 @@ addHook({
       if (suite.root || !suite.tests.length) {
         return
       }
-      let asyncResource = testFileToSuiteAr.get(suite.file)
-      if (!asyncResource) {
-        asyncResource = new AsyncResource('bound-anonymous-fn')
-        testFileToSuiteAr.set(suite.file, asyncResource)
+      let ctx = testFileToSuiteCtx.get(suite.file)
+      if (!ctx) {
         const isUnskippable = unskippableSuites.includes(suite.file)
         isForcedToRun = isUnskippable && suitesToSkip.includes(getTestSuitePath(suite.file, process.cwd()))
-        asyncResource.runInAsyncScope(() => {
-          testSuiteStartCh.publish({
-            testSuiteAbsolutePath: suite.file,
-            isUnskippable,
-            isForcedToRun,
-            itrCorrelationId
-          })
-        })
+        ctx = {
+          testSuiteAbsolutePath: suite.file,
+          isUnskippable,
+          isForcedToRun,
+          itrCorrelationId
+        }
+        testFileToSuiteCtx.set(suite.file, ctx)
+        testSuiteStartCh.runStores(ctx, () => {})
       }
     })
 
@@ -485,11 +513,9 @@ addHook({
         resetCoverage(global.__coverage__)
       }
 
-      const asyncResource = testFileToSuiteAr.get(suite.file)
-      if (asyncResource) {
-        asyncResource.runInAsyncScope(() => {
-          testSuiteFinishCh.publish(status)
-        })
+      const ctx = testFileToSuiteCtx.get(suite.file)
+      if (ctx) {
+        testSuiteFinishCh.publish({ status, ...ctx.currentStore }, () => {})
       } else {
         log.warn(() => `No AsyncResource found for suite ${suite.file}`)
       }
@@ -509,6 +535,15 @@ addHook({
   file: 'lib/runnable.js'
 }, (runnablePackage) => runnableWrapper(runnablePackage, config))
 
+function onMessage (message) {
+  if (Array.isArray(message)) {
+    const [messageCode, payload] = message
+    if (messageCode === MOCHA_WORKER_TRACE_PAYLOAD_CODE) {
+      workerReportTraceCh.publish(payload)
+    }
+  }
+}
+
 // Only used in parallel mode (--parallel flag is passed)
 // Used to generate suite events and receive test payloads from workers
 addHook({
@@ -520,58 +555,40 @@ addHook({
   file: 'src/WorkerHandler.js'
 }, (workerHandlerPackage) => {
   shimmer.wrap(workerHandlerPackage.prototype, 'exec', exec => function (_, path) {
-    if (!testStartCh.hasSubscribers) {
+    if (!testFinishCh.hasSubscribers) {
       return exec.apply(this, arguments)
     }
     if (!path?.length) {
       return exec.apply(this, arguments)
     }
     const [testSuiteAbsolutePath] = path
-    const testSuiteAsyncResource = new AsyncResource('bound-anonymous-fn')
-
-    function onMessage (message) {
-      if (Array.isArray(message)) {
-        const [messageCode, payload] = message
-        if (messageCode === MOCHA_WORKER_TRACE_PAYLOAD_CODE) {
-          testSuiteAsyncResource.runInAsyncScope(() => {
-            workerReportTraceCh.publish(payload)
-          })
-        }
-      }
-    }
+    const testSuiteContext = {}
 
     this.worker.on('message', onMessage)
 
-    testSuiteAsyncResource.runInAsyncScope(() => {
-      testSuiteStartCh.publish({
-        testSuiteAbsolutePath
-      })
-    })
+    testSuiteContext.testSuiteAbsolutePath = testSuiteAbsolutePath
+    testSuiteStartCh.runStores(testSuiteContext, () => {})
 
     try {
       const promise = exec.apply(this, arguments)
       promise.then(
         (result) => {
           const status = result.failureCount === 0 ? 'pass' : 'fail'
-          testSuiteAsyncResource.runInAsyncScope(() => {
-            testSuiteFinishCh.publish(status)
-          })
+          testSuiteFinishCh.publish({ status, ...testSuiteContext.currentStore }, () => {})
           this.worker.off('message', onMessage)
         },
         (err) => {
-          testSuiteAsyncResource.runInAsyncScope(() => {
-            testSuiteErrorCh.publish(err)
-            testSuiteFinishCh.publish('fail')
-          })
+          testSuiteContext.error = err
+          testSuiteErrorCh.runStores(testSuiteContext, () => {})
+          testSuiteFinishCh.publish({ status: 'fail', ...testSuiteContext.currentStore }, () => {})
           this.worker.off('message', onMessage)
         }
       )
       return promise
     } catch (err) {
-      testSuiteAsyncResource.runInAsyncScope(() => {
-        testSuiteErrorCh.publish(err)
-        testSuiteFinishCh.publish('fail')
-      })
+      testSuiteContext.error = err
+      testSuiteErrorCh.runStores(testSuiteContext, () => {})
+      testSuiteFinishCh.publish({ status: 'fail', ...testSuiteContext.currentStore }, () => {})
       this.worker.off('message', onMessage)
       throw err
     }
@@ -588,7 +605,7 @@ addHook({
   file: 'lib/nodejs/parallel-buffered-runner.js'
 }, (ParallelBufferedRunner, frameworkVersion) => {
   shimmer.wrap(ParallelBufferedRunner.prototype, 'run', run => function (cb, { files }) {
-    if (!testStartCh.hasSubscribers) {
+    if (!testFinishCh.hasSubscribers) {
       return run.apply(this, arguments)
     }
 
@@ -629,7 +646,10 @@ addHook({
   const { BufferedWorkerPool } = BufferedWorkerPoolPackage
 
   shimmer.wrap(BufferedWorkerPool.prototype, 'run', run => async function (testSuiteAbsolutePath, workerArgs) {
-    if (!testStartCh.hasSubscribers || (!config.isKnownTestsEnabled && !config.isTestManagementTestsEnabled)) {
+    if (!testFinishCh.hasSubscribers ||
+        (!config.isKnownTestsEnabled &&
+         !config.isTestManagementTestsEnabled &&
+         !config.isImpactedTestsEnabled)) {
       return run.apply(this, arguments)
     }
 
@@ -662,6 +682,12 @@ addHook({
       }
     }
 
+    if (config.isImpactedTestsEnabled) {
+      const testSuiteImpactedTests = config.modifiedTests || {}
+      newWorkerArgs._ddIsImpactedTestsEnabled = true
+      newWorkerArgs._ddModifiedTests = testSuiteImpactedTests
+    }
+
     // We pass the known tests for the test file to the worker
     const testFileResult = await run.apply(
       this,
@@ -682,10 +708,10 @@ addHook({
         const testFullName = getTestFullName(test)
         const tests = newTests[testFullName]
 
-        if (!tests) {
-          newTests[testFullName] = [test]
-        } else {
+        if (tests) {
           tests.push(test)
+        } else {
+          newTests[testFullName] = [test]
         }
       }
       // `testsQuarantined` is filled in the worker process, so we need to use the test results to fill it here too.

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

@@ -7,7 +7,7 @@ const {
   addAttemptToFixStringToTestName,
   removeAttemptToFixStringFromTestName
 } = require('../../../dd-trace/src/plugins/util/test')
-const { channel, AsyncResource } = require('../helpers/instrument')
+const { channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
 // test channels
@@ -17,15 +17,16 @@ const testFinishCh = channel('ci:mocha:test:finish')
 const testRetryCh = channel('ci:mocha:test:retry')
 const errorCh = channel('ci:mocha:test:error')
 const skipCh = channel('ci:mocha:test:skip')
-
+const testFnCh = channel('ci:mocha:test:fn')
+const isModifiedCh = channel('ci:mocha:test:is-modified')
 // suite channels
 const testSuiteErrorCh = channel('ci:mocha:test-suite:error')
 
 const BREAKPOINT_HIT_GRACE_PERIOD_MS = 200
-const testToAr = new WeakMap()
+const testToContext = new WeakMap()
 const originalFns = new WeakMap()
 const testToStartLine = new WeakMap()
-const testFileToSuiteAr = new Map()
+const testFileToSuiteCtx = new Map()
 const wrappedFunctions = new WeakSet()
 const newTests = {}
 const testsAttemptToFix = new Set()
@@ -125,7 +126,7 @@ function getTestStatus (test) {
   return 'pass'
 }
 
-function getTestToArKey (test) {
+function getTestToContextKey (test) {
   if (!test.fn) {
     return test
   }
@@ -136,14 +137,14 @@ function getTestToArKey (test) {
   return originalFn
 }
 
-function getTestAsyncResource (test) {
-  const key = getTestToArKey(test)
-  return testToAr.get(key)
+function getTestContext (test) {
+  const key = getTestToContextKey(test)
+  return testToContext.get(key)
 }
 
 function runnableWrapper (RunnablePackage, libraryConfig) {
   shimmer.wrap(RunnablePackage.prototype, 'run', run => function () {
-    if (!testStartCh.hasSubscribers) {
+    if (!testFinishCh.hasSubscribers) {
       return run.apply(this, arguments)
     }
     // Flaky test retries does not work in parallel mode
@@ -167,14 +168,17 @@ function runnableWrapper (RunnablePackage, libraryConfig) {
 
     if (isTestHook || this.type === 'test') {
       const test = isTestHook ? this.ctx.currentTest : this
-      const asyncResource = getTestAsyncResource(test)
+      const ctx = getTestContext(test)
 
-      if (asyncResource) {
-        // we bind the test fn to the correct async resource
-        const newFn = asyncResource.bind(this.fn)
+      if (ctx) {
+        const originalFn = this.fn
+        // we bind the test fn to the correct context
+        const newFn = function () {
+          return testFnCh.runStores(ctx, () => originalFn.apply(this, arguments))
+        }
 
         // we store the original function, not to lose it
-        originalFns.set(newFn, this.fn)
+        originalFns.set(newFn, originalFn)
         this.fn = newFn
 
         wrappedFunctions.add(this.fn)
@@ -189,7 +193,6 @@ function runnableWrapper (RunnablePackage, libraryConfig) {
 function getOnTestHandler (isMain) {
   return function (test) {
     const testStartLine = testToStartLine.get(test)
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
 
     // This may be a retry. If this is the case, `test.fn` is already wrapped,
     // so we need to restore it.
@@ -198,7 +201,6 @@ function getOnTestHandler (isMain) {
       test.fn = originalFn
       wrappedFunctions.delete(test.fn)
     }
-    testToAr.set(test.fn, asyncResource)
 
     const {
       file: testSuiteAbsolutePath,
@@ -207,7 +209,8 @@ function getOnTestHandler (isMain) {
       _ddIsEfdRetry: isEfdRetry,
       _ddIsAttemptToFix: isAttemptToFix,
       _ddIsDisabled: isDisabled,
-      _ddIsQuarantined: isQuarantined
+      _ddIsQuarantined: isQuarantined,
+      _ddIsModified: isModified
     } = test
 
     const testName = removeEfdStringFromTestName(removeAttemptToFixStringFromTestName(test.fullTitle()))
@@ -228,6 +231,7 @@ function getOnTestHandler (isMain) {
     testInfo.isAttemptToFix = isAttemptToFix
     testInfo.isDisabled = isDisabled
     testInfo.isQuarantined = isQuarantined
+    testInfo.isModified = isModified
     // We want to store the result of the new tests
     if (isNew) {
       const testFullName = getTestFullName(test)
@@ -242,15 +246,15 @@ function getOnTestHandler (isMain) {
       test.pending = true
     }
 
-    asyncResource.runInAsyncScope(() => {
-      testStartCh.publish(testInfo)
-    })
+    const ctx = testInfo
+    testToContext.set(test.fn, ctx)
+    testStartCh.runStores(ctx, () => {})
   }
 }
 
 function getOnTestEndHandler (config) {
   return async function (test) {
-    const asyncResource = getTestAsyncResource(test)
+    const ctx = getTestContext(test)
     const status = getTestStatus(test)
 
     // After finishing it might take a bit for the snapshot to be handled.
@@ -269,17 +273,17 @@ function getOnTestEndHandler (config) {
 
     const testName = getTestFullName(test)
 
-    if (!testsStatuses.get(testName)) {
-      testsStatuses.set(testName, [status])
-    } else {
+    if (testsStatuses.get(testName)) {
       testsStatuses.get(testName).push(status)
+    } else {
+      testsStatuses.set(testName, [status])
     }
     const testStatuses = testsStatuses.get(testName)
 
     const isLastAttempt = testStatuses.length === config.testManagementAttemptToFixRetries + 1
 
     if (test._ddIsAttemptToFix && isLastAttempt) {
-      if (testStatuses.some(status => status === 'fail')) {
+      if (testStatuses.includes('fail')) {
         attemptToFixFailed = true
       }
       if (testStatuses.every(status => status === 'fail')) {
@@ -295,18 +299,17 @@ function getOnTestEndHandler (config) {
       !test._ddIsEfdRetry
 
     // if there are afterEach to be run, we don't finish the test yet
-    if (asyncResource && !getAfterEachHooks(test).length) {
-      asyncResource.runInAsyncScope(() => {
-        testFinishCh.publish({
-          status,
-          hasBeenRetried: isMochaRetry(test),
-          isLastRetry: getIsLastRetry(test),
-          hasFailedAllRetries,
-          attemptToFixPassed,
-          attemptToFixFailed,
-          isAttemptToFixRetry,
-          isAtrRetry
-        })
+    if (ctx && !getAfterEachHooks(test).length) {
+      testFinishCh.publish({
+        status,
+        hasBeenRetried: isMochaRetry(test),
+        isLastRetry: getIsLastRetry(test),
+        hasFailedAllRetries,
+        attemptToFixPassed,
+        attemptToFixFailed,
+        isAttemptToFixRetry,
+        isAtrRetry,
+        ...ctx.currentStore
       })
     }
   }
@@ -320,10 +323,13 @@ function getOnHookEndHandler () {
       const isLastAfterEach = afterEachHooks.indexOf(hook) === afterEachHooks.length - 1
       if (isLastAfterEach) {
         const status = getTestStatus(test)
-        const asyncResource = getTestAsyncResource(test)
-        if (asyncResource) {
-          asyncResource.runInAsyncScope(() => {
-            testFinishCh.publish({ status, hasBeenRetried: isMochaRetry(test), isLastRetry: getIsLastRetry(test) })
+        const ctx = getTestContext(test)
+        if (ctx) {
+          testFinishCh.publish({
+            status,
+            hasBeenRetried: isMochaRetry(test),
+            isLastRetry: getIsLastRetry(test),
+            ...ctx.currentStore
           })
         }
       }
@@ -339,35 +345,34 @@ function getOnFailHandler (isMain) {
     if (isHook && testOrHook.ctx) {
       test = testOrHook.ctx.currentTest
     }
-    let testAsyncResource
+    let testContext
     if (test) {
-      testAsyncResource = getTestAsyncResource(test)
+      testContext = getTestContext(test)
     }
-    if (testAsyncResource) {
-      testAsyncResource.runInAsyncScope(() => {
-        if (isHook) {
-          err.message = `${testOrHook.fullTitle()}: ${err.message}`
-          errorCh.publish(err)
-          // if it's a hook and it has failed, 'test end' will not be called
-          testFinishCh.publish({ status: 'fail', hasBeenRetried: isMochaRetry(test) })
-        } else {
-          errorCh.publish(err)
-        }
-      })
+    if (testContext) {
+      if (isHook) {
+        err.message = `${testOrHook.fullTitle()}: ${err.message}`
+        testContext.err = err
+        errorCh.runStores(testContext, () => {})
+        // if it's a hook and it has failed, 'test end' will not be called
+        testFinishCh.publish({ status: 'fail', hasBeenRetried: isMochaRetry(test), ...testContext.currentStore })
+      } else {
+        testContext.err = err
+        errorCh.runStores(testContext, () => {})
+      }
     }
 
     if (isMain) {
-      const testSuiteAsyncResource = testFileToSuiteAr.get(testFile)
+      const testSuiteContext = testFileToSuiteCtx.get(testFile)
 
-      if (testSuiteAsyncResource) {
+      if (testSuiteContext) {
         // we propagate the error to the suite
         const testSuiteError = new Error(
           `"${testOrHook.parent.fullTitle()}" failed with message "${err.message}"`
         )
         testSuiteError.stack = err.stack
-        testSuiteAsyncResource.runInAsyncScope(() => {
-          testSuiteErrorCh.publish(testSuiteError)
-        })
+        testSuiteContext.error = testSuiteError
+        testSuiteErrorCh.runStores(testSuiteContext, () => {})
       }
     }
   }
@@ -375,20 +380,18 @@ function getOnFailHandler (isMain) {
 
 function getOnTestRetryHandler (config) {
   return function (test, err) {
-    const asyncResource = getTestAsyncResource(test)
-    if (asyncResource) {
+    const ctx = getTestContext(test)
+    if (ctx) {
       const isFirstAttempt = test._currentRetry === 0
       const willBeRetried = test._currentRetry < test._retries
       const isAtrRetry = !isFirstAttempt &&
         config.isFlakyTestRetriesEnabled &&
         !test._ddIsAttemptToFix &&
         !test._ddIsEfdRetry
-      asyncResource.runInAsyncScope(() => {
-        testRetryCh.publish({ isFirstAttempt, err, willBeRetried, test, isAtrRetry })
-      })
+      testRetryCh.publish({ isFirstAttempt, err, willBeRetried, test, isAtrRetry, ...ctx.currentStore })
     }
-    const key = getTestToArKey(test)
-    testToAr.delete(key)
+    const key = getTestToContextKey(test)
+    testToContext.delete(key)
   }
 }
 
@@ -407,23 +410,19 @@ function getOnPendingHandler () {
       testStartLine
     }
 
-    const asyncResource = getTestAsyncResource(test)
-    if (asyncResource) {
-      asyncResource.runInAsyncScope(() => {
-        skipCh.publish(testInfo)
-      })
+    const ctx = getTestContext(test)
+    if (ctx) {
+      skipCh.publish(testInfo)
     } else {
-      // if there is no async resource, the test has been skipped through `test.skip`
+      // if there is no context, the test has been skipped through `test.skip`
       // or the parent suite is skipped
-      const skippedTestAsyncResource = new AsyncResource('bound-anonymous-fn')
+      const testCtx = testInfo
       if (test.fn) {
-        testToAr.set(test.fn, skippedTestAsyncResource)
+        testToContext.set(test.fn, testCtx)
       } else {
-        testToAr.set(test, skippedTestAsyncResource)
+        testToContext.set(test, testCtx)
       }
-      skippedTestAsyncResource.runInAsyncScope(() => {
-        skipCh.publish(testInfo)
-      })
+      skipCh.runStores(testCtx, () => {})
     }
   }
 }
@@ -455,12 +454,34 @@ function getRunTestsWrapper (runTests, config) {
       })
     }
 
+    if (config.isImpactedTestsEnabled) {
+      suite.tests.forEach((test) => {
+        isModifiedCh.publish({
+          modifiedTests: config.modifiedTests,
+          file: suite.file,
+          onDone: (isModified) => {
+            if (isModified) {
+              test._ddIsModified = true
+              if (!test.isPending() && !test._ddIsAttemptToFix && config.isEarlyFlakeDetectionEnabled) {
+                retryTest(
+                  test,
+                  config.earlyFlakeDetectionNumRetries,
+                  addEfdStringToTestName,
+                  ['_ddIsModified', '_ddIsEfdRetry']
+                )
+              }
+            }
+          }
+        })
+      })
+    }
+
     if (config.isKnownTestsEnabled) {
       // by the time we reach `this.on('test')`, it is too late. We need to add retries here
       suite.tests.forEach(test => {
         if (!test.isPending() && isNewTest(test, config.knownTests)) {
           test._ddIsNew = true
-          if (config.isEarlyFlakeDetectionEnabled) {
+          if (config.isEarlyFlakeDetectionEnabled && !test._ddIsAttemptToFix && !test._ddIsModified) {
             retryTest(
               test,
               config.earlyFlakeDetectionNumRetries,
@@ -484,9 +505,9 @@ module.exports = {
   getTestFullName,
   getTestStatus,
   runnableWrapper,
-  testToAr,
+  testToContext,
   originalFns,
-  getTestAsyncResource,
+  getTestContext,
   testToStartLine,
   getOnTestHandler,
   getOnTestEndHandler,
@@ -494,7 +515,7 @@ module.exports = {
   getOnHookEndHandler,
   getOnFailHandler,
   getOnPendingHandler,
-  testFileToSuiteAr,
+  testFileToSuiteCtx,
   getRunTestsWrapper,
   newTests,
   testsQuarantined,