dd-trace 5.36.0 → 5.37.1

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
   }

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

@@ -9,6 +9,7 @@ const testPassCh = channel('ci:vitest:test:pass')
 const testErrorCh = channel('ci:vitest:test:error')
 const testSkipCh = channel('ci:vitest:test:skip')
 const isNewTestCh = channel('ci:vitest:test:is-new')
+const isQuarantinedCh = channel('ci:vitest:test:is-quarantined')
 
 // test suite hooks
 const testSuiteStartCh = channel('ci:vitest:test-suite:start')
@@ -21,10 +22,12 @@ const testSessionFinishCh = channel('ci:vitest:session:finish')
 const libraryConfigurationCh = channel('ci:vitest:library-configuration')
 const knownTestsCh = channel('ci:vitest:known-tests')
 const isEarlyFlakeDetectionFaultyCh = channel('ci:vitest:is-early-flake-detection-faulty')
+const quarantinedTestsCh = channel('ci:vitest:quarantined-tests')
 
 const taskToAsync = new WeakMap()
 const taskToStatuses = new WeakMap()
 const newTasks = new WeakSet()
+const quarantinedTasks = new WeakSet()
 let isRetryReasonEfd = false
 const switchedStatuses = new WeakSet()
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
@@ -46,7 +49,9 @@ function getProvidedContext () {
       _ddIsDiEnabled,
       _ddKnownTests: knownTests,
       _ddEarlyFlakeDetectionNumRetries: numRepeats,
-      _ddIsKnownTestsEnabled: isKnownTestsEnabled
+      _ddIsKnownTestsEnabled: isKnownTestsEnabled,
+      _ddIsQuarantinedTestsEnabled: isQuarantinedTestsEnabled,
+      _ddQuarantinedTests: quarantinedTests
     } = globalThis.__vitest_worker__.providedContext
 
     return {
@@ -54,7 +59,9 @@ function getProvidedContext () {
       isEarlyFlakeDetectionEnabled: _ddIsEarlyFlakeDetectionEnabled,
       knownTests,
       numRepeats,
-      isKnownTestsEnabled
+      isKnownTestsEnabled,
+      isQuarantinedTestsEnabled,
+      quarantinedTests
     }
   } catch (e) {
     log.error('Vitest workers could not parse provided context, so some features will not work.')
@@ -63,7 +70,9 @@ function getProvidedContext () {
       isEarlyFlakeDetectionEnabled: false,
       knownTests: {},
       numRepeats: 0,
-      isKnownTestsEnabled: false
+      isKnownTestsEnabled: false,
+      isQuarantinedTestsEnabled: false,
+      quarantinedTests: {}
     }
   }
 }
@@ -158,8 +167,10 @@ function getSortWrapper (sort) {
     let earlyFlakeDetectionNumRetries = 0
     let isEarlyFlakeDetectionFaulty = false
     let isKnownTestsEnabled = false
+    let isQuarantinedTestsEnabled = false
     let isDiEnabled = false
     let knownTests = {}
+    let quarantinedTests = {}
 
     try {
       const { err, libraryConfig } = await getChannelPromise(libraryConfigurationCh)
@@ -170,6 +181,7 @@ function getSortWrapper (sort) {
         earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
         isDiEnabled = libraryConfig.isDiEnabled
         isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
+        isQuarantinedTestsEnabled = libraryConfig.isQuarantinedTestsEnabled
       }
     } catch (e) {
       isFlakyTestRetriesEnabled = false
@@ -229,6 +241,23 @@ function getSortWrapper (sort) {
       }
     }
 
+    if (isQuarantinedTestsEnabled) {
+      const { err, quarantinedTests: receivedQuarantinedTests } = await getChannelPromise(quarantinedTestsCh)
+      if (!err) {
+        quarantinedTests = receivedQuarantinedTests
+        try {
+          const workspaceProject = this.ctx.getCoreWorkspaceProject()
+          workspaceProject._provided._ddIsQuarantinedTestsEnabled = isQuarantinedTestsEnabled
+          workspaceProject._provided._ddQuarantinedTests = quarantinedTests
+        } catch (e) {
+          log.warn('Could not send quarantined tests to workers so Quarantine will not work.')
+        }
+      } else {
+        isQuarantinedTestsEnabled = false
+        log.error('Could not get quarantined tests.')
+      }
+    }
+
     let testCodeCoverageLinesTotal
 
     if (this.ctx.coverageProvider?.generateCoverage) {
@@ -263,6 +292,7 @@ function getSortWrapper (sort) {
           error,
           isEarlyFlakeDetectionEnabled,
           isEarlyFlakeDetectionFaulty,
+          isQuarantinedTestsEnabled,
           onFinish
         })
       })
