dd-trace 5.35.0 → 5.37.0

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

@@ -43,6 +43,7 @@ const testErrCh = channel('ci:jest:test:err')
 const skippableSuitesCh = channel('ci:jest:test-suite:skippable')
 const libraryConfigurationCh = channel('ci:jest:library-configuration')
 const knownTestsCh = channel('ci:jest:known-tests')
+const quarantinedTestsCh = channel('ci:jest:quarantined-tests')
 
 const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')
 
@@ -70,6 +71,8 @@ let earlyFlakeDetectionFaultyThreshold = 30
 let isEarlyFlakeDetectionFaulty = false
 let hasFilteredSkippableSuites = false
 let isKnownTestsEnabled = false
+let isQuarantinedTestsEnabled = false
+let quarantinedTests = {}
 
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
@@ -140,6 +143,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       this.flakyTestRetriesCount = this.testEnvironmentOptions._ddFlakyTestRetriesCount
       this.isDiEnabled = this.testEnvironmentOptions._ddIsDiEnabled
       this.isKnownTestsEnabled = this.testEnvironmentOptions._ddIsKnownTestsEnabled
+      this.isQuarantinedTestsEnabled = this.testEnvironmentOptions._ddIsQuarantinedTestsEnabled
 
       if (this.isKnownTestsEnabled) {
         try {
@@ -161,6 +165,18 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           this.global[RETRY_TIMES] = this.flakyTestRetriesCount
         }
       }
+
+      if (this.isQuarantinedTestsEnabled) {
+        try {
+          const hasQuarantinedTests = !!quarantinedTests.jest
+          this.quarantinedTestsForThisSuite = hasQuarantinedTests
+            ? this.getQuarantinedTestsForSuite(quarantinedTests.jest.suites[this.testSuite].tests)
+            : this.getQuarantinedTestsForSuite(this.testEnvironmentOptions._ddQuarantinedTests)
+        } catch (e) {
+          log.error('Error parsing quarantined tests', e)
+          this.isQuarantinedTestsEnabled = false
+        }
+      }
     }
 
     getHasSnapshotTests () {
@@ -193,8 +209,25 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       return knownTestsForSuite
     }
 
+    getQuarantinedTestsForSuite (quaratinedTests) {
+      if (this.quarantinedTestsForThisSuite) {
+        return this.quarantinedTestsForThisSuite
+      }
+      let quarantinedTestsForSuite = quaratinedTests
+      // If jest is using workers, quarantined tests are serialized to json.
+      // If jest runs in band, they are not.
+      if (typeof quarantinedTestsForSuite === 'string') {
+        quarantinedTestsForSuite = JSON.parse(quarantinedTestsForSuite)
+      }
+      return Object.entries(quarantinedTestsForSuite).reduce((acc, [testName, { properties }]) => {
+        if (properties?.quarantined) {
+          acc.push(testName)
+        }
+        return acc
+      }, [])
+    }
+
     // Add the `add_test` event we don't have the test object yet, so
-    // we use its describe block to get the full name
     getTestNameFromAddTestEvent (event, state) {
       const describeSuffix = getJestTestName(state.currentDescribeBlock)
       const fullTestName = describeSuffix ? `${describeSuffix} ${event.testName}` : event.testName
@@ -303,6 +336,12 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             }
           }
         }
+        let isQuarantined = false
+
+        if (this.isQuarantinedTestsEnabled) {
+          const testName = getJestTestName(event.test)
+          isQuarantined = this.quarantinedTestsForThisSuite?.includes(testName)
+        }
 
         const promises = {}
         const numRetries = this.global[RETRY_TIMES]
@@ -313,10 +352,11 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         const asyncResource = asyncResources.get(event.test)
 
         if (status === 'fail') {
+          const shouldSetProbe = this.isDiEnabled && willBeRetried && numTestExecutions === 1
           asyncResource.runInAsyncScope(() => {
             testErrCh.publish({
               error: formatJestError(event.test.errors[0]),
-              shouldSetProbe: this.isDiEnabled && willBeRetried && numTestExecutions === 1,
+              shouldSetProbe,
               promises
             })
           })
@@ -336,18 +376,13 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           testFinishCh.publish({
             status,
             testStartLine: getTestLineStart(event.test.asyncError, this.testSuite),
-            promises,
-            shouldRemoveProbe: this.isDiEnabled && !willBeRetried
+            isQuarantined
           })
         })
 
         if (promises.isProbeReady) {
           await promises.isProbeReady
         }
