dd-trace 5.88.0 → 5.89.0

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

@@ -69,7 +69,9 @@ const RETRY_TIMES = Symbol.for('RETRY_TIMES')
 let skippableSuites = []
 let knownTests = {}
 let isCodeCoverageEnabled = false
+let isCodeCoverageEnabledBecauseOfUs = false
 let isSuitesSkippingEnabled = false
+let isKeepingCoverageConfiguration = false
 let isUserCodeCoverageEnabled = false
 let isSuitesSkipped = false
 let numSkippedSuites = 0
@@ -994,6 +996,8 @@ function getCliWrapper (isNewJestVersion) {
         if (!err) {
           isCodeCoverageEnabled = libraryConfig.isCodeCoverageEnabled
           isSuitesSkippingEnabled = libraryConfig.isSuitesSkippingEnabled
+          isKeepingCoverageConfiguration =
+            libraryConfig.isKeepingCoverageConfiguration ?? isKeepingCoverageConfiguration
           isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
           earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
           earlyFlakeDetectionSlowTestRetries = libraryConfig.earlyFlakeDetectionSlowTestRetries ?? {}
@@ -1327,9 +1331,10 @@ function coverageReporterWrapper (coverageReporter) {
    */
   // `_addUntestedFiles` is an async function
   shimmer.wrap(CoverageReporter.prototype, '_addUntestedFiles', addUntestedFiles => function () {
-    // If the user has added coverage manually, they're willing to pay the price of this execution, so
-    // we will not skip it.
-    if (isSuitesSkippingEnabled && !isUserCodeCoverageEnabled) {
+    if (isKeepingCoverageConfiguration) {
+      return addUntestedFiles.apply(this, arguments)
+    }
+    if (isCodeCoverageEnabledBecauseOfUs) {
       return Promise.resolve()
     }
     return addUntestedFiles.apply(this, arguments)
@@ -1509,12 +1514,13 @@ function configureTestEnvironment (readConfigsResult) {
   }
 
   isUserCodeCoverageEnabled = !!readConfigsResult.globalConfig.collectCoverage
+  isCodeCoverageEnabledBecauseOfUs = isCodeCoverageEnabled && !isUserCodeCoverageEnabled
 
   if (readConfigsResult.globalConfig.forceExit) {
     log.warn("Jest's '--forceExit' flag has been passed. This may cause loss of data.")
   }
 
-  if (isCodeCoverageEnabled) {
+  if (isCodeCoverageEnabledBecauseOfUs) {
     const globalConfig = {
       ...readConfigsResult.globalConfig,
       collectCoverage: true,
@@ -1522,14 +1528,18 @@ function configureTestEnvironment (readConfigsResult) {
     readConfigsResult.globalConfig = globalConfig
   }
   if (isSuitesSkippingEnabled) {
-    // If suite skipping is enabled, the code coverage results are not going to be relevant,
-    // so we do not show them.
-    // Also, we might skip every test, so we need to pass `passWithNoTests`
+    // If suite skipping is enabled, we pass `passWithNoTests` in case every test gets skipped.
     const globalConfig = {
       ...readConfigsResult.globalConfig,
-      coverageReporters: ['none'],
       passWithNoTests: true,
     }
+    if (isCodeCoverageEnabledBecauseOfUs && !isKeepingCoverageConfiguration) {
+      globalConfig.coverageReporters = ['none']
+      readConfigsResult.configs = configs.map(config => ({
+        ...config,
+        coverageReporters: ['none'],
+      }))
+    }
     readConfigsResult.globalConfig = globalConfig
   }
 
@@ -1552,49 +1562,97 @@ function jestConfigSyncWrapper (jestConfig) {
   })
 }
 
+const DD_TEST_ENVIRONMENT_OPTION_KEYS = [
+  '_ddTestModuleId',
+  '_ddTestSessionId',
+  '_ddTestCommand',
+  '_ddTestSessionName',
+  '_ddForcedToRun',
+  '_ddUnskippable',
+  '_ddItrCorrelationId',
+  '_ddKnownTests',
+  '_ddIsEarlyFlakeDetectionEnabled',
+  '_ddEarlyFlakeDetectionSlowTestRetries',
+  '_ddRepositoryRoot',
+  '_ddIsFlakyTestRetriesEnabled',
+  '_ddFlakyTestRetriesCount',
+  '_ddIsDiEnabled',
+  '_ddIsKnownTestsEnabled',
+  '_ddIsTestManagementTestsEnabled',
+  '_ddTestManagementTests',
+  '_ddTestManagementAttemptToFixRetries',
+  '_ddModifiedFiles',
+]
+
+function removeDatadogTestEnvironmentOptions (testEnvironmentOptions) {
+  const removedEntries = []
+
+  for (const key of DD_TEST_ENVIRONMENT_OPTION_KEYS) {
+    if (!Object.hasOwn(testEnvironmentOptions, key)) {
+      continue
+    }
+
+    removedEntries.push([key, testEnvironmentOptions[key]])
+    delete testEnvironmentOptions[key]
+  }
+
+  return function restoreDatadogTestEnvironmentOptions () {
+    for (const [key, value] of removedEntries) {
+      testEnvironmentOptions[key] = value
+    }
+  }
+}
+
+/**
+ * Wrap `createScriptTransformer` to temporarily hide Datadog-specific
+ * `testEnvironmentOptions` keys while Jest builds its transform config.
+ *
+ * @param {Function} createScriptTransformer
+ * @returns {Function}
+ */
+function wrapCreateScriptTransformer (createScriptTransformer) {
+  return function (config) {
+    const testEnvironmentOptions = config?.testEnvironmentOptions
+
+    if (!testEnvironmentOptions) {
+      return createScriptTransformer.apply(this, arguments)
+    }
+
+    const restoreTestEnvironmentOptions = removeDatadogTestEnvironmentOptions(testEnvironmentOptions)
+
+    try {
+      const result = createScriptTransformer.apply(this, arguments)
+
+      if (result?.then) {
+        return result.finally(restoreTestEnvironmentOptions)
+      }
+
+      restoreTestEnvironmentOptions()
+      return result
+    } catch (e) {
+      restoreTestEnvironmentOptions()
+      throw e
+    }
+  }
+}
+
 addHook({
   name: '@jest/transform',
-  versions: ['>=24.8.0'],
+  versions: ['>=24.8.0 <30.0.0'],
   file: 'build/ScriptTransformer.js',
 }, transformPackage => {
-  const originalCreateScriptTransformer = transformPackage.createScriptTransformer
-
-  // `createScriptTransformer` is an async function
-  transformPackage.createScriptTransformer = function (config) {
-    const { testEnvironmentOptions, ...restOfConfig } = config
-    const {
-      _ddTestModuleId,
-      _ddTestSessionId,
-      _ddTestCommand,
-      _ddTestSessionName,
-      _ddForcedToRun,
-      _ddUnskippable,
-      _ddItrCorrelationId,
-      _ddKnownTests,
-      _ddIsEarlyFlakeDetectionEnabled,
-      _ddEarlyFlakeDetectionSlowTestRetries,
-      _ddRepositoryRoot,
-      _ddIsFlakyTestRetriesEnabled,
-      _ddFlakyTestRetriesCount,
-      _ddIsDiEnabled,
-      _ddIsKnownTestsEnabled,
-      _ddIsTestManagementTestsEnabled,
-      _ddTestManagementTests,
-      _ddTestManagementAttemptToFixRetries,
-      _ddModifiedFiles,
-      ...restOfTestEnvironmentOptions
-    } = testEnvironmentOptions
-
-    restOfConfig.testEnvironmentOptions = restOfTestEnvironmentOptions
-
-    arguments[0] = restOfConfig
-
-    return originalCreateScriptTransformer.apply(this, arguments)
-  }
+  transformPackage.createScriptTransformer = wrapCreateScriptTransformer(transformPackage.createScriptTransformer)
 
   return transformPackage
 })
 
+addHook({
+  name: '@jest/transform',
+  versions: ['>=30.0.0'],
+}, transformPackage => {
+  return shimmer.wrap(transformPackage, 'createScriptTransformer', wrapCreateScriptTransformer, { replaceGetter: true })
+})
+
 /**
  * Hook to remove the test paths (test suite) that are part of `skippableSuites`
  */

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

@@ -91,6 +91,11 @@ const {
   RUNTIME_VERSION,
 } = require('../../dd-trace/src/plugins/util/env')
 const { DD_MAJOR } = require('../../../version')
+const {
+  resolveOriginalSourcePosition,
+  resolveSourceLineForTest,
+  shouldTrustInvocationDetailsLine,
+} = require('./source-map-utils')
 
 const TEST_FRAMEWORK_NAME = 'cypress'
 
@@ -238,7 +243,6 @@ class CypressPlugin {
 
   finishedTestsByFile = {}
   testStatuses = {}
-
   isTestsSkipped = false
   isSuitesSkippingEnabled = false
   isCodeCoverageEnabled = false
@@ -391,7 +395,9 @@ class CypressPlugin {
     this.ciVisEvent(TELEMETRY_EVENT_CREATED, 'suite')
 
     if (testSuiteAbsolutePath) {
-      const testSourceFile = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
+      const resolvedSuitePosition = resolveOriginalSourcePosition(testSuiteAbsolutePath, 1)
+      const resolvedSuiteAbsolutePath = resolvedSuitePosition ? resolvedSuitePosition.sourceFile : testSuiteAbsolutePath
+      const testSourceFile = getTestSuitePath(resolvedSuiteAbsolutePath, this.repositoryRoot)
       testSuiteSpanMetadata[TEST_SOURCE_FILE] = testSourceFile
       testSuiteSpanMetadata[TEST_SOURCE_START] = 1
       const codeOwners = this.getTestCodeOwners({ testSuite, testSourceFile })
@@ -804,8 +810,10 @@ class CypressPlugin {
         if (this.itrCorrelationId) {
           finishedTest.testSpan.setTag(ITR_CORRELATION_ID, this.itrCorrelationId)
         }
-        const testSourceFile = spec.absolute && this.repositoryRoot
-          ? getTestSuitePath(spec.absolute, this.repositoryRoot)
+        const resolvedSpecPosition = spec.absolute ? resolveOriginalSourcePosition(spec.absolute, 1) : null
+        const resolvedSpecAbsolutePath = resolvedSpecPosition ? resolvedSpecPosition.sourceFile : spec.absolute
+        const testSourceFile = resolvedSpecAbsolutePath && this.repositoryRoot
+          ? getTestSuitePath(resolvedSpecAbsolutePath, this.repositoryRoot)
           : spec.relative
         if (testSourceFile) {
           finishedTest.testSpan.setTag(TEST_SOURCE_FILE, testSourceFile)
@@ -902,9 +910,11 @@ class CypressPlugin {
           error,
           isRUMActive,
           testSourceLine,
+          testSourceStack,
           testSuite,
           testSuiteAbsolutePath,
           testName,
+          testItTitle,
           isNew,
           isEfdRetry,
           isAttemptToFix,
@@ -946,8 +956,29 @@ class CypressPlugin {
         if (isRUMActive) {
           this.activeTestSpan.setTag(TEST_IS_RUM_ACTIVE, 'true')
         }
+        // Source-line resolution strategy:
+        // 1. If plain JS and no source map, trust invocationDetails.line directly.
+        // 2. Otherwise, try invocationDetails.stack line mapped through source map.
+        // 3. If that fails, scan generated file for it/test/specify declaration by test name.
+        // 4. If declaration found:
+        //    - .ts file: use declaration line directly.
+        //    - .js file: map declaration line through source map.
+        // 5. If all fail, keep original invocationDetails.line.
         if (testSourceLine) {
-          this.activeTestSpan.setTag(TEST_SOURCE_START, testSourceLine)
+          let resolvedLine = testSourceLine
+          if (testSuiteAbsolutePath && testItTitle) {
+            // Use invocationDetails directly only for plain JS specs without source maps.
+            // Otherwise, resolve from the test declaration in the spec and map via source map.
+            const shouldTrustInvocationDetails = shouldTrustInvocationDetailsLine(testSuiteAbsolutePath, testSourceLine)
+            if (!shouldTrustInvocationDetails) {
+              resolvedLine = resolveSourceLineForTest(
+                testSuiteAbsolutePath,
+                testItTitle,
+                testSourceStack
+              ) ?? testSourceLine
+            }
+          }
+          this.activeTestSpan.setTag(TEST_SOURCE_START, resolvedLine)
         }
         if (isNew) {
           this.activeTestSpan.setTag(TEST_IS_NEW, 'true')

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

@@ -258,6 +258,7 @@ afterEach(function () {
 
   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)
@@ -272,7 +273,9 @@ afterEach(function () {
     isQuarantined: isQuarantinedTestThatFailed,
   }
   try {
-    testInfo.testSourceLine = Cypress.mocha.getRunner().currentRunnable.invocationDetails.line
+    const invocationDetails = Cypress.mocha.getRunner().currentRunnable.invocationDetails
+    testInfo.testSourceLine = invocationDetails.line
+    testInfo.testSourceStack = invocationDetails.stack
   } catch {}
 
   const rum = safeGetRum(originalWindow)

package/packages/dd-trace/src/aiguard/sdk.js

@@ -175,7 +175,7 @@ class AIGuard extends NoopAIGuard {
           `AI Guard service call failed, status ${response.status}`,
           { errors: response.body?.errors })
       }
-      let action, reason, tags, blockingEnabled
+      let action, reason, tags, sdsFindings, blockingEnabled
       try {
         const attr = response.body.data.attributes
         if (!attr.action) {
@@ -184,6 +184,7 @@ class AIGuard extends NoopAIGuard {
         action = attr.action
         reason = attr.reason
         tags = attr.tags
+        sdsFindings = attr.sds_findings
         blockingEnabled = attr.is_blocking_enabled ?? false
       } catch (e) {
         appsecMetrics.count(AI_GUARD_TELEMETRY_REQUESTS, { error: true }).inc(1)
@@ -198,6 +199,9 @@ class AIGuard extends NoopAIGuard {
       if (tags?.length > 0) {
         metaStruct.attack_categories = tags
       }
+      if (sdsFindings?.length > 0) {
+        metaStruct.sds = sdsFindings
+      }
       if (shouldBlock) {
         span.setTag(AI_GUARD_BLOCKED_TAG_KEY, 'true')
         throw new AIGuardAbortError(reason, tags)

package/packages/dd-trace/src/ci-visibility/exporters/ci-visibility-exporter.js

@@ -234,6 +234,7 @@ class CiVisibilityExporter extends BufferingExporter {
         testManagementAttemptToFixRetries ?? this._config.testManagementAttemptToFixRetries,
       isImpactedTestsEnabled: isImpactedTestsEnabled && this._config.isImpactedTestsEnabled,
       isCoverageReportUploadEnabled,
+      isKeepingCoverageConfiguration: this._config.isKeepingCoverageConfiguration,
     }
   }
 

package/packages/dd-trace/src/config/index.js

@@ -352,6 +352,7 @@ class Config {
       DD_TELEMETRY_HEARTBEAT_INTERVAL,
       DD_TELEMETRY_LOG_COLLECTION_ENABLED,
       DD_TELEMETRY_METRICS_ENABLED,
+      DD_TEST_TIA_KEEP_COV_CONFIG,
       DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED,
       DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED,
       DD_TRACE_AGENT_PORT,
@@ -757,6 +758,7 @@ class Config {
     unprocessedTarget['telemetry.heartbeatInterval'] = DD_TELEMETRY_HEARTBEAT_INTERVAL
     setBoolean(target, 'telemetry.logCollection', DD_TELEMETRY_LOG_COLLECTION_ENABLED)
     setBoolean(target, 'telemetry.metrics', DD_TELEMETRY_METRICS_ENABLED)
+    setBoolean(target, 'isKeepingCoverageConfiguration', DD_TEST_TIA_KEEP_COV_CONFIG)
     setBoolean(target, 'traceId128BitGenerationEnabled', DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED)
     setBoolean(target, 'traceId128BitLoggingEnabled', DD_TRACE_128_BIT_TRACEID_LOGGING_ENABLED)
     warnIfPropagationStyleConflict(

package/packages/dd-trace/src/config/supported-configurations.json

@@ -1770,6 +1770,16 @@
         ]
       }
     ],
+    "DD_TEST_TIA_KEEP_COV_CONFIG": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "false",
+        "configurationNames": [
+          "isKeepingCoverageConfiguration"
+        ]
+      }
+    ],
     "DD_TEST_SESSION_NAME": [
       {
         "implementation": "A",