@@ -332,7 +362,7 @@ addHook({
 
   // `onAfterRunTask` is run after all repetitions or attempts are run
   shimmer.wrap(VitestTestRunner.prototype, 'onAfterRunTask', onAfterRunTask => async function (task) {
-    const { isEarlyFlakeDetectionEnabled } = getProvidedContext()
+    const { isEarlyFlakeDetectionEnabled, isQuarantinedTestsEnabled } = getProvidedContext()
 
     if (isEarlyFlakeDetectionEnabled && taskToStatuses.has(task)) {
       const statuses = taskToStatuses.get(task)
@@ -345,6 +375,12 @@ addHook({
       }
     }
 
+    if (isQuarantinedTestsEnabled) {
+      if (quarantinedTasks.has(task)) {
+        task.result.state = 'pass'
+      }
+    }
+
     return onAfterRunTask.apply(this, arguments)
   })
 
@@ -356,17 +392,34 @@ addHook({
     }
     const testName = getTestName(task)
     let isNew = false
+    let isQuarantined = false
 
     const {
       isKnownTestsEnabled,
       isEarlyFlakeDetectionEnabled,
-      isDiEnabled
+      isDiEnabled,
+      isQuarantinedTestsEnabled,
+      quarantinedTests
     } = getProvidedContext()
 
     if (isKnownTestsEnabled) {
       isNew = newTasks.has(task)
     }
 
+    if (isQuarantinedTestsEnabled) {
+      isQuarantinedCh.publish({
+        quarantinedTests,
+        testSuiteAbsolutePath: task.file.filepath,
+        testName,
+        onDone: (isTestQuarantined) => {
+          isQuarantined = isTestQuarantined
+          if (isTestQuarantined) {
+            quarantinedTasks.add(task)
+          }
+        }
+      })
+    }
+
     const { retry: numAttempt, repeats: numRepetition } = retryInfo
 
     // We finish the previous test here because we know it has failed already
@@ -448,7 +501,8 @@ addHook({
         isRetry: numAttempt > 0 || numRepetition > 0,
         isRetryReasonEfd,
         isNew,
-        mightHitProbe: isDiEnabled && numAttempt > 0
+        mightHitProbe: isDiEnabled && numAttempt > 0,
+        isQuarantined
       })
     })
     return onBeforeTryTask.apply(this, arguments)

package/packages/datadog-plugin-cucumber/src/index.js

@@ -27,7 +27,9 @@ const {
   TEST_MODULE_ID,
   TEST_SUITE,
   CUCUMBER_IS_PARALLEL,
-  TEST_RETRY_REASON
+  TEST_RETRY_REASON,
+  TEST_MANAGEMENT_ENABLED,
+  TEST_MANAGEMENT_IS_QUARANTINED
 } = require('../../dd-trace/src/plugins/util/test')
 const { RESOURCE_NAME } = require('../../../ext/tags')
 const { COMPONENT, ERROR_MESSAGE } = require('../../dd-trace/src/constants')
@@ -47,6 +49,7 @@ const {
 const id = require('../../dd-trace/src/id')
 
 const BREAKPOINT_HIT_GRACE_PERIOD_MS = 200
+const BREAKPOINT_SET_GRACE_PERIOD_MS = 200
 const isCucumberWorker = !!process.env.CUCUMBER_WORKER_ID
 
 function getTestSuiteTags (testSuiteSpan) {
@@ -83,6 +86,7 @@ class CucumberPlugin extends CiPlugin {
       hasForcedToRunSuites,
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
+      isQuarantinedTestsEnabled,
       isParallel
     }) => {
       const { isSuitesSkippingEnabled, isCodeCoverageEnabled } = this.libraryConfig || {}
@@ -109,6 +113,9 @@ class CucumberPlugin extends CiPlugin {
       if (isParallel) {
         this.testSessionSpan.setTag(CUCUMBER_IS_PARALLEL, 'true')
       }
+      if (isQuarantinedTestsEnabled) {
+        this.testSessionSpan.setTag(TEST_MANAGEMENT_ENABLED, 'true')
+      }
 
       this.testSessionSpan.setTag(TEST_STATUS, status)
       this.testModuleSpan.setTag(TEST_STATUS, status)
@@ -251,7 +258,12 @@ class CucumberPlugin extends CiPlugin {
           const { file, line, stackIndex } = probeInformation
           this.runningTestProbe = { file, line }
           this.testErrorStackIndex = stackIndex
-          // TODO: we're not waiting for setProbePromise to be resolved, so there might be race conditions
+          const waitUntil = Date.now() + BREAKPOINT_SET_GRACE_PERIOD_MS
+          while (Date.now() < waitUntil) {
+            // TODO: To avoid a race condition, we should wait until `probeInformation.setProbePromise` has resolved.
+            // However, Cucumber doesn't have a mechanism for waiting asyncrounously here, so for now, we'll have to
+            // fall back to a fixed syncronous delay.
+          }
         }
       }
       span.setTag(TEST_STATUS, 'fail')
@@ -311,7 +323,8 @@ class CucumberPlugin extends CiPlugin {
       errorMessage,
       isNew,
       isEfdRetry,
-      isFlakyRetry
+      isFlakyRetry,
+      isQuarantined
     }) => {
       const span = storage('legacy').getStore().span
       const statusTag = isStep ? 'step.status' : TEST_STATUS
@@ -340,6 +353,10 @@ class CucumberPlugin extends CiPlugin {
         span.setTag(TEST_IS_RETRY, 'true')
       }
 
+      if (isQuarantined) {
+        span.setTag(TEST_MANAGEMENT_IS_QUARANTINED, 'true')
+      }
+
       span.finish()
       if (!isStep) {
         const spanTags = span.context()._tags

package/packages/datadog-plugin-cypress/src/cypress-plugin.js

@@ -33,7 +33,9 @@ const {
   TEST_SESSION_NAME,
   TEST_LEVEL_EVENT_TYPES,
   TEST_RETRY_REASON,
-  DD_TEST_IS_USER_PROVIDED_SERVICE
+  DD_TEST_IS_USER_PROVIDED_SERVICE,
+  TEST_MANAGEMENT_IS_QUARANTINED,
+  TEST_MANAGEMENT_ENABLED
 } = require('../../dd-trace/src/plugins/util/test')
 const { isMarkedAsUnskippable } = require('../../datadog-plugin-jest/src/util')
 const { ORIGIN_KEY, COMPONENT } = require('../../dd-trace/src/constants')
@@ -152,6 +154,20 @@ function getKnownTests (tracer, testConfiguration) {
   })
 }
 
+function getQuarantinedTests (tracer, testConfiguration) {
+  return new Promise(resolve => {
+    if (!tracer._tracer._exporter?.getQuarantinedTests) {
+      return resolve({ err: new Error('Test Optimization was not initialized correctly') })
+    }
+    tracer._tracer._exporter.getQuarantinedTests(testConfiguration, (err, quarantinedTests) => {
+      resolve({
+        err,
+        quarantinedTests
+      })
+    })
+  })
+}
+
 function getSuiteStatus (suiteStats) {
   if (!suiteStats) {
     return 'skip'
@@ -240,7 +256,8 @@ class CypressPlugin {
               earlyFlakeDetectionNumRetries,
               isFlakyTestRetriesEnabled,
               flakyTestRetriesCount,
-              isKnownTestsEnabled
+              isKnownTestsEnabled,
+              isQuarantinedTestsEnabled
             }
           } = libraryConfigurationResponse
           this.isSuitesSkippingEnabled = isSuitesSkippingEnabled
@@ -251,12 +268,24 @@ class CypressPlugin {
           if (isFlakyTestRetriesEnabled) {
             this.cypressConfig.retries.runMode = flakyTestRetriesCount
           }
+          this.isQuarantinedTestsEnabled = isQuarantinedTestsEnabled
         }
         return this.cypressConfig
       })
     return this.libraryConfigurationPromise
   }
 
+  getIsQuarantinedTest (testSuite, testName) {
+    return this.quarantinedTests
+      ?.cypress
+      ?.suites
+      ?.[testSuite]
+      ?.tests
+      ?.[testName]
+      ?.properties
+      ?.quarantined
+  }
+
   getTestSuiteSpan ({ testSuite, testSuiteAbsolutePath }) {
     const testSuiteSpanMetadata =
       getTestSuiteCommonTags(this.command, this.frameworkVersion, testSuite, TEST_FRAMEWORK_NAME)
@@ -351,10 +380,6 @@ class CypressPlugin {
     })
   }
 