-
-        if (promises.isProbeRemoved) {
-          await promises.isProbeRemoved
-        }
       }
       if (event.name === 'test_skip' || event.name === 'test_todo') {
         const asyncResource = new AsyncResource('bound-anonymous-fn')
@@ -489,6 +524,7 @@ function cliWrapper (cli, jestVersion) {
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
         earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
         isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
+        isQuarantinedTestsEnabled = libraryConfig.isQuarantinedTestsEnabled
       }
     } catch (err) {
       log.error('Jest library configuration error', err)
@@ -536,6 +572,25 @@ function cliWrapper (cli, jestVersion) {
       }
     }
 
+    if (isQuarantinedTestsEnabled) {
+      const quarantinedTestsPromise = new Promise((resolve) => {
+        onDone = resolve
+      })
+
+      sessionAsyncResource.runInAsyncScope(() => {
+        quarantinedTestsCh.publish({ onDone })
+      })
+
+      try {
+        const { err, quarantinedTests: receivedQuarantinedTests } = await quarantinedTestsPromise
+        if (!err) {
+          quarantinedTests = receivedQuarantinedTests
+        }
+      } catch (err) {
+        log.error('Jest quarantined tests error', err)
+      }
+    }
+
     const processArgv = process.argv.slice(2).join(' ')
     sessionAsyncResource.runInAsyncScope(() => {
       testSessionStartCh.publish({ command: `jest ${processArgv}`, frameworkVersion: jestVersion })
@@ -605,6 +660,7 @@ function cliWrapper (cli, jestVersion) {
         error,
         isEarlyFlakeDetectionEnabled,
         isEarlyFlakeDetectionFaulty,
+        isQuarantinedTestsEnabled,
         onDone
       })
     })
@@ -638,6 +694,37 @@ function cliWrapper (cli, jestVersion) {
       }
     }
 
+    if (isQuarantinedTestsEnabled) {
+      const failedTests = result
+        .results
+        .testResults.flatMap(({ testResults, testFilePath: testSuiteAbsolutePath }) => (
+          testResults.map(({ fullName: testName, status }) => ({ testName, testSuiteAbsolutePath, status }))
+        ))
+        .filter(({ status }) => status === 'failed')
+
+      let numFailedQuarantinedTests = 0
+
+      for (const { testName, testSuiteAbsolutePath } of failedTests) {
+        const testSuite = getTestSuitePath(testSuiteAbsolutePath, result.globalConfig.rootDir)
+        const isQuarantined = quarantinedTests
+          ?.jest
+          ?.suites
+          ?.[testSuite]
+          ?.tests
+          ?.[testName]
+          ?.properties
+          ?.quarantined
+        if (isQuarantined) {
+          numFailedQuarantinedTests++
+        }
+      }
+
+      // If every test that failed was quarantined, we'll consider the suite passed
+      if (numFailedQuarantinedTests !== 0 && result.results.numFailedTests === numFailedQuarantinedTests) {
+        result.results.success = true
+      }
+    }
+
     return result
   })
 
