dd-trace 5.117.0 → 5.118.0

package/ci/diagnose.js

@@ -34,6 +34,7 @@ const SKIPPED_DIRECTORIES = new Set([
   '.yarn',
   'build',
   'coverage',
+  'dd-test-optimization-validation-results',
   'dist',
   'node_modules',
   'out',
@@ -90,6 +91,14 @@ const WATCH_MODE_RE = /(?:^|\s)(?:watch|--watch|--watchAll)(?!(?:=false)(?:\s|$)
 const CYPRESS_MANUAL_PLUGIN_RE = /dd-trace\/ci\/cypress\/(?:plugin|after-run|after-spec)\b/
 const CYPRESS_SUPPORT_RE = /dd-trace\/ci\/cypress\/support\b/
 const CYPRESS_SUPPORT_DISABLED_RE = /supportFile\s*:\s*false|"supportFile"\s*:\s*false/
+const CUCUMBER_RUNNER_COMMAND_RE = new RegExp(
+  String.raw`(?:^|(?:&&|\|\||[;|])\s*)` +
+  String.raw`(?:(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s;&|]+)|` +
+  String.raw`cross-env|env|npx|nyc|c8|npm\s+exec|pnpm\s+exec|yarn\s+exec|--?[^\s;&|]+)\s+)*` +
+  String.raw`(?:(?:[^\s"';&|]+[\/\\])?(?:cucumber-js(?:\.cmd)?|cucumber(?:\.cmd)?)|` +
+  String.raw`node(?:\.exe)?\s+(?:[^\s"';&|]+[\/\\])?bin[\/\\]cucumber\.js)` +
+  String.raw`(?=$|[\s"';&|])`
+)
 const CUCUMBER_PARALLEL_RE =
   /\bcucumber(?:-js)?\b[\s\S]{0,200}\s--parallel\b|--parallel\b[\s\S]{0,200}\bcucumber(?:-js)?\b/
 const JEST_FORCE_EXIT_RE = /\bforceExit\s*:\s*true\b|--forceExit\b|"forceExit"\s*:\s*true/
@@ -123,9 +132,8 @@ function getFrameworkDefinitions (ddMajor) {
       commandPatterns: [/\bjest\b/],
       configPatterns: [/^jest\.config\./, /^config-jest\./],
       supportedRange: ddMajor >= 6 ? '>=28.0.0' : '>=24.8.0',
-      recommendation: ddMajor >= 6
-        ? 'Upgrade Jest to >=28.0.0, or use dd-trace v5 for older Jest versions.'
-        : 'Upgrade Jest to >=24.8.0.',
+      recommendation: 'Use a Jest and dd-trace combination whose documented support ranges overlap; this ' +
+        `dd-trace version requires Jest ${ddMajor >= 6 ? '>=28.0.0' : '>=24.8.0'}.`,
     },
     {
       id: 'mocha',
@@ -134,9 +142,8 @@ function getFrameworkDefinitions (ddMajor) {
       commandPatterns: [/\bmocha\b/],
       configPatterns: [/^\.mocharc\./],
       supportedRange: ddMajor >= 6 ? '>=8.0.0' : '>=5.2.0',
-      recommendation: ddMajor >= 6
-        ? 'Upgrade Mocha to >=8.0.0, or use dd-trace v5 for older Mocha versions.'
-        : 'Upgrade Mocha to >=5.2.0.',
+      recommendation: 'Use a Mocha and dd-trace combination whose documented support ranges overlap; this ' +
+        `dd-trace version requires Mocha ${ddMajor >= 6 ? '>=8.0.0' : '>=5.2.0'}.`,
       notes: [
         'Impacted tests are detected at suite level for Mocha.',
       ],
@@ -145,7 +152,7 @@ function getFrameworkDefinitions (ddMajor) {
       id: 'cucumber',
       name: 'Cucumber',
       packages: ['@cucumber/cucumber'],
-      commandPatterns: [/\bcucumber-js\b/, /\bcucumber\b/],
+      commandPatterns: [CUCUMBER_RUNNER_COMMAND_RE],
       configPatterns: [/^cucumber\./],
       supportedRange: '>=7.0.0',
       recommendation: 'Upgrade @cucumber/cucumber to >=7.0.0.',
@@ -158,9 +165,8 @@ function getFrameworkDefinitions (ddMajor) {
       configPatterns: [/^cypress\.config\./, /^cypress\.json$/],
       supportedRange: ddMajor >= 6 ? '>=12.0.0' : '>=6.7.0',
       autoInstrumentationRange: ddMajor >= 6 ? '>=12.0.0' : '>=10.2.0',
-      recommendation: ddMajor >= 6
-        ? 'Upgrade Cypress to >=12.0.0, or use dd-trace v5 for older Cypress versions.'
-        : 'Upgrade Cypress to >=6.7.0.',
+      recommendation: 'Use a Cypress and dd-trace combination whose documented support ranges overlap; this ' +
+        `dd-trace version requires Cypress ${ddMajor >= 6 ? '>=12.0.0' : '>=6.7.0'}.`,
     },
     {
       id: 'playwright',
@@ -169,9 +175,8 @@ function getFrameworkDefinitions (ddMajor) {
       commandPatterns: [/\bplaywright\s+test\b/],
       configPatterns: [/^playwright\.config\./],
       supportedRange: ddMajor >= 6 ? '>=1.38.0' : '>=1.18.0',
-      recommendation: ddMajor >= 6
-        ? 'Upgrade Playwright to >=1.38.0, or use dd-trace v5 for older Playwright versions.'
-        : 'Upgrade Playwright to >=1.18.0.',
+      recommendation: 'Use a Playwright and dd-trace combination whose documented support ranges overlap; this ' +
+        `dd-trace version requires Playwright ${ddMajor >= 6 ? '>=1.38.0' : '>=1.18.0'}.`,
       notes: [
         'Test Impact Analysis suite skipping is not supported for Playwright.',
         'Impacted tests are detected at suite level for Playwright.',
@@ -199,7 +204,7 @@ const UNSUPPORTED_FRAMEWORKS = [
     id: 'node-test',
     name: 'Node.js test runner',
     packages: [],
-    commandPatterns: [/\bnode\s+--test\b/, /\bnode\s+--experimental-test-coverage\b/],
+    commandPatterns: [/\bnode\s+--test\b/, /\bnode\s+--experimental-test-coverage\b/, /\bbnt\b/],
   },
   { id: 'ava', name: 'AVA', packages: ['ava'], commandPatterns: [/\bava\b/] },
   { id: 'tap', name: 'tap', packages: ['tap'], commandPatterns: [/\btap\b/] },
@@ -1106,9 +1111,13 @@ function collectScripts (manifests) {
  */
 function detectSupportedFrameworks (root, definitions, manifests, scripts, textFiles) {
   const frameworks = []
+  const projectPreferenceScores = getProjectPreferenceScores(root, manifests)
 
   for (const definition of definitions) {
-    const dependencyEntries = findDependencyEntries(manifests, definition.packages)
+    const dependencyEntries = [
+      ...findDependencyEntries(manifests, definition.packages),
+      ...findPackageIdentityEntries(manifests, definition.packages),
+    ]
     const scriptMatches = findScriptMatches(scripts, definition.commandPatterns)
     const configMatches = findConfigMatches(textFiles, definition.configPatterns)
 
@@ -1119,6 +1128,7 @@ function detectSupportedFrameworks (root, definitions, manifests, scripts, textF
       dependencyEntries,
       scriptMatches,
       configMatches,
+      projectPreferenceScores,
       locations: unique([
         ...dependencyEntries.map(entry => entry.relativePath),
         ...scriptMatches.map(script => script.relativePath),
@@ -1193,23 +1203,117 @@ function getSupportedVersionDetection (framework, relativePath) {
  * @returns {object|undefined} eligible command match
  */
 function getEligibleCommandMatch (framework) {
-  const scriptMatches = framework.scriptMatches || []
+  const scriptMatches = [...(framework.scriptMatches || [])].sort((left, right) => {
+    return compareProjectScope(left, right, framework.projectPreferenceScores) ||
+      getFrameworkCommandPreference(framework.id, left) - getFrameworkCommandPreference(framework.id, right) ||
+      left.relativePath.localeCompare(right.relativePath)
+  })
 
   for (const script of scriptMatches) {
     if (isIneligibleFrameworkCommand(framework.id, script.command)) continue
     return script
   }
 
-  if (scriptMatches.length > 0) return
-
-  if (framework.id === 'jest' || framework.id === 'mocha' || framework.id === 'vitest') {
-    return framework.dependencyEntries?.[0] && {
+  if (framework.id === 'cucumber' || framework.id === 'cypress' || framework.id === 'jest' ||
+    framework.id === 'mocha' || framework.id === 'playwright' || framework.id === 'vitest') {
+    const dependencyEntries = [...(framework.dependencyEntries || [])].sort((left, right) => {
+      return compareProjectPreference(left, right, framework.projectPreferenceScores)
+    })
+    return dependencyEntries[0] && {
       command: `direct ${framework.id} binary`,
-      relativePath: framework.dependencyEntries[0].relativePath,
+      relativePath: dependencyEntries[0].relativePath,
     }
   }
 }
 
+/**
+ * Prefers direct, single-stage framework scripts over aggregate coverage or setup chains.
+ *
+ * @param {string} frameworkId framework id
+ * @param {object} script package script
+ * @returns {number} lower is preferred
+ */
+function getFrameworkCommandPreference (frameworkId, script) {
+  let score = 0
+  if (/coverage|all|full/i.test(script.name)) score += 4
+  if (/[\r\n;&|`]|\$\(/.test(script.command)) score += 4
+  const invokesFramework = frameworkId === 'cucumber'
+    ? isCucumberRunnerCommand(script.command)
+    : script.command.toLowerCase().includes(frameworkId.toLowerCase())
+  if (invokesFramework) score--
+  return score
+}
+
+/**
+ * Scores package manifests by how closely their names match the repository directory name.
+ *
+ * @param {string} root repository root
+ * @param {Array<object>} manifests package manifests
+ * @returns {Map<string, number>} preference score by package.json path
+ */
+function getProjectPreferenceScores (root, manifests) {
+  const repositoryTokens = getIdentityTokens(path.basename(root))
+  const scores = new Map()
+
+  for (const manifest of manifests) {
+    const projectName = manifest.json.name || (manifest.relativePath === 'package.json'
+      ? path.basename(root)
+      : path.basename(path.dirname(manifest.relativePath)))
+    const projectTokens = getIdentityTokens(projectName)
+    let score = 0
+    for (const token of projectTokens) {
+      if (repositoryTokens.has(token)) score++
+    }
+    scores.set(manifest.relativePath, score)
+  }
+
+  return scores
+}
+
+/**
+ * Normalizes repository and package names for conservative identity comparison.
+ *
+ * @param {string} value repository or package name
+ * @returns {Set<string>} normalized identity tokens
+ */
+function getIdentityTokens (value) {
+  const tokens = String(value || '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean)
+  const normalized = new Set()
+  for (const token of tokens) {
+    if (['monorepo', 'package', 'packages', 'project', 'repo', 'root', 'workspace'].includes(token)) continue
+    normalized.add(token.endsWith('js') && token.length > 2 ? token.slice(0, -2) : token)
+  }
+  return normalized
+}
+
+/**
+ * Orders command owners by repository identity, then by scope and stable path.
+ *
+ * @param {object} left first command or dependency entry
+ * @param {object} right second command or dependency entry
+ * @param {Map<string, number>|undefined} scores package preference scores
+ * @returns {number} sort order
+ */
+function compareProjectPreference (left, right, scores) {
+  return compareProjectScope(left, right, scores) ||
+    left.relativePath.localeCompare(right.relativePath)
+}
+
+/**
+ * Orders command owners by repository identity and package depth.
+ *
+ * @param {object} left first command or dependency entry
+ * @param {object} right second command or dependency entry
+ * @param {Map<string, number>|undefined} scores package preference scores
+ * @returns {number} sort order before stable path tie-breaking
+ */
+function compareProjectScope (left, right, scores) {
+  const scoreDifference = (scores?.get(right.relativePath) || 0) - (scores?.get(left.relativePath) || 0)
+  if (scoreDifference !== 0) return scoreDifference
+
+  return left.relativePath.split('/').length - right.relativePath.split('/').length
+}
+
 /**
  * Checks whether a framework command is ineligible for live validation.
  *
@@ -1218,12 +1322,23 @@ function getEligibleCommandMatch (framework) {
  * @returns {boolean} whether the command is ineligible
  */
 function isIneligibleFrameworkCommand (frameworkId, command) {
+  if (frameworkId === 'cucumber' && !isCucumberRunnerCommand(command)) return true
   if (frameworkId === 'vitest' && /\bvitest\s+bench\b/.test(command)) return true
   if (WATCH_MODE_RE.test(command)) return true
 
   return false
 }
 
+/**
+ * Checks whether a package command invokes the Cucumber runner instead of merely naming a Cucumber config file.
+ *
+ * @param {string} command package script command
+ * @returns {boolean} whether the command invokes Cucumber
+ */
+function isCucumberRunnerCommand (command) {
+  return CUCUMBER_RUNNER_COMMAND_RE.test(String(command || ''))
+}
+
 /**
  * Detects unsupported test frameworks.
  *
@@ -1317,6 +1432,28 @@ function findDependencyEntries (manifests, packageNames) {
   return entries
 }
 
+/**
+ * Treats a repository containing a framework's own package as a local version source.
+ *
+ * @param {Array<object>} manifests package manifests
+ * @param {string[]} packageNames framework package names
+ * @returns {Array<object>} local package identities
+ */
+function findPackageIdentityEntries (manifests, packageNames) {
+  const packageSet = new Set(packageNames)
+  const entries = []
+  for (const manifest of manifests) {
+    if (!packageSet.has(manifest.json.name) || typeof manifest.json.version !== 'string') continue
+    entries.push({
+      packageName: manifest.json.name,
+      rawVersion: manifest.json.version,
+      section: 'package',
+      relativePath: manifest.relativePath,
+    })
+  }
+  return entries
+}
+
 /**
  * Resolves framework package versions from installed modules and manifest ranges.
  *
@@ -2011,6 +2148,8 @@ function formatLocations (locations) {
  * @returns {object} serializable framework summary
  */
 function serializeSupportedFramework (framework) {
+  const eligibleCommand = getEligibleCommandMatch(framework)
+  const supportedVersion = getSupportedVersionDetection(framework, eligibleCommand?.relativePath)
   return {
     id: framework.id,
     name: framework.name,
@@ -2018,6 +2157,8 @@ function serializeSupportedFramework (framework) {
     supportedRange: framework.supportedRange,
     locations: framework.locations,
     versionDetections: framework.versionDetections,
+    eligibleCommand,
+    supportedVersion,
   }
 }
 

package/ci/init.js

@@ -75,7 +75,6 @@ if (isTestWorker) {
     exporter: EXPORTER_MAP[testWorkerType],
   }
 } else if (isValidationMode) {
-  baseOptions.telemetry = { enabled: false }
   baseOptions.experimental = {
     exporter: 'ci_validation',
   }