dd-trace 5.116.0 → 5.118.0

package/ci/test-optimization-validation/ci-command-candidate.js

@@ -1,75 +1,71 @@
 'use strict'
 
-const {
-  getCommandDetails,
-  serializeDisplayCommand,
-} = require('./command-runner')
 const { sanitizeEnv } = require('./redaction')
 
 /**
- * Builds the normalized CI command metadata shape shared by reports and UI payloads.
+ * Builds the normalized static CI configuration metadata shared by reports.
  *
  * @param {object} framework manifest framework entry
- * @returns {object|undefined} CI command candidate context when available
+ * @returns {object|undefined} CI configuration context when available
  */
 function buildCiCommandCandidate (framework) {
   const ciWiring = framework.ciWiring || {}
-  const command = framework.ciWiringCommand
-
-  if (!command && !hasCiWiringContext(ciWiring)) return
+  if (Object.keys(ciWiring).length === 0) return
 
   return removeUndefined({
-    provider: ciWiring.provider || undefined,
-    configFile: ciWiring.configFile || undefined,
-    workflow: ciWiring.workflow || undefined,
-    job: ciWiring.job || undefined,
-    step: ciWiring.step || undefined,
-    runner: ciWiring.runner || undefined,
-    shell: ciWiring.shell || undefined,
-    command: command ? serializeDisplayCommand(command) : ciWiring.command,
-    cwd: command?.cwd || ciWiring.workingDirectory,
+    provider: ciWiring.provider,
+    configFile: ciWiring.configFile,
+    workflow: ciWiring.workflow,
+    job: ciWiring.job,
+    step: ciWiring.step,
+    runner: ciWiring.runner,
+    shell: ciWiring.shell,
+    command: typeof ciWiring.command === 'string' ? ciWiring.command : undefined,
+    cwd: ciWiring.workingDirectory,
+    terminalTestCommand: ciWiring.terminalTestCommand,
     whySelected: ciWiring.whySelected || ciWiring.selectionReason || ciWiring.diagnosis,
-    replayability: ciWiring.replayability,
-    replayBlocker: ciWiring.replayBlocker,
     initialization: ciWiring.initialization,
-    env: buildCiEnvSummary(ciWiring, command),
+    transport: ciWiring.transport,
+    env: buildCiEnvSummary(ciWiring),
     packageScriptExpansionChain: getFirstArray(
       ciWiring.packageScriptExpansionChain,
       ciWiring.scriptExpansionChain,
       ciWiring.commandExpansion
     ),
     runnerToolChain: getFirstArray(
+      ciWiring.wrapperChain,
       ciWiring.runnerToolChain,
       ciWiring.toolChain,
       ciWiring.commandChain
     ),
     setupCommandIds: ciWiring.setupCommandIds,
     unresolved: ciWiring.unresolved,
-    commandDetails: command && getCommandDetails(command),
   })
 }
 