@@ -829,6 +916,8 @@ addHook({
       _ddFlakyTestRetriesCount,
       _ddIsDiEnabled,
       _ddIsKnownTestsEnabled,
+      _ddIsQuarantinedTestsEnabled,
+      _ddQuarantinedTests,
       ...restOfTestEnvironmentOptions
     } = testEnvironmentOptions
 
@@ -940,8 +1029,9 @@ addHook({
 })
 
 /*
-* This hook does two things:
+* This hook does three things:
 * - Pass known tests to the workers.
+* - Pass quarantined tests to the workers.
 * - Receive trace, coverage and logs payloads from the workers.
 */
 addHook({
@@ -951,7 +1041,7 @@ addHook({
 }, (childProcessWorker) => {
   const ChildProcessWorker = childProcessWorker.default
   shimmer.wrap(ChildProcessWorker.prototype, 'send', send => function (request) {
-    if (!isKnownTestsEnabled) {
+    if (!isKnownTestsEnabled && !isQuarantinedTestsEnabled) {
       return send.apply(this, arguments)
     }
     const [type] = request
@@ -971,11 +1061,15 @@ addHook({
       const [{ globalConfig, config, path: testSuiteAbsolutePath }] = args
       const testSuite = getTestSuitePath(testSuiteAbsolutePath, globalConfig.rootDir || process.cwd())
       const suiteKnownTests = knownTests.jest?.[testSuite] || []
+
+      const suiteQuarantinedTests = quarantinedTests.jest?.suites?.[testSuite]?.tests || {}
+
       args[0].config = {
         ...config,
         testEnvironmentOptions: {
           ...config.testEnvironmentOptions,
-          _ddKnownTests: suiteKnownTests
+          _ddKnownTests: suiteKnownTests,
+          _ddQuarantinedTests: suiteQuarantinedTests
         }
       }
     }

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

@@ -27,6 +27,7 @@ const {
   getOnPendingHandler,
   testFileToSuiteAr,
   newTests,
+  testsQuarantined,
   getTestFullName,
   getRunTestsWrapper
 } = require('./utils')
@@ -61,6 +62,7 @@ const testSuiteCodeCoverageCh = channel('ci:mocha:test-suite:code-coverage')
 const libraryConfigurationCh = channel('ci:mocha:library-configuration')
 const knownTestsCh = channel('ci:mocha:known-tests')
 const skippableSuitesCh = channel('ci:mocha:test-suite:skippable')
+const quarantinedTestsCh = channel('ci:mocha:quarantined-tests')
 const workerReportTraceCh = channel('ci:mocha:worker-report:trace')
 const testSessionStartCh = channel('ci:mocha:session:start')
 const testSessionFinishCh = channel('ci:mocha:session:finish')
@@ -135,6 +137,18 @@ function getOnEndHandler (isParallel) {
       }
     }
 
+    // We subtract the errors from quarantined tests from the total number of failures
+    if (config.isQuarantinedTestsEnabled) {
+      let numFailedQuarantinedTests = 0
+      for (const test of testsQuarantined) {
+        if (isTestFailed(test)) {
+          numFailedQuarantinedTests++
+        }
+      }
+      this.stats.failures -= numFailedQuarantinedTests
+      this.failures -= numFailedQuarantinedTests
+    }
+
     if (status === 'fail') {
       error = new Error(`Failed tests: ${this.failures}.`)
     }
@@ -165,6 +179,7 @@ function getOnEndHandler (isParallel) {
       error,
       isEarlyFlakeDetectionEnabled: config.isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty: config.isEarlyFlakeDetectionFaulty,
+      isQuarantinedTestsEnabled: config.isQuarantinedTestsEnabled,
       isParallel
     })
   })
@@ -173,6 +188,22 @@ function getOnEndHandler (isParallel) {
 function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
   const mochaRunAsyncResource = new AsyncResource('bound-anonymous-fn')
 
+  const onReceivedQuarantinedTests = ({ err, quarantinedTests: receivedQuarantinedTests }) => {
+    if (err) {
+      config.quarantinedTests = {}
+      config.isQuarantinedTestsEnabled = false
+    } else {
+      config.quarantinedTests = receivedQuarantinedTests
+    }
+    if (config.isSuitesSkippingEnabled) {
+      skippableSuitesCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
+      })
+    } else {
+      onFinishRequest()
+    }
+  }
+
   const onReceivedSkippableSuites = ({ err, skippableSuites, itrCorrelationId: responseItrCorrelationId }) => {
     if (err) {
       suitesToSkip = []
@@ -205,8 +236,11 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
     } else {
       config.knownTests = knownTests
     }
-
-    if (config.isSuitesSkippingEnabled) {
+    if (config.isQuarantinedTestsEnabled) {
+      quarantinedTestsCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedQuarantinedTests)
+      })
+    } else if (config.isSuitesSkippingEnabled) {
       skippableSuitesCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
       })
@@ -224,15 +258,20 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
     config.earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
     config.earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
     config.isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
-    // ITR and auto test retries are not supported in parallel mode yet
+    // ITR, auto test retries and quarantine are not supported in parallel mode yet
     config.isSuitesSkippingEnabled = !isParallel && libraryConfig.isSuitesSkippingEnabled
     config.isFlakyTestRetriesEnabled = !isParallel && libraryConfig.isFlakyTestRetriesEnabled
     config.flakyTestRetriesCount = !isParallel && libraryConfig.flakyTestRetriesCount
+    config.isQuarantinedTestsEnabled = !isParallel && libraryConfig.isQuarantinedTestsEnabled
 
     if (config.isKnownTestsEnabled) {
       knownTestsCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedKnownTests)
       })