-  isNewTest (testName, testSuite) {
-    return !this.knownTestsByTestSuite?.[testSuite]?.includes(testName)
-  }
-
   async beforeRun (details) {
     // We need to make sure that the plugin is initialized before running the tests
     // This is for the case where the user has not returned the promise from the init function
@@ -393,6 +418,19 @@ class CypressPlugin {
       }
     }
 
+    if (this.isQuarantinedTestsEnabled) {
+      const quarantinedTestsResponse = await getQuarantinedTests(
+        this.tracer,
+        this.testConfiguration
+      )
+      if (quarantinedTestsResponse.err) {
+        log.error('Cypress quarantined tests response error', quarantinedTestsResponse.err)
+        this.isQuarantinedTestsEnabled = false
+      } else {
+        this.quarantinedTests = quarantinedTestsResponse.quarantinedTests
+      }
+    }
+
     // `details.specs` are test files
     details.specs?.forEach(({ absolute, relative }) => {
       const isUnskippableSuite = isMarkedAsUnskippable({ path: absolute })
@@ -471,6 +509,10 @@ class CypressPlugin {
         }
       )
 
+      if (this.isQuarantinedTestsEnabled) {
+        this.testSessionSpan.setTag(TEST_MANAGEMENT_ENABLED, 'true')
+      }
+
       this.testModuleSpan.finish()
       this.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
       this.testSessionSpan.finish()
@@ -545,6 +587,13 @@ class CypressPlugin {
       if (this.itrCorrelationId) {
         skippedTestSpan.setTag(ITR_CORRELATION_ID, this.itrCorrelationId)
       }
+
+      const isQuarantined = this.getIsQuarantinedTest(spec.relative, cypressTestName)
+
+      if (isQuarantined) {
+        skippedTestSpan.setTag(TEST_MANAGEMENT_IS_QUARANTINED, 'true')
+      }
+
       skippedTestSpan.finish()
     })
 