-function buildCiEnvSummary (ciWiring, command) {
+function buildCiEnvSummary (ciWiring) {
   const summary = removeUndefined({
     workflow: sanitizeEnv(ciWiring.workflowEnv || ciWiring.env?.workflow),
     job: sanitizeEnv(ciWiring.jobEnv || ciWiring.env?.job),
-    step: sanitizeEnv(ciWiring.stepEnv || command?.env || ciWiring.env?.step),
+    step: sanitizeEnv(ciWiring.stepEnv || ciWiring.env?.step),
     inherited: sanitizeEnv(ciWiring.inheritedEnv),
   })
 
   return Object.keys(summary).length > 0 ? summary : undefined
 }
 
-function hasCiWiringContext (ciWiring) {
-  return Object.keys(ciWiring).length > 0
-}
-
 function getFirstArray (...values) {
   for (const value of values) {
-    if (Array.isArray(value) && value.length > 0) return value
+    if (Array.isArray(value) && value.length > 0) return value.map(formatChainEntry)
   }
 }
 
+function formatChainEntry (entry) {
+  if (typeof entry === 'string') return entry
+  if (!entry || typeof entry !== 'object') return String(entry)
+  return entry.source ? `${entry.source}: ${entry.command}` : entry.command
+}
+
 function removeUndefined (object) {
   const result = {}
   for (const [key, value] of Object.entries(object)) {
@@ -78,6 +74,4 @@ function removeUndefined (object) {
   return result
 }
 
-module.exports = {
-  buildCiCommandCandidate,
-}
+module.exports = { buildCiCommandCandidate }

package/ci/test-optimization-validation/ci-discovery.js

@@ -86,7 +86,7 @@ function getFrameworkCiDiscoveryContradiction (framework, manifest) {
     reason: 'CI workflow files were found by validator static diagnosis, but this manifest entry says no CI ' +
       'workflow was found. The manifest cannot support a "no CI workflow found" conclusion.',
     recommendation: 'Inspect the discovered CI files with hidden-directory-aware discovery, then update ciWiring, ' +
-      'ciWiringCommand, omittedTestCommands, notes, or unresolved blockers before rerunning live validation.',
+      'ciWiring configuration evidence, omittedTestCommands, notes, or unresolved blockers before validation.',
     ciDiscovery,
   }
 }

package/ci/test-optimization-validation/ci-package-scripts.js

@@ -0,0 +1,141 @@
+'use strict'
+
+const { parseLiteralEnvironmentPrefix } = require('./literal-environment')
+
+const MAX_SCRIPT_EXPANSIONS = 16
+const DYNAMIC_VALUE_PATTERN = /[$`]|\r|\n|%[^%\s]+%|![^!\s]+!/
+
+/**
+ * Expands bounded local package-script references without executing them.
+ *
+ * @param {string} command selected CI command
+ * @param {Record<string, string>} scripts package.json scripts
+ * @returns {{error?: string, lifecycleScripts: string[], terminals: object[]}} expansion
+ */
+function expandLocalPackageScripts (command, scripts) {
+  const state = { count: 0, lifecycleScripts: new Set() }
+  const result = expandCommand(command, scripts || {}, [], new Set(), state)
+  return {
+    ...(result.error ? { error: result.error } : {}),
+    lifecycleScripts: [...state.lifecycleScripts],
+    terminals: result.terminals || [],
+  }
+}
+
+function expandCommand (command, scripts, path, stack, state) {
+  if (++state.count > MAX_SCRIPT_EXPANSIONS) {
+    return { error: `local package-script expansion exceeded ${MAX_SCRIPT_EXPANSIONS} commands` }
+  }
+  const segments = splitLiteralAndChain(command)
+  if (!segments) return { error: 'the command contains unsupported dynamic shell syntax' }
+
+  const terminals = []
+  for (const segment of segments) {
+    if (hasStatefulShellSemantics(segment)) {
+      return { error: 'the command contains unsupported stateful shell semantics' }
+    }
+    const invocation = getPackageScriptInvocation(segment)
+    if (!invocation) {
+      terminals.push({ command: segment, path: [...path, segment] })
+      continue
+    }
+    if (typeof scripts[invocation.script] !== 'string') {
+      return { error: `local package script ${invocation.script} is unavailable` }
+    }
+    if (stack.has(invocation.script)) {
+      return { error: `local package-script cycle includes ${invocation.script}` }
+    }
+    const lifecycleNames = invocation.manager === 'npm'
+      ? [`pre${invocation.script}`, `post${invocation.script}`]
+          .filter(name => typeof scripts[name] === 'string')
+      : []
+    for (const lifecycle of lifecycleNames) state.lifecycleScripts.add(lifecycle)
+
+    for (const scriptName of [
+      ...(lifecycleNames.includes(`pre${invocation.script}`) ? [`pre${invocation.script}`] : []),
+      invocation.script,
+      ...(lifecycleNames.includes(`post${invocation.script}`) ? [`post${invocation.script}`] : []),
+    ]) {
+      if (stack.has(scriptName)) return { error: `local package-script cycle includes ${scriptName}` }
+      const nextStack = new Set(stack)
+      nextStack.add(invocation.script)
+      nextStack.add(scriptName)
+      const expanded = expandCommand(
+        scripts[scriptName],
+        scripts,
+        [...path, segment],
+        nextStack,
+        state
+      )
+      if (expanded.error) return expanded
+      terminals.push(...expanded.terminals)
+    }
+  }
+  return { terminals }
+}
+
+/**
+ * Splits only literal `&&` chains and rejects other shell control flow or expansion.
+ *
+ * @param {string} command command text
+ * @returns {string[]|undefined} literal command segments
+ */
+function splitLiteralAndChain (command) {
+  const source = String(command || '').trim()
+  if (!source || DYNAMIC_VALUE_PATTERN.test(source)) return
+  const segments = []
+  let quote
+  let start = 0
+
+  for (let index = 0; index < source.length; index++) {
+    const character = source[index]
+    if (character === '\\') {
+      index++
+      continue
+    }
+    if (quote) {
+      if (character === quote) quote = undefined
+      continue
+    }
+    if (character === '"' || character === "'") {
+      quote = character
+      continue
+    }
+    if (character === '&' && source[index + 1] === '&') {
+      const segment = source.slice(start, index).trim()
+      if (!segment) return
+      segments.push(segment)
+      start = ++index + 1
+      continue
+    }
+    if (';&|()'.includes(character)) return
+  }
+  if (quote) return
+  const finalSegment = source.slice(start).trim()
+  if (!finalSegment) return
+  segments.push(finalSegment)
+  return segments
+}
+
+function hasStatefulShellSemantics (command) {
+  const prefix = parseLiteralEnvironmentPrefix(command)
+  const executable = command.slice(prefix.length).trim()
+  return !executable ||
+    /^(?:cd|eval|exec|export|popd|pushd|set|source|unset)\b/.test(executable) ||
+    /^\.(?:\s|$)/.test(executable)
+}
+
+function getPackageScriptInvocation (command) {
+  const literalPrefix = parseLiteralEnvironmentPrefix(command)
+  const source = command.slice(literalPrefix.length).trim()
+    .replace(/^(?:c8|nyc)(?:\.cmd)?\s+/, '')
+  const match = /^(npm(?:\.cmd)?|pnpm(?:\.cmd)?|yarn(?:pkg)?(?:\.cmd)?)\s+(?:(run|run-script)\s+)?([\w:-]+)$/
+    .exec(source)
+  if (!match) return
+
+  const manager = match[1].replace(/\.cmd$/i, '')
+  if (manager === 'npm' && !match[2] && !['restart', 'start', 'stop', 'test'].includes(match[3])) return
+  return { manager, script: match[3] }
+}
+
+module.exports = { expandLocalPackageScripts }

package/ci/test-optimization-validation/ci-remediation.js

@@ -2,7 +2,9 @@
 
 const path = require('node:path')
 
-const { serializeDisplayCommand } = require('./command-runner')
+const { findEnvironmentEntry } = require('./environment')
+const { splitNodeOptions } = require('./executable')
+const { removeEmptyLiteralEnvironmentAssignments } = require('./literal-environment')
 
 const GITHUB_API_KEY_REFERENCE = '$' + '{{ secrets.DD_API_KEY }}'
 const AGENTLESS_ENV = {
@@ -31,7 +33,7 @@ function buildCiRemediation (framework) {
   const location = getCiLocation(ciWiring)
   const nodeOptions = getNodeOptions(framework)
   const recommendedValues = getRecommendedValues(framework)
-  const variants = getVariants(transport, ciWiring, framework.ciWiringCommand, recommendedValues, nodeOptions)
+  const variants = getVariants(transport, ciWiring, recommendedValues, nodeOptions)
 
   return {
     provider: ciWiring.provider || 'unknown',
@@ -47,25 +49,8 @@ function buildCiRemediation (framework) {
 }
 
 function getConfiguredTransport (framework) {
-  const env = collectCiEnv(framework)
-  if (isTrue(env.DD_CIVISIBILITY_AGENTLESS_ENABLED)) return 'agentless'
-  if (env.DD_AGENT_HOST || env.DD_TRACE_AGENT_URL || env.DD_TRACE_AGENT_HOSTNAME) return 'agent'
-  return 'unknown'
-}
-
-function collectCiEnv (framework) {
-  const ciWiring = framework.ciWiring || {}
-  return {
-    ...ciWiring.workflowEnv,
-    ...ciWiring.jobEnv,
-    ...ciWiring.stepEnv,
-    ...ciWiring.inheritedEnv,
-    ...framework.ciWiringCommand?.env,
-  }
-}
-
-function isTrue (value) {
-  return ['1', 'true'].includes(String(value || '').toLowerCase())
+  const mode = framework.ciWiring?.transport?.mode
+  return ['agentless', 'agent', 'none'].includes(mode) ? mode : 'unknown'
 }
 
 function getCiLocation (ciWiring) {
@@ -106,12 +91,12 @@ function getAgentAlternative () {
     'DD_CIVISIBILITY_AGENTLESS_ENABLED.'
 }
 
-function getVariants (transport, ciWiring, command, recommendedValues, nodeOptions) {
-  if (transport === 'agent') return [getVariant('agent', ciWiring, command, recommendedValues, nodeOptions)]
-  return [getVariant('agentless', ciWiring, command, recommendedValues, nodeOptions)]
+function getVariants (transport, ciWiring, recommendedValues, nodeOptions) {
+  if (transport === 'agent') return [getVariant('agent', ciWiring, recommendedValues, nodeOptions)]
+  return [getVariant('agentless', ciWiring, recommendedValues, nodeOptions)]
 }
 
-function getVariant (transport, ciWiring, command, recommendedValues, nodeOptions) {
+function getVariant (transport, ciWiring, recommendedValues, nodeOptions) {
   const transportEnv = transport === 'agentless' ? AGENTLESS_ENV : {}
   const requiredEnv = { NODE_OPTIONS: nodeOptions, ...transportEnv }
   const recommendedEnv = Object.fromEntries(recommendedValues.map(({ name, value }) => [name, value]))
@@ -128,13 +113,77 @@ function getVariant (transport, ciWiring, command, recommendedValues, nodeOption
     })),
     recommendedValues,
     optionalValues: OPTIONAL_VALUES[transport],
-    snippet: formatSnippet({ ...requiredEnv, ...recommendedEnv }, ciWiring, command),
+    snippet: formatSnippet({ ...requiredEnv, ...recommendedEnv }, ciWiring),
   }
 }
 
 function getNodeOptions (framework) {
-  if (framework.framework === 'vitest') return '--import dd-trace/register.js -r dd-trace/ci/init'
-  return '-r dd-trace/ci/init'
+  const existing = getEffectiveNodeOptions(framework.ciWiring)
+  const options = existing ? [existing] : []
+  if (framework.framework === 'vitest' &&
+    !hasNodeModuleOption(existing, ['--import'], isDatadogRegisterSpecifier)) {
+    options.push('--import dd-trace/register.js')
+  }
+  if (!hasNodeModuleOption(existing, ['-r', '--require'], isDatadogCiInitSpecifier)) {
+    options.push('-r dd-trace/ci/init')
+  }
+  return options.join(' ')
+}
+
+function getEffectiveNodeOptions (ciWiring = {}) {
+  const platform = getCiPlatform(ciWiring)
+  let value
+  for (const field of ['inheritedEnv', 'workflowEnv', 'jobEnv', 'stepEnv']) {
+    const entry = findEnvironmentEntry(ciWiring[field], 'NODE_OPTIONS', platform)
+    if (entry) value = entry[1]
+  }
+  if (typeof value !== 'string') return ''
+  const literal = value.trim()
+  return hasDynamicEnvironmentReference(literal) ? '' : literal
+}
+
+function hasNodeModuleOption (value, optionNames, matchesSpecifier) {
+  if (!value) return false
+  let args
+  try {
+    args = splitNodeOptions(value)
+  } catch {
+    return false
+  }
+  for (let index = 0; index < args.length; index++) {
+    const argument = args[index]
+    let specifier
+    if (optionNames.includes(argument)) {
+      specifier = args[++index]
+    } else {
+      for (const optionName of optionNames) {
+        const prefix = `${optionName}=`
+        if (argument.startsWith(prefix)) specifier = argument.slice(prefix.length)
+      }
+    }
+    if (matchesSpecifier(specifier)) return true
+  }
+  return false
+}
+
+function isDatadogCiInitSpecifier (specifier) {
+  return isDatadogModuleSpecifier(specifier, 'ci/init')
+}
+
+function isDatadogRegisterSpecifier (specifier) {
+  return isDatadogModuleSpecifier(specifier, 'register')
+}
+
+function isDatadogModuleSpecifier (specifier, entrypoint) {
+  if (typeof specifier !== 'string') return false
+  const normalized = specifier.replaceAll('\\', '/')
+  return [`dd-trace/${entrypoint}`, `dd-trace/${entrypoint}.js`].some(candidate => {
+    return normalized === candidate || normalized.endsWith(`/${candidate}`)
+  })
+}
+
+function hasDynamicEnvironmentReference (value) {
+  return /(?:\$[A-Za-z_{]|\$\(|%[A-Za-z_][A-Za-z0-9_]*%)/.test(value)
 }
 
 function getRecommendedValues (framework) {
@@ -142,8 +191,7 @@ function getRecommendedValues (framework) {
   const context = [
     framework.ciWiring?.step,
     framework.ciWiring?.job,
-    framework.existingTestCommand?.description,
-    framework.ciWiringCommand?.description,
+    framework.ciWiring?.command,
   ].filter(Boolean).join(' ')
   const testKind = /\bunit\b/i.test(context)
     ? 'unit-tests'
@@ -172,17 +220,27 @@ function normalizeName (value) {
     .replaceAll(/^-|-$/g, '') || 'test'
 }
 
-function formatSnippet (env, ciWiring, command) {
+function formatSnippet (env, ciWiring) {
   if (ciWiring.provider === 'github-actions') {
-    const testCommand = getTestCommand(ciWiring, command)
-    return [
+    const testCommand = getTestCommand(ciWiring)
+    const lines = [
       ciWiring.configFile ? `# ${formatPath(ciWiring.configFile)}` : '# GitHub Actions workflow',
       ciWiring.job ? `# Job: ${ciWiring.job}` : '# Selected test job',
+    ]
+    if (!testCommand) {
+      return [
+        ...lines,
+        'env:',
+        ...Object.entries(env).map(([name, value]) => `  ${name}: ${quoteYamlValue(value)}`),
+      ].join('\n')
+    }
+    return [
+      ...lines,
       `- name: ${quoteYamlValue(ciWiring.step || 'Run tests with Datadog')}`,
       '  env:',
       ...Object.entries(env).map(([name, value]) => `    ${name}: ${quoteYamlValue(value)}`),
       '  run: |',
-      ...String(testCommand).split(/\r?\n/).map(line => `    ${line}`),
+      ...testCommand.split(/\r?\n/).map(line => `    ${line}`),
     ].join('\n')
   }
 
@@ -196,10 +254,22 @@ function quoteShellValue (value) {
   return JSON.stringify(String(value))
 }
 
-function getTestCommand (ciWiring, command) {
-  if (command) return serializeDisplayCommand(command)
-  return ciWiring.packageScriptExpansionChain?.[0] || ciWiring.runnerToolChain?.[0] ||
-    '# keep the existing test command here'
+function getTestCommand (ciWiring) {
+  if (typeof ciWiring.command === 'string' && ciWiring.command.trim()) {
+    return removeEmptyLiteralEnvironmentAssignments(
+      ciWiring.command,
+      'NODE_OPTIONS',
+      getCiPlatform(ciWiring)
+    )
+  }
+  return ciWiring.packageScriptExpansionChain?.[0] || ciWiring.runnerToolChain?.[0]
+}
+
+function getCiPlatform (ciWiring) {
+  const shellName = path.basename(String(ciWiring.shell || '')).toLowerCase()
+  return ['cmd', 'cmd.exe', 'powershell', 'powershell.exe', 'pwsh', 'pwsh.exe'].includes(shellName)
+    ? 'win32'
+    : process.platform
 }
 
 function quoteYamlValue (value) {
@@ -207,4 +277,7 @@ function quoteYamlValue (value) {
   return JSON.stringify(String(value))
 }
 
-module.exports = { buildCiRemediation }
+module.exports = {
+  buildCiRemediation,
+  getConfiguredTransport,
+}