+    } else if (config.isQuarantinedTestsEnabled) {
+      quarantinedTestsCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedQuarantinedTests)
+      })
     } else if (config.isSuitesSkippingEnabled) {
       skippableSuitesCh.publish({
         onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
@@ -357,7 +396,7 @@ addHook({
 
     this.once('end', getOnEndHandler(false))
 
-    this.on('test', getOnTestHandler(true, newTests))
+    this.on('test', getOnTestHandler(true))
 
     this.on('test end', getOnTestEndHandler())
 
@@ -579,6 +618,7 @@ addHook({
 
     const testPath = getTestSuitePath(testSuiteAbsolutePath, process.cwd())
     const testSuiteKnownTests = config.knownTests.mocha?.[testPath] || []
+    const testSuiteQuarantinedTests = config.quarantinedTests?.modules?.mocha?.suites?.[testPath] || []
 
     // We pass the known tests for the test file to the worker
     const testFileResult = await run.apply(
@@ -589,6 +629,8 @@ addHook({
           ...workerArgs,
           _ddEfdNumRetries: config.earlyFlakeDetectionNumRetries,
           _ddIsEfdEnabled: config.isEarlyFlakeDetectionEnabled,
+          _ddIsQuarantinedEnabled: config.isQuarantinedTestsEnabled,
+          _ddQuarantinedTests: testSuiteQuarantinedTests,
           _ddKnownTests: {
             mocha: {
               [testPath]: testSuiteKnownTests

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

@@ -26,6 +26,27 @@ const testToStartLine = new WeakMap()
 const testFileToSuiteAr = new Map()
 const wrappedFunctions = new WeakSet()
 const newTests = {}
+const testsQuarantined = new Set()
+
+function isQuarantinedTest (test, testsToQuarantine) {
+  const testSuite = getTestSuitePath(test.file, process.cwd())
+  const testName = test.fullTitle()
+
+  const isQuarantined = (testsToQuarantine
+    .mocha
+    ?.suites
+    ?.[testSuite]
+    ?.tests
+    ?.[testName]
+    ?.properties
+    ?.quarantined) ?? false
+
+  if (isQuarantined) {
+    testsQuarantined.add(test)
+  }
+
+  return isQuarantined
+}
 
 function isNewTest (test, knownTests) {
   const testSuite = getTestSuitePath(test.file, process.cwd())
@@ -171,7 +192,8 @@ function getOnTestHandler (isMain) {
       file: testSuiteAbsolutePath,
       title,
       _ddIsNew: isNew,
-      _ddIsEfdRetry: isEfdRetry
+      _ddIsEfdRetry: isEfdRetry,
+      _ddIsQuarantined: isQuarantined
     } = test
 
     const testInfo = {
@@ -187,6 +209,7 @@ function getOnTestHandler (isMain) {
 
     testInfo.isNew = isNew
     testInfo.isEfdRetry = isEfdRetry
+    testInfo.isQuarantined = isQuarantined
     // We want to store the result of the new tests
     if (isNew) {
       const testFullName = getTestFullName(test)
@@ -360,6 +383,15 @@ function getRunTestsWrapper (runTests, config) {
         }
       })
     }
+
+    if (config.isQuarantinedTestsEnabled) {
+      suite.tests.forEach(test => {
+        if (isQuarantinedTest(test, config.quarantinedTests)) {
+          test._ddIsQuarantined = true
+        }
+      })
+    }
+
     return runTests.apply(this, arguments)
   }
 }
@@ -384,5 +416,6 @@ module.exports = {
   getOnPendingHandler,
   testFileToSuiteAr,
   getRunTestsWrapper,
-  newTests
+  newTests,
+  testsQuarantined
 }

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

@@ -33,6 +33,13 @@ addHook({
       delete this.options._ddIsEfdEnabled
       delete this.options._ddKnownTests
       delete this.options._ddEfdNumRetries
+      delete this.options._ddQuarantinedTests
+    }
+    if (this.options._ddIsQuarantinedEnabled) {
+      config.isQuarantinedEnabled = true
+      config.quarantinedTests = this.options._ddQuarantinedTests
+      delete this.options._ddIsQuarantinedEnabled
+      delete this.options._ddQuarantinedTests
     }
     return run.apply(this, arguments)
   })

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

@@ -6,14 +6,14 @@ const {
   AsyncResource
 } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
-const semver = require('semver')
+const satisfies = require('semifies')
 
 function wrapConnection (Connection, version) {
   const startCh = channel('apm:mysql2:query:start')
   const finishCh = channel('apm:mysql2:query:finish')
   const errorCh = channel('apm:mysql2:query:error')
   const startOuterQueryCh = channel('datadog:mysql2:outerquery:start')
-  const shouldEmitEndAfterQueryAbort = semver.intersects(version, '>=1.3.3')
+  const shouldEmitEndAfterQueryAbort = satisfies(version, '>=1.3.3')
 
   shimmer.wrap(Connection.prototype, 'addCommand', addCommand => function (cmd) {
     if (!startCh.hasSubscribers) return addCommand.apply(this, arguments)
@@ -154,7 +154,7 @@ function wrapConnection (Connection, version) {
 }
 function wrapPool (Pool, version) {
   const startOuterQueryCh = channel('datadog:mysql2:outerquery:start')
-  const shouldEmitEndAfterQueryAbort = semver.intersects(version, '>=1.3.3')
+  const shouldEmitEndAfterQueryAbort = satisfies(version, '>=1.3.3')
 
   shimmer.wrap(Pool.prototype, 'query', query => function (sql, values, cb) {
     if (!startOuterQueryCh.hasSubscribers) return query.apply(this, arguments)

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

@@ -97,6 +97,14 @@ const V4_PACKAGE_SHIMS = [
     targetClass: 'Translations',
     baseResource: 'audio.translations',
     methods: ['create']
+  },
+  {
+    file: 'resources/chat/completions/completions.js',
+    targetClass: 'Completions',
+    baseResource: 'chat.completions',
+    methods: ['create'],
+    streamedResponse: true,
+    versions: ['>=4.85.0']
   }
 ]
 

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

@@ -1,4 +1,4 @@
-const semver = require('semver')
+const satisfies = require('semifies')
 
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
@@ -13,6 +13,7 @@ const testSessionFinishCh = channel('ci:playwright:session:finish')
 
 const libraryConfigurationCh = channel('ci:playwright:library-configuration')
 const knownTestsCh = channel('ci:playwright:known-tests')
+const quarantinedTestsCh = channel('ci:playwright:quarantined-tests')
 
 const testSuiteStartCh = channel('ci:playwright:test-suite:start')
 const testSuiteFinishCh = channel('ci:playwright:test-suite:finish')
@@ -41,8 +42,24 @@ let earlyFlakeDetectionNumRetries = 0
 let isFlakyTestRetriesEnabled = false
 let flakyTestRetriesCount = 0
 let knownTests = {}
+let isQuarantinedTestsEnabled = false
+let quarantinedTests = {}
 let rootDir = ''
-const MINIMUM_SUPPORTED_VERSION_EFD = '1.38.0'
+const MINIMUM_SUPPORTED_VERSION_RANGE_EFD = '>=1.38.0'
+
+function isQuarantineTest (test) {
+  const testName = getTestFullname(test)
+  const testSuite = getTestSuitePath(test._requireFile, rootDir)
+
+  return quarantinedTests
+    ?.playwright
+    ?.suites
+    ?.[testSuite]
+    ?.tests
+    ?.[testName]
+    ?.properties
+    ?.quarantined
+}
 
 function isNewTest (test) {
   const testSuite = getTestSuitePath(test._requireFile, rootDir)
@@ -296,6 +313,7 @@ function testEndHandler (test, annotations, testStatus, error, isTimeout) {
       error,
       extraTags: annotationTags,
       isNew: test._ddIsNew,
+      isQuarantined: test._ddIsQuarantined,
       isEfdRetry: test._ddIsEfdRetry
     })
   })
@@ -424,14 +442,16 @@ function runnerHook (runnerExport, playwrightVersion) {
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
         isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
         flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
+        isQuarantinedTestsEnabled = libraryConfig.isQuarantinedTestsEnabled
       }
     } catch (e) {
       isEarlyFlakeDetectionEnabled = false
       isKnownTestsEnabled = false
+      isQuarantinedTestsEnabled = false
       log.error('Playwright session start error', e)
     }
 
-    if (isKnownTestsEnabled && semver.gte(playwrightVersion, MINIMUM_SUPPORTED_VERSION_EFD)) {
+    if (isKnownTestsEnabled && satisfies(playwrightVersion, MINIMUM_SUPPORTED_VERSION_RANGE_EFD)) {
       try {
         const { err, knownTests: receivedKnownTests } = await getChannelPromise(knownTestsCh)
         if (!err) {
@@ -447,6 +467,20 @@ function runnerHook (runnerExport, playwrightVersion) {
       }
     }
 
+    if (isQuarantinedTestsEnabled && satisfies(playwrightVersion, MINIMUM_SUPPORTED_VERSION_RANGE_EFD)) {
+      try {
+        const { err, quarantinedTests: receivedQuarantinedTests } = await getChannelPromise(quarantinedTestsCh)
+        if (!err) {
+          quarantinedTests = receivedQuarantinedTests
+        } else {
+          isQuarantinedTestsEnabled = false
+        }
+      } catch (err) {
+        isQuarantinedTestsEnabled = false
+        log.error('Playwright quarantined tests error', err)
+      }
+    }
+
     const projects = getProjectsFromRunner(this)
 
     if (isFlakyTestRetriesEnabled && flakyTestRetriesCount > 0) {
@@ -479,6 +513,7 @@ function runnerHook (runnerExport, playwrightVersion) {
       testSessionFinishCh.publish({
         status: STATUS_TO_TEST_STATUS[sessionStatus],
         isEarlyFlakeDetectionEnabled,
+        isQuarantinedTestsEnabled,
         onDone
       })
     })
@@ -487,6 +522,8 @@ function runnerHook (runnerExport, playwrightVersion) {
     startedSuites = []
     remainingTestsByFile = {}
 
+    // TODO: we can trick playwright into thinking the session passed by returning
+    // 'passed' here. We might be able to use this for both EFD and Quarantined tests.
     return runAllTestsReturn
   })
 
@@ -540,7 +577,7 @@ addHook({
 addHook({
   name: 'playwright',
   file: 'lib/common/suiteUtils.js',
-  versions: [`>=${MINIMUM_SUPPORTED_VERSION_EFD}`]
+  versions: [MINIMUM_SUPPORTED_VERSION_RANGE_EFD]
 }, suiteUtilsPackage => {
   // We grab `applyRepeatEachIndex` to use it later
   // `applyRepeatEachIndex` needs to be applied to a cloned suite
@@ -552,31 +589,42 @@ addHook({
 addHook({
   name: 'playwright',
   file: 'lib/runner/loadUtils.js',
-  versions: [`>=${MINIMUM_SUPPORTED_VERSION_EFD}`]
+  versions: [MINIMUM_SUPPORTED_VERSION_RANGE_EFD]
 }, (loadUtilsPackage) => {
   const oldCreateRootSuite = loadUtilsPackage.createRootSuite
 
   async function newCreateRootSuite () {
+    if (!isKnownTestsEnabled && !isQuarantinedTestsEnabled) {
+      return oldCreateRootSuite.apply(this, arguments)
+    }
     const rootSuite = await oldCreateRootSuite.apply(this, arguments)
-    if (!isKnownTestsEnabled) {
-      return rootSuite
+
+    const allTests = rootSuite.allTests()
+
+    if (isQuarantinedTestsEnabled) {
+      const testsToBeIgnored = allTests.filter(isQuarantineTest)
+      testsToBeIgnored.forEach(test => {
+        test._ddIsQuarantined = true
+        test.expectedStatus = 'skipped'
+      })
     }
-    const newTests = rootSuite
-      .allTests()
-      .filter(isNewTest)
-
-    newTests.forEach(newTest => {
-      newTest._ddIsNew = true
-      if (isEarlyFlakeDetectionEnabled && newTest.expectedStatus !== 'skipped') {
-        const fileSuite = getSuiteType(newTest, 'file')
-        const projectSuite = getSuiteType(newTest, 'project')
-        for (let repeatEachIndex = 0; repeatEachIndex < earlyFlakeDetectionNumRetries; repeatEachIndex++) {
-          const copyFileSuite = deepCloneSuite(fileSuite, isNewTest)
-          applyRepeatEachIndex(projectSuite._fullProject, copyFileSuite, repeatEachIndex + 1)
-          projectSuite._addSuite(copyFileSuite)
+
+    if (isKnownTestsEnabled) {
+      const newTests = allTests.filter(isNewTest)
+
+      newTests.forEach(newTest => {
+        newTest._ddIsNew = true
+        if (isEarlyFlakeDetectionEnabled && newTest.expectedStatus !== 'skipped') {
+          const fileSuite = getSuiteType(newTest, 'file')
+          const projectSuite = getSuiteType(newTest, 'project')
+          for (let repeatEachIndex = 0; repeatEachIndex < earlyFlakeDetectionNumRetries; repeatEachIndex++) {
+            const copyFileSuite = deepCloneSuite(fileSuite, isNewTest)
+            applyRepeatEachIndex(projectSuite._fullProject, copyFileSuite, repeatEachIndex + 1)
+            projectSuite._addSuite(copyFileSuite)
+          }
         }
-      }
-    })
+      })
+    }
 
     return rootSuite
   }