@@ -648,6 +697,7 @@ class CypressPlugin {
         })
         const isUnskippable = this.unskippableSuites.includes(testSuite)
         const isForcedToRun = shouldSkip && isUnskippable
+        const isQuarantined = this.getIsQuarantinedTest(testSuite, testName)
 
         // skip test
         if (shouldSkip && !isUnskippable) {
@@ -656,6 +706,12 @@ class CypressPlugin {
           return { shouldSkip: true }
         }
 
+        // TODO: I haven't found a way to trick cypress into ignoring a test
+        // The way we'll implement quarantine in cypress is by skipping the test altogether
+        if (isQuarantined) {
+          return { shouldSkip: true }
+        }
+
         if (!this.activeTestSpan) {
           this.activeTestSpan = this.getTestSpan({
             testName,
@@ -681,7 +737,8 @@ class CypressPlugin {
           testSuiteAbsolutePath,
           testName,
           isNew,
-          isEfdRetry
+          isEfdRetry,
+          isQuarantined
         } = test
         if (coverage && this.isCodeCoverageEnabled && this.tracer._tracer._exporter?.exportCoverage) {
           const coverageFiles = getCoveredFilenamesFromCoverage(coverage)
@@ -720,6 +777,9 @@ class CypressPlugin {
             this.activeTestSpan.setTag(TEST_RETRY_REASON, 'efd')
           }
         }
+        if (isQuarantined) {
+          this.activeTestSpan.setTag(TEST_MANAGEMENT_IS_QUARANTINED, 'true')
+        }
         const finishedTest = {
           testName,
           testStatus,