@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,11 @@
+'use strict'
+
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+
+// Cypress plugin does not patch any library. This is just a placeholder to
+// follow the structure of the plugins
+class CypressPlugin extends Plugin {
+  static id = 'cypress'
+}
+
+module.exports = CypressPlugin

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

@@ -0,0 +1,57 @@
+'use strict'
+
+const NoopTracer = require('../../dd-trace/src/noop/tracer')
+const satisfies = require('../../../vendor/dist/semifies')
+const { DD_MAJOR } = require('../../../version')
+const cypressPlugin = require('./cypress-plugin')
+
+const noopTask = {
+  'dd:testSuiteStart': () => {
+    return null
+  },
+  'dd:beforeEach': () => {
+    return {}
+  },
+  'dd:afterEach': () => {
+    return null
+  },
+  'dd:addTags': () => {
+    return null
+  },
+}
+
+module.exports = function CypressPlugin (on, config) {
+  const tracer = require('../../dd-trace')
+
+  if (satisfies(config.version, '<10.2.0')) {
+    if (DD_MAJOR >= 6) {
+      // eslint-disable-next-line no-console
+      console.error(
+        'ERROR: dd-trace v6 has deleted support for Cypress<10.2.0.'
+      )
+      on('task', noopTask)
+      return config
+    }
+
+    // console.warn does not seem to work in cypress, so using console.log instead
+    // eslint-disable-next-line no-console
+    console.log(
+      'WARNING: dd-trace support for Cypress<10.2.0 is deprecated' +
+      ' and will not be supported in future versions of dd-trace.'
+    )
+  }
+
+  // The tracer was not init correctly for whatever reason (such as invalid DD_SITE)
+  if (tracer._tracer instanceof NoopTracer) {
+    // We still need to register these tasks or the support file will fail
+    on('task', noopTask)
+    return config
+  }
+
+  on('before:run', cypressPlugin.beforeRun.bind(cypressPlugin))
+  on('after:spec', cypressPlugin.afterSpec.bind(cypressPlugin))
+  on('after:run', cypressPlugin.afterRun.bind(cypressPlugin))
+  on('task', cypressPlugin.getTasks())
+
+  return cypressPlugin.init(tracer, config)
+}

package/packages/datadog-plugin-cypress/src/source-map-utils.js

@@ -0,0 +1,297 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+
+// Base64 lookup table for source map VLQ decoding
+const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+const BASE64_DECODE = new Uint8Array(128)
+for (let i = 0; i < BASE64_CHARS.length; i++) {
+  BASE64_DECODE[BASE64_CHARS.charCodeAt(i)] = i
+}
+const TEST_DECLARATION_RE = /(?:it|test|specify)\s*\(\s*(?:'((?:[^'\\]|\\.)*)'|"((?:[^"\\]|\\.)*)"|`((?:[^`\\]|\\[\s\S])*)`)\s*,/g
+const SOURCE_MAP_CACHE = new Map()
+
+/**
+ * Whether a file path references JavaScript.
+ * @param {string} absoluteFilePath
+ * @returns {boolean}
+ */
+function isJavaScriptFile (absoluteFilePath) {
+  return absoluteFilePath.endsWith('.js') || absoluteFilePath.endsWith('.cjs') || absoluteFilePath.endsWith('.mjs')
+}
+
+/**
+ * Decide whether invocationDetails line can be trusted as final source line.
+ * @param {string} absoluteFilePath
+ * @param {number} testSourceLine
+ * @returns {boolean}
+ */
+function shouldTrustInvocationDetailsLine (absoluteFilePath, testSourceLine) {
+  if (!Number.isInteger(testSourceLine) || testSourceLine < 1) return false
+  if (!isJavaScriptFile(absoluteFilePath)) return false
+
+  return getCachedSourceMap(absoluteFilePath) === null
+}
+
+/**
+ * Decode one VLQ-encoded integer from `str` at `cursor.pos`, advancing the cursor in place.
+ * @param {string} str
+ * @param {{ pos: number }} cursor
+ * @returns {number}
+ */
+function decodeVLQ (str, cursor) {
+  let result = 0
+  let shift = 0
+  let digit
+  do {
+    digit = BASE64_DECODE[str.charCodeAt(cursor.pos++)]
+    result |= (digit & 0x1F) << shift
+    shift += 5
+  } while (digit & 0x20)
+  return (result & 1) ? -(result >>> 1) : result >>> 1
+}
+
+/**
+ * Resolve a source path from a source map entry to an absolute file path.
+ * Handles regular relative paths and virtual URL-like source paths.
+ * @param {string} mapDir - Directory of the source map (or the file containing the inline source map)
+ * @param {string} sourceRoot - The `sourceRoot` field from the source map
+ * @param {string} sourcePath - A single entry from the source map's `sources` array
+ * @returns {string | null}
+ */
+function resolveSourcePath (mapDir, sourceRoot, sourcePath) {
+  const cleanSourcePath = sourcePath.replace(/[?#].*$/, '')
+  if (/^[A-Za-z][A-Za-z\d+.-]*:\/\//.test(cleanSourcePath)) {
+    // Virtual sources may use URL-like schemes (e.g. file://, webpack://, vite://).
+    // If they encode an absolute local path in the URL pathname, use it.
+    try {
+      const pathname = new URL(cleanSourcePath).pathname
+      return pathname && path.isAbsolute(pathname) ? pathname : null
+    } catch {
+      return null
+    }
+  }
+  if (sourceRoot && /^[A-Za-z][A-Za-z\d+.-]*:\/\//.test(sourceRoot)) {
+    // URL-like sourceRoot values are virtual; resolve relative entries from mapDir.
+    return path.resolve(mapDir, sourcePath)
+  }
+  return path.resolve(mapDir, sourceRoot || '', sourcePath)
+}
+
+/**
+ * Read a source map for a file. Tries:
+ *  1. An adjacent `.map` file (`absoluteFilePath + '.map'`)
+ *  2. An inline `data:` URI in the file's last line (`//# sourceMappingURL=data:…`)
+ * Returns null when neither source is available or parseable.
+ * @param {string} absoluteFilePath
+ * @returns {object | null}
+ */
+function readSourceMap (absoluteFilePath) {
+  try {
+    return JSON.parse(fs.readFileSync(absoluteFilePath + '.map', 'utf8'))
+  } catch {}
+  try {
+    const content = fs.readFileSync(absoluteFilePath, 'utf8')
+    const match = content.match(
+      /\/\/# sourceMappingURL=data:application\/json;(?:charset=utf-8;)?base64,([\w+/=\s]+)/
+    )
+    if (match) {
+      return JSON.parse(Buffer.from(match[1].replaceAll(/\s/g, ''), 'base64').toString('utf8'))
+    }
+  } catch {}
+  return null
+}
+
+/**
+ * Read and cache source maps per file path. Cache stores parse result or null.
+ * @param {string} absoluteFilePath
+ * @returns {object | null}
+ */
+function getCachedSourceMap (absoluteFilePath) {
+  if (SOURCE_MAP_CACHE.has(absoluteFilePath)) {
+    return SOURCE_MAP_CACHE.get(absoluteFilePath)
+  }
+  const sourceMap = readSourceMap(absoluteFilePath)
+  SOURCE_MAP_CACHE.set(absoluteFilePath, sourceMap)
+  return sourceMap
+}
+
+/**
+ * Given a generated file's absolute path and a generated line number, returns the
+ * original source file path and line by reading the adjacent .map file or an inline
+ * source map embedded in the file. Returns null when no source map is found or the
+ * mapping cannot be resolved.
+ * @param {string} absoluteFilePath - Absolute path to the generated (compiled or bundled) file
+ * @param {number} generatedLine - 1-indexed line number in the generated file
+ * @returns {{ sourceFile: string, line: number } | null}
+ */
+function resolveOriginalSourcePosition (absoluteFilePath, generatedLine) {
+  const sourceMap = getCachedSourceMap(absoluteFilePath)
+  if (!sourceMap) return null
+  const { mappings, sources, sourceRoot } = sourceMap
+  if (!mappings || !sources?.length) return null
+
+  const mapDir = path.dirname(absoluteFilePath)
+  const cursor = { pos: 0 }
+  let srcFile = 0
+  let srcLine = 0
+
+  const lines = mappings.split(';')
+  for (let li = 0; li < lines.length; li++) {
+    const line = lines[li]
+    if (!line) continue
+    cursor.pos = 0
+    while (cursor.pos < line.length) {
+      decodeVLQ(line, cursor) // genCol — not needed
+      if (cursor.pos < line.length && line[cursor.pos] !== ',') {
+        // Segment has source info: srcFileIndex (delta), srcLine (delta), srcCol, [namesIndex]
+        srcFile += decodeVLQ(line, cursor)
+        srcLine += decodeVLQ(line, cursor)
+        decodeVLQ(line, cursor) // srcCol — not needed
+        if (cursor.pos < line.length && line[cursor.pos] !== ',') {
+          decodeVLQ(line, cursor) // namesIndex — not needed
+        }
+        if (li === generatedLine - 1) {
+          const sourcePath = sources[srcFile]
+          if (!sourcePath) return null
+          const sourceFile = resolveSourcePath(mapDir, sourceRoot, sourcePath)
+          return sourceFile ? { sourceFile, line: srcLine + 1 } : null
+        }
+      }
+      if (cursor.pos < line.length && line[cursor.pos] === ',') cursor.pos++
+    }
+  }
+  return null
+}
+
+/**
+ * Convert a template literal body (the text between backticks, with `${…}` interpolations)
+ * into a regex that matches the runtime-evaluated string. Each `${…}` expression is replaced
+ * with `.*?` so the pattern matches whatever value the expression produced at runtime.
+ * @param {string} templateBody - Raw template literal content (the text between the backticks)
+ * @returns {RegExp}
+ */
+function templateBodyToRegExp (templateBody) {
+  // Split on ${...} expressions, escaping the literal parts and replacing interpolations
+  // with .*? wildcards. We handle basic nesting of braces inside ${} to avoid false splits.
+  let pattern = ''
+  let i = 0
+  while (i < templateBody.length) {
+    const dollarIdx = templateBody.indexOf('${', i)
+    if (dollarIdx === -1) {
+      pattern += templateBody.slice(i).replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)
+      break
+    }
+    pattern += templateBody.slice(i, dollarIdx).replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)
+    pattern += '.*?'
+    // skip past the matching closing brace, counting nested braces
+    let depth = 1
+    i = dollarIdx + 2
+    while (i < templateBody.length && depth > 0) {
+      if (templateBody[i] === '{') depth++
+      else if (templateBody[i] === '}') depth--
+      i++
+    }
+  }
+  return new RegExp(`^${pattern}$`)
+}
+
+/**
+ * Count 1-indexed line number for a character index in `content`.
+ * @param {string} content
+ * @param {number} endIndex
+ * @returns {number}
+ */
+function lineNumberForIndex (content, endIndex) {
+  let line = 1
+  for (let i = 0; i < endIndex; i++) {
+    if (content.charCodeAt(i) === 10) line++
+  }
+  return line
+}
+
+/**
+ * Extract the first stack frame line number from an invocation stack.
+ * Supports Chromium-style ("at fn (file:line:col)") and Firefox-style ("fn@file:line:col").
+ * @param {string} stack
+ * @returns {number | null}
+ */
+function firstGeneratedLineFromStack (stack) {
+  if (typeof stack !== 'string' || stack.length === 0) return null
+  const lines = stack.split('\n')
+  for (const line of lines) {
+    const match = line.match(/:(\d+):\d+\)?\s*$/)
+    if (match) {
+      const parsed = Number(match[1])
+      if (Number.isInteger(parsed) && parsed > 0) {
+        return parsed
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * Find the declaration line for a test name by scanning it()/test()/specify() calls.
+ * For template literals, `${...}` placeholders are fuzzy-matched against runtime values.
+ * @param {string} content
+ * @param {string} testName
+ * @returns {number | null}
+ */
+function findTestDeclarationLine (content, testName) {
+  TEST_DECLARATION_RE.lastIndex = 0
+  let match
+  while ((match = TEST_DECLARATION_RE.exec(content)) !== null) {
+    const singleQuoted = match[1]
+    const doubleQuoted = match[2]
+    const templateQuoted = match[3]
+    const isTemplate = templateQuoted !== undefined
+    const candidateName = singleQuoted ?? doubleQuoted ?? templateQuoted
+    if (!candidateName) continue
+
+    const doesMatch = isTemplate
+      ? templateBodyToRegExp(candidateName).test(testName)
+      : candidateName === testName
+    if (doesMatch) {
+      return lineNumberForIndex(content, match.index)
+    }
+  }
+  return null
+}
+
+/**
+ * Find the original source line for a test.
+ * It first tries mapping a generated line extracted from invocation stack.
+ * If that fails, it scans declaration name and maps the matched generated line
+ * through a source map when available.
+ * For `.ts` specs, the matched line is already the source line.
+ * @param {string} absoluteFilePath - Absolute path to the spec file (compiled JS or .ts)
+ * @param {string} testName - The test name passed to `it()`, `test()`, or `specify()`
+ * @param {string} invocationStack - Raw invocationDetails stack for the test
+ * @returns {number | null} The resolved source line (1-indexed), or null
+ */
+function resolveSourceLineForTest (absoluteFilePath, testName, invocationStack) {
+  const generatedLineFromStack = firstGeneratedLineFromStack(invocationStack)
+  if (generatedLineFromStack && !absoluteFilePath.endsWith('.ts')) {
+    const stackResolved = resolveOriginalSourcePosition(absoluteFilePath, generatedLineFromStack)
+    if (stackResolved) return stackResolved.line
+  }
+
+  let content
+  try {
+    content = fs.readFileSync(absoluteFilePath, 'utf8')
+  } catch {
+    return null
+  }
+
+  const foundLine = findTestDeclarationLine(content, testName)
+  if (!foundLine) return null
+
+  if (absoluteFilePath.endsWith('.ts')) return foundLine
+  const resolved = resolveOriginalSourcePosition(absoluteFilePath, foundLine)
+  if (resolved) return resolved.line
+  return null
+}
+
+module.exports = { resolveOriginalSourcePosition, resolveSourceLineForTest, shouldTrustInvocationDetailsLine }

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

@@ -0,0 +1,303 @@
+'use strict'
+
+const DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME = 'datadog-ci-visibility-test-execution-id'
+let rumFlushWaitMillis = 500
+
+let isEarlyFlakeDetectionEnabled = false
+let isKnownTestsEnabled = false
+let knownTestsForSuite = []
+let earlyFlakeDetectionNumRetries = 0
+let isTestManagementEnabled = false
+let testManagementAttemptToFixRetries = 0
+let testManagementTests = {}
+let isImpactedTestsEnabled = false
+let isModifiedTest = false
+let isTestIsolationEnabled = false
+// Array of test names that have been retried and the reason
+const retryReasonsByTestName = new Map()
+// Track quarantined test errors - we catch them in Cypress.on('fail') but need to report to Datadog
+const quarantinedTestErrors = new Map()
+
+// Track the most recently loaded window in the AUT. Updated via the 'window:load'
+// event so we always get the real app window (after cy.visit()), not the
+// about:blank window that exists when beforeEach runs. If the test later navigates
+// to a cross-origin URL, safeGetRum() handles the access error.
+let originalWindow
+
+// If the test is using multi domain with cy.origin, trying to access
+// window properties will result in a cross origin error.
+function safeGetRum (window) {
+  try {
+    return window.DD_RUM
+  } catch {
+    return null
+  }
+}
+
+function isNewTest (test) {
+  // If for whatever reason the worker does not receive valid known tests, we don't consider it as new
+  if (!Array.isArray(knownTestsForSuite)) {
+    return false
+  }
+  return !knownTestsForSuite.includes(test.fullTitle())
+}
+
+function getTestProperties (testName) {
+  // TODO: Use optional chaining when we drop support for older Cypress versions, which will happen when dd-trace@5 is
+  // EoL. Until then, this files needs to support Node.js 16.
+  const properties = testManagementTests[testName] && testManagementTests[testName].properties || {}
+
+  const { attempt_to_fix: isAttemptToFix, disabled: isDisabled, quarantined: isQuarantined } = properties
+
+  return { isAttemptToFix, isDisabled, isQuarantined }
+}
+
+// Catch test failures for quarantined tests and suppress them
+// By not re-throwing the error, Cypress marks the test as passed
+// This allows quarantined tests to run but not affect the exit code
+Cypress.on('fail', (err, runnable) => {
+  if (!isTestManagementEnabled) {
+    throw err
+  }
+
+  const testName = runnable.fullTitle()
+  const { isQuarantined, isAttemptToFix } = getTestProperties(testName)
+
+  // For pure quarantined tests (not attemptToFix), suppress the failure
+  // This makes the test "pass" from Cypress's perspective while we still track the error
+  if (isQuarantined && !isAttemptToFix) {
+    // Store the error so we can report it to Datadog in afterEach
+    quarantinedTestErrors.set(testName, err)
+    // Don't re-throw - this prevents Cypress from marking the test as failed
+    return
+  }
+
+  // For all other tests (including attemptToFix), let the error propagate normally
+  throw err
+})
+
+function getRetriedTests (test, numRetries, tags) {
+  const retriedTests = []
+  for (let retryIndex = 0; retryIndex < numRetries; retryIndex++) {
+    // TODO: signal in framework logs that this is a retry.
+    // TODO: Change it so these tests are allowed to fail.
+    const clonedTest = test.clone()
+    for (const tag of tags) {
+      if (tag) {
+        clonedTest[tag] = true
+      }
+    }
+    retriedTests.push(clonedTest)
+  }
+  return retriedTests
+}
+
+const oldRunTests = Cypress.mocha.getRunner().runTests
+Cypress.mocha.getRunner().runTests = function (suite, fn) {
+  if (!isKnownTestsEnabled && !isTestManagementEnabled && !isImpactedTestsEnabled) {
+    return oldRunTests.apply(this, arguments)
+  }
+  // We copy the tests array and add retries to it, then assign it back to suite.tests
+  // to avoid modifying the array while iterating over it
+  const testsWithRetries = []
+
+  for (let testIndex = 0; testIndex < suite.tests.length; testIndex++) {
+    const test = suite.tests[testIndex]
+    const testName = test.fullTitle()
+    const { isAttemptToFix } = getTestProperties(testName)
+    const isSkipped = test.isPending()
+
+    const isAtemptToFix = isTestManagementEnabled && isAttemptToFix && !isSkipped
+    const isModified = isImpactedTestsEnabled && isModifiedTest
+    const isNew = isKnownTestsEnabled && !isSkipped && isNewTest(test)
+
+    // We want is_modified and is_new regardless of the retry reason
+    if (isModified) {
+      test._ddIsModified = true
+    }
+    if (isNew) {
+      test._ddIsNew = true
+    }
+
+    // Add the original test first
+    testsWithRetries.push(test)
+
+    if (!isTestIsolationEnabled) {
+      continue
+    }
+
+    // Then add retries right after it
+    let retriedTests = []
+    let retryMessage = ''
+    if (isAtemptToFix) {
+      test._ddIsAttemptToFix = true
+      retryMessage = 'because it is an attempt to fix'
+      retriedTests = getRetriedTests(test, testManagementAttemptToFixRetries, ['_ddIsAttemptToFix'])
+    } else if (isModified && isEarlyFlakeDetectionEnabled) {
+      retryMessage = 'to detect flakes because it is modified'
+      retriedTests = getRetriedTests(test, earlyFlakeDetectionNumRetries, [
+        '_ddIsModified',
+        '_ddIsEfdRetry',
+        isKnownTestsEnabled && isNewTest(test) && '_ddIsNew',
+      ])
+    } else if (isNew && isEarlyFlakeDetectionEnabled) {
+      retryMessage = 'to detect flakes because it is new'
+      retriedTests = getRetriedTests(test, earlyFlakeDetectionNumRetries, ['_ddIsNew', '_ddIsEfdRetry'])
+    }
+
+    testsWithRetries.push(...retriedTests)
+
+    if (retryMessage) {
+      retryReasonsByTestName.set(testName, retryMessage)
+    }
+  }
+
+  suite.tests = testsWithRetries
+
+  return oldRunTests.apply(this, [suite, fn])
+}
+
+beforeEach(function () {
+  const testName = Cypress.mocha.getRunner().suite.ctx.currentTest.fullTitle()
+
+  const retryMessage = retryReasonsByTestName.get(testName)
+  if (retryMessage) {
+    cy.task(
+      'dd:log',
+      `Retrying "${testName}" ${retryMessage}`
+    )
+    retryReasonsByTestName.delete(testName)
+  }
+
+  cy.on('window:load', (win) => {
+    originalWindow = win
+  })
+
+  cy.task('dd:beforeEach', {
+    testName,
+    testSuite: Cypress.mocha.getRootSuite().file,
+  }).then(({ traceId, shouldSkip }) => {
+    if (traceId) {
+      cy.setCookie(DD_CIVISIBILITY_TEST_EXECUTION_ID_COOKIE_NAME, traceId).then(() => {
+        // When testIsolation:false, the page is not reset between tests, so the RUM session
+        // stopped in afterEach must be explicitly restarted so events in this test are
+        // associated with the new testExecutionId.
+        //
+        // After stopSession(), the RUM SDK creates a new session upon a user interaction
+        // (click, scroll, keydown, or touchstart). We dispatch a synthetic click on the window
+        // to trigger session renewal, then call startView() to establish a view boundary.
+        if (!isTestIsolationEnabled && originalWindow) {
+          const rum = safeGetRum(originalWindow)
+          if (rum) {
+            try {
+              const evt = new originalWindow.MouseEvent('click', { bubbles: true, cancelable: true })
+              // The browser-sdk addEventListener wrapper filters out untrusted synthetic events
+              // unless __ddIsTrusted is set. Set it so the click triggers expandOrRenewSession().
+              // See: https://github.com/DataDog/browser-sdk/blob/v6.27.1/packages/core/src/browser/addEventListener.ts#L119
+              Object.defineProperty(evt, '__ddIsTrusted', { value: true })
+              originalWindow.dispatchEvent(evt)
+            } catch {}
+            if (rum.startView) {
+              rum.startView()
+            }
+          }
+        }
+      })
+    }
+    if (shouldSkip) {
+      this.skip()
+    }
+  })
+})
+
+before(function () {
+  cy.task('dd:testSuiteStart', {
+    testSuite: Cypress.mocha.getRootSuite().file,
+    testSuiteAbsolutePath: Cypress.spec && Cypress.spec.absolute,
+  }).then((suiteConfig) => {
+    if (suiteConfig) {
+      isEarlyFlakeDetectionEnabled = suiteConfig.isEarlyFlakeDetectionEnabled
+      isKnownTestsEnabled = suiteConfig.isKnownTestsEnabled
+      knownTestsForSuite = suiteConfig.knownTestsForSuite
+      earlyFlakeDetectionNumRetries = suiteConfig.earlyFlakeDetectionNumRetries
+      isTestManagementEnabled = suiteConfig.isTestManagementEnabled
+      testManagementAttemptToFixRetries = suiteConfig.testManagementAttemptToFixRetries
+      testManagementTests = suiteConfig.testManagementTests
+      isImpactedTestsEnabled = suiteConfig.isImpactedTestsEnabled
+      isModifiedTest = suiteConfig.isModifiedTest
+      isTestIsolationEnabled = suiteConfig.isTestIsolationEnabled
+      if (Number.isFinite(suiteConfig.rumFlushWaitMillis)) {
+        rumFlushWaitMillis = suiteConfig.rumFlushWaitMillis
+      }
+    }
+  })
+})
+
+after(() => {
+  try {
+    if (safeGetRum(originalWindow)) {
+      originalWindow.dispatchEvent(new Event('beforeunload'))
+    }
+  } catch {
+    // ignore error. It's usually a multi origin issue.
+  }
+})
+
+afterEach(function () {
+  const currentTest = Cypress.mocha.getRunner().suite.ctx.currentTest
+  const testName = currentTest.fullTitle()
+
+  // Check if this was a quarantined test that we suppressed the failure for
+  const quarantinedError = quarantinedTestErrors.get(testName)
+  const isQuarantinedTestThatFailed = !!quarantinedError
+
+  // For quarantined tests, convert Error to a serializable format for cy.task
+  const errorToReport = isQuarantinedTestThatFailed
+    ? { message: quarantinedError.message, stack: quarantinedError.stack }
+    : currentTest.err
+
+  const testInfo = {
+    testName,
+    testItTitle: currentTest.title,
+    testSuite: Cypress.mocha.getRootSuite().file,
+    testSuiteAbsolutePath: Cypress.spec && Cypress.spec.absolute,
+    // For quarantined tests, report the actual state (failed) to Datadog, not what Cypress thinks (passed)
+    state: isQuarantinedTestThatFailed ? 'failed' : currentTest.state,
+    // For quarantined tests, include the actual error that was suppressed
+    error: errorToReport,
+    isNew: currentTest._ddIsNew,
+    isEfdRetry: currentTest._ddIsEfdRetry,
+    isAttemptToFix: currentTest._ddIsAttemptToFix,
+    isModified: currentTest._ddIsModified,
+    // Mark quarantined tests that failed so the plugin knows to tag them appropriately
+    isQuarantined: isQuarantinedTestThatFailed,
+  }
+  try {
+    const invocationDetails = Cypress.mocha.getRunner().currentRunnable.invocationDetails
+    testInfo.testSourceLine = invocationDetails.line
+    testInfo.testSourceStack = invocationDetails.stack
+  } catch {}
+
+  const rum = safeGetRum(originalWindow)
+  if (rum) {
+    testInfo.isRUMActive = true
+    if (rum.stopSession) {
+      rum.stopSession()
+      // eslint-disable-next-line cypress/no-unnecessary-waiting
+      cy.wait(rumFlushWaitMillis)
+    }
+  }
+  let coverage
+  try {
+    coverage = originalWindow.__coverage__
+  } catch {
+    // ignore error and continue
+  }
+
+  // Clean up the quarantined error tracking
+  if (isQuarantinedTestThatFailed) {
+    quarantinedTestErrors.delete(testName)
+  }
+
+  cy.task('dd:afterEach', { test: testInfo, coverage })
+})