dd-trace 6.4.0 → 6.6.0

package/ci/test-optimization-validation/generated-files.js

@@ -0,0 +1,351 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+
+const {
+  MAX_GENERATED_FILES,
+  getGeneratedFileContentError,
+} = require('./generated-file-policy')
+const { createFileSafely, ensureSafeDirectory } = require('./safe-files')
+
+const RUNTIME_FILE_NAMESPACE = 'dd-test-optimization-validation'
+const createdGeneratedDirectories = new Map()
+const initializedCleanupStrategies = new WeakSet()
+const authorizedRuntimeCleanupFiles = new Map()
+const writtenGeneratedFiles = new Map()
+
+function writeGeneratedFiles (framework) {
+  const strategy = framework.generatedTestStrategy
+  if (!strategy || !['planned', 'verified'].includes(strategy.status)) {
+    return []
+  }
+  if ((strategy.files || []).length > MAX_GENERATED_FILES) {
+    throw new Error(`Generated validation strategy must contain at most ${MAX_GENERATED_FILES} files.`)
+  }
+  initializeRuntimeCleanupFiles(framework, strategy)
+
+  const written = []
+  try {
+    for (const file of strategy.files || []) {
+      const filename = validateGeneratedFilePath(framework, file.path)
+      validateContentLines(file.contentLines, filename)
+      const content = `${file.contentLines.join('\n')}\n`
+      if (fs.existsSync(filename)) {
+        if (fs.readFileSync(filename, 'utf8') === content) continue
+        throw new Error(`Refusing to overwrite existing generated validation file with different content: ${filename}`)
+      }
+
+      const directory = path.dirname(filename)
+      const missingDirectories = getMissingDirectories(framework.project.root, directory)
+      ensureSafeDirectory(framework.project.root, directory, 'generated validation file directory', {
+        allowRootSymlink: true,
+      })
+      for (const createdDirectory of missingDirectories) {
+        createdGeneratedDirectories.set(
+          createdDirectory,
+          authorizePathForCleanup(framework.project.root, createdDirectory)
+        )
+      }
+      validateGeneratedFilePath(framework, filename)
+      createFileSafely(framework.project.root, filename, content, 'generated validation file')
+      writtenGeneratedFiles.set(filename, authorizePathForCleanup(framework.project.root, filename))
+      written.push(filename)
+    }
+    pinRuntimeCleanupParents(strategy)
+  } catch (err) {
+    cleanupPaths(written)
+    cleanupCreatedDirectories(framework.project.root)
+    forgetWrittenGeneratedFiles(written)
+    throw err
+  }
+  return written
+}
+
+function cleanupGeneratedFiles (manifest, { keep = false } = {}) {
+  if (keep) return
+
+  for (const framework of manifest.frameworks || []) {
+    const strategy = framework.generatedTestStrategy
+    cleanupPaths(getSafeCleanupPaths(framework, strategy, { includeGeneratedFiles: true }))
+    cleanupCreatedDirectories(framework.project.root)
+  }
+}
+
+/**
+ * Finds missing directories that the validator will create for one generated file.
+ *
+ * @param {string} root project root
+ * @param {string} directory generated file directory
+ * @returns {string[]} missing directories, from deepest to shallowest
+ */
+function getMissingDirectories (root, directory) {
+  const missing = []
+  let current = path.resolve(directory)
+  const resolvedRoot = path.resolve(root)
+  while (current !== resolvedRoot && isPathInside(resolvedRoot, current) && !fs.existsSync(current)) {
+    missing.push(current)
+    current = path.dirname(current)
+  }
+  return missing
+}
+
+/**
+ * Removes empty generated directories created by this validator process.
+ *
+ * @param {string} root project root
+ */
+function cleanupCreatedDirectories (root) {
+  const resolvedRoot = path.resolve(root)
+  const directories = [...createdGeneratedDirectories.entries()]
+    .filter(([directory, authorization]) => {
+      return isPathInside(resolvedRoot, directory) && isCleanupAuthorizationValid(directory, authorization)
+    })
+    .sort(([left], [right]) => right.length - left.length)
+
+  for (const [directory] of directories) {
+    try {
+      fs.rmdirSync(directory)
+      createdGeneratedDirectories.delete(directory)
+    } catch (error) {
+      if (error.code === 'ENOENT') createdGeneratedDirectories.delete(directory)
+    }
+  }
+}
+
+function cleanupGeneratedRuntimeFiles (framework) {
+  const strategy = framework.generatedTestStrategy
+  if (!strategy) return
+
+  initializeRuntimeCleanupFiles(framework, strategy)
+  cleanupPaths(getSafeCleanupPaths(framework, strategy, { includeGeneratedFiles: false }))
+}
+
+function initializeRuntimeCleanupFiles (framework, strategy) {
+  if (initializedCleanupStrategies.has(strategy)) return
+
+  const generatedFiles = new Set((strategy.files || []).map(file => validateGeneratedFilePath(framework, file.path)))
+  for (const cleanupPath of strategy.cleanupPaths || []) {
+    const filename = validateCleanupPath(framework, cleanupPath)
+    if (generatedFiles.has(filename) || isDirectory(filename) || !isNamespacedRuntimeFile(filename)) continue
+    if (fs.existsSync(filename)) {
+      throw new Error(`Refusing to delete pre-existing generated validation runtime file: ${filename}`)
+    }
+    authorizedRuntimeCleanupFiles.set(filename, authorizePathForCleanup(framework.project.root, filename))
+  }
+  initializedCleanupStrategies.add(strategy)
+}
+
+function getSafeCleanupPaths (framework, strategy, { includeGeneratedFiles }) {
+  if (!strategy) return []
+
+  const generatedFiles = new Set()
+  for (const file of strategy.files || []) {
+    generatedFiles.add(validateGeneratedFilePath(framework, file.path))
+  }
+
+  const cleanupPaths = []
+  for (const cleanupPath of strategy.cleanupPaths || []) {
+    const filename = validateCleanupPath(framework, cleanupPath)
+    if (generatedFiles.has(filename)) {
+      if (includeGeneratedFiles && writtenGeneratedFiles.has(filename)) cleanupPaths.push(filename)
+      continue
+    }
+
+    if (authorizedRuntimeCleanupFiles.has(filename)) {
+      cleanupPaths.push(filename)
+    }
+  }
+
+  if (includeGeneratedFiles) {
+    for (const filename of generatedFiles) {
+      if (writtenGeneratedFiles.has(filename)) cleanupPaths.push(filename)
+    }
+  }
+  return [...new Set(cleanupPaths)]
+}
+
+function cleanupPaths (cleanupPaths) {
+  for (const cleanupPath of cleanupPaths) {
+    try {
+      const authorization = writtenGeneratedFiles.get(cleanupPath) ||
+        authorizedRuntimeCleanupFiles.get(cleanupPath)
+      if (!authorization || !isCleanupAuthorizationValid(cleanupPath, authorization)) continue
+      if (isDirectory(cleanupPath)) continue
+      fs.rmSync(cleanupPath, { force: true })
+      writtenGeneratedFiles.delete(cleanupPath)
+    } catch {
+      // Cleanup should be best-effort. The report will contain the command artifacts.
+    }
+  }
+}
+
+function forgetWrittenGeneratedFiles (filenames) {
+  for (const filename of filenames) {
+    writtenGeneratedFiles.delete(filename)
+  }
+}
+
+function authorizePathForCleanup (root, filename) {
+  const lexicalRoot = path.resolve(root)
+  const physicalRoot = fs.realpathSync(lexicalRoot)
+  const rootStat = fs.statSync(physicalRoot)
+  const authorization = {
+    lexicalRoot,
+    physicalRoot,
+    rootDevice: rootStat.dev,
+    rootInode: rootStat.ino,
+  }
+  pinCleanupParent(authorization, filename)
+  pinCleanupTarget(authorization, filename)
+  return authorization
+}
+
+function pinRuntimeCleanupParents (strategy) {
+  for (const cleanupPath of strategy.cleanupPaths || []) {
+    const authorization = authorizedRuntimeCleanupFiles.get(path.resolve(cleanupPath))
+    if (authorization && authorization.physicalParent === undefined) {
+      pinCleanupParent(authorization, cleanupPath)
+    }
+  }
+}
+
+function pinCleanupParent (authorization, filename) {
+  try {
+    const physicalParent = fs.realpathSync(path.dirname(filename))
+    if (!isPathInside(authorization.physicalRoot, physicalParent)) return
+    const parentStat = fs.statSync(physicalParent)
+    authorization.physicalParent = physicalParent
+    authorization.parentDevice = parentStat.dev
+    authorization.parentInode = parentStat.ino
+  } catch {}
+}
+
+function pinCleanupTarget (authorization, filename) {
+  try {
+    const targetStat = fs.lstatSync(filename)
+    authorization.targetDevice = targetStat.dev
+    authorization.targetInode = targetStat.ino
+  } catch {}
+}
+
+function isCleanupAuthorizationValid (filename, authorization) {
+  try {
+    const currentPhysicalRoot = fs.realpathSync(authorization.lexicalRoot)
+    const rootStat = fs.statSync(currentPhysicalRoot)
+    if (currentPhysicalRoot !== authorization.physicalRoot ||
+      rootStat.dev !== authorization.rootDevice || rootStat.ino !== authorization.rootInode) {
+      return false
+    }
+
+    if (authorization.physicalParent === undefined) return false
+    const physicalParent = fs.realpathSync(path.dirname(filename))
+    const parentStat = fs.statSync(physicalParent)
+    if (physicalParent !== authorization.physicalParent ||
+      parentStat.dev !== authorization.parentDevice || parentStat.ino !== authorization.parentInode) {
+      return false
+    }
+
+    if (authorization.targetDevice !== undefined) {
+      const targetStat = fs.lstatSync(filename)
+      if (targetStat.dev !== authorization.targetDevice || targetStat.ino !== authorization.targetInode) {
+        return false
+      }
+    }
+    return true
+  } catch {
+    return false
+  }
+}
+
+function validateGeneratedFilePath (framework, filename) {
+  return validatePathUnderProjectRoot(framework, filename, 'generated validation file')
+}
+
+function validateCleanupPath (framework, filename) {
+  return validatePathUnderProjectRoot(framework, filename, 'generated validation cleanup')
+}
+
+function validatePathUnderProjectRoot (framework, filename, label) {
+  const root = getProjectRoot(framework)
+  const resolved = path.resolve(filename || '')
+  if (!root || !isPathInside(root, resolved)) {
+    throw new Error(`Refusing ${label} path outside project root: ${filename}`)
+  }
+  validatePhysicalPath(root, resolved, label)
+  return resolved
+}
+
+/**
+ * Verifies that an existing parent resolves inside the physical project root.
+ *
+ * @param {string} root project root
+ * @param {string} filename candidate filename
+ * @param {string} label customer-facing path label
+ */
+function validatePhysicalPath (root, filename, label) {
+  const parent = path.dirname(filename)
+  let physicalRoot
+  let physicalParent
+  try {
+    physicalRoot = fs.realpathSync(root)
+    physicalParent = fs.realpathSync(parent)
+  } catch (error) {
+    if (error.code === 'ENOENT') return
+    throw error
+  }
+
+  if (!isPathInside(physicalRoot, physicalParent)) {
+    throw new Error(`Refusing ${label} path outside physical project root: ${filename}`)
+  }
+  try {
+    if (fs.lstatSync(filename).isSymbolicLink()) {
+      throw new Error(`Refusing ${label} symbolic-link target: ${filename}`)
+    }
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error
+  }
+}
+
+function getProjectRoot (framework) {
+  const root = framework.project?.root
+  return typeof root === 'string' && path.isAbsolute(root) ? path.resolve(root) : null
+}
+
+function isPathInside (root, filename) {
+  const relative = path.relative(root, filename)
+  return relative === '' || (relative && !relative.startsWith('..') && !path.isAbsolute(relative))
+}
+
+function validateContentLines (contentLines, filename) {
+  if (!Array.isArray(contentLines) || contentLines.some(line => typeof line !== 'string')) {
+    throw new Error(`Generated validation file contentLines must be an array of strings: ${filename}`)
+  }
+  const policyError = getGeneratedFileContentError(contentLines)
+  if (policyError) {
+    throw new Error(`Generated validation file ${policyError}: ${filename}`)
+  }
+}
+
+function isNamespacedRuntimeFile (filename) {
+  return path.basename(filename).includes(RUNTIME_FILE_NAMESPACE)
+}
+
+function isDirectory (filename) {
+  try {
+    return fs.statSync(filename).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+function findGeneratedScenario (framework, scenarioId) {
+  return (framework.generatedTestStrategy?.scenarios || []).find(scenario => scenario.id === scenarioId)
+}
+
+module.exports = {
+  cleanupGeneratedFiles,
+  cleanupGeneratedRuntimeFiles,
+  findGeneratedScenario,
+  writeGeneratedFiles,
+}

package/ci/test-optimization-validation/generated-verifier.js

@@ -0,0 +1,196 @@
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+const { runCommand, serializeDisplayCommand } = require('./command-runner')
+const {
+  cleanupGeneratedRuntimeFiles,
+  writeGeneratedFiles,
+} = require('./generated-files')
+const {
+  getDatadogCleanCommand,
+  getLocalValidationCommand,
+} = require('./local-command')
+const { frameworkOutDir } = require('./scenarios/helpers')
+const { getObservedTestCount } = require('./test-output')
+
+const GENERATED_SCENARIO_BY_FEATURE = {
+  efd: 'basic-pass',
+  atr: 'atr-fail-once',
+  'test-management': 'test-management-target',
+}
+
+/**
+ * Verifies generated scenario commands without Datadog initialization.
+ *
+ * @param {object} input verification inputs
+ * @param {object} input.framework manifest framework entry
+ * @param {string} input.out validation output directory
+ * @param {object} input.options validator options
+ * @returns {Promise<{ok: boolean, failure?: object}>} verification outcome
+ */
+async function verifyGeneratedTestStrategy ({ framework, out, options }) {
+  const strategy = framework.generatedTestStrategy
+  if (!strategy || !['planned', 'verified'].includes(strategy.status)) return { ok: true }
+
+  const evidence = {
+    scenarios: [],
+  }
+  const artifacts = []
+  const startedAt = Date.now()
+
+  try {
+    cleanupGeneratedRuntimeFiles(framework)
+    writeGeneratedFiles(framework)
+
+    for (const scenario of getScenariosToVerify(strategy.scenarios, options.scenarios)) {
+      cleanupGeneratedRuntimeFiles(framework)
+      const command = getDatadogCleanCommand(getLocalValidationCommand(framework, scenario.runCommand))
+      const outDir = frameworkOutDir(out, framework, `generated-verification-${scenario.id}`)
+      // Generated commands run serially because fail-once state and cleanup are scenario-local.
+      // eslint-disable-next-line no-await-in-loop
+      const result = await runCommand(command, {
+        artifactRoot: out,
+        envMode: 'clean',
+        label: `${framework.id}:generated-verification:${scenario.id}`,
+        outDir,
+        repositoryRoot: options.repositoryRoot,
+        requireExecutableApproval: options.requireExecutableApproval,
+        verbose: options.verbose,
+      })
+      const observedTestCount = getObservedTestCount(framework.framework, result.stdout, result.stderr)
+      const expected = scenario.expectedWithoutDatadog
+      const failOnceStateCreated = scenario.id === 'atr-fail-once'
+        ? hasGeneratedRuntimeFile(strategy)
+        : undefined
+      const scenarioEvidence = {
+        id: scenario.id,
+        command: serializeDisplayCommand(command),
+        exitCode: result.exitCode,
+        expectedExitCode: expected.exitCode,
+        observedTestCount,
+        expectedTestCount: expected.observedTestCount,
+        localAdjustments: command.localAdjustments || [],
+      }
+      if (failOnceStateCreated !== undefined) scenarioEvidence.failOnceStateCreated = failOnceStateCreated
+      evidence.scenarios.push(scenarioEvidence)
+      artifacts.push(...Object.values(result.artifacts))
+
+      if (result.timedOut || result.exitCode !== expected.exitCode ||
+        observedTestCount !== expected.observedTestCount || failOnceStateCreated === false) {
+        cleanupGeneratedRuntimeFiles(framework)
+        return getVerificationFailure(framework, evidence, artifacts, scenarioEvidence, result.timedOut)
+      }
+    }
+
+    cleanupGeneratedRuntimeFiles(framework)
+    strategy.status = 'verified'
+    strategy.verification = {
+      source: 'validator',
+      ran: true,
+      durationMs: Date.now() - startedAt,
+      observedScenarios: evidence.scenarios,
+      cleanupCompleted: true,
+    }
+    return { ok: true }
+  } catch (error) {
+    cleanupGeneratedRuntimeFiles(framework)
+    return {
+      ok: false,
+      failure: {
+        frameworkId: framework.id,
+        scenario: 'generated-test-verification',
+        status: 'error',
+        diagnosis: 'The validator could not run the temporary validation test as expected. No advanced-feature ' +
+          `conclusion was reached: ${error.message || error}`,
+        evidence,
+        artifacts,
+      },
+    }
+  }
+}
+
+/**
+ * Selects only generated tests required by the requested advanced checks.
+ *
+ * @param {object[]} scenarios generated test scenarios
+ * @param {Set<string>} [selectedFeatures] validator scenario selection
+ * @returns {object[]} generated scenarios to verify
+ */
+function getScenariosToVerify (scenarios, selectedFeatures) {
+  if (!(selectedFeatures instanceof Set)) return scenarios
+
+  const selectedScenarioIds = new Set()
+  for (const feature of selectedFeatures) {
+    const scenarioId = GENERATED_SCENARIO_BY_FEATURE[feature]
+    if (scenarioId) selectedScenarioIds.add(scenarioId)
+  }
+
+  if (selectedScenarioIds.size === 0) return scenarios
+  return scenarios.filter(scenario => selectedScenarioIds.has(scenario.id))
+}
+
+/**
+ * Builds a failure when a generated scenario does not behave as declared.
+ *
+ * @param {object} framework manifest framework entry
+ * @param {object} evidence collected verification evidence
+ * @param {string[]} artifacts command artifacts
+ * @param {object} scenario failed scenario evidence
+ * @param {boolean} timedOut whether the scenario timed out
+ * @returns {{ok: false, failure: object}} generated verification failure
+ */
+function getVerificationFailure (framework, evidence, artifacts, scenario, timedOut) {
+  let reason
+  if (timedOut) {
+    reason = 'timed out'
+  } else if (scenario.id === 'atr-fail-once' && scenario.failOnceStateCreated === false) {
+    reason = 'failed without creating its declared fail-once state file, so it failed for an unrelated reason'
+  } else {
+    reason = `exited ${scenario.exitCode} with ${formatObservedCount(scenario.observedTestCount)}; expected exit ` +
+      `${scenario.expectedExitCode} and ${scenario.expectedTestCount} test`
+  }
+  return {
+    ok: false,
+    failure: {
+      frameworkId: framework.id,
+      scenario: 'generated-test-verification',
+      status: 'error',
+      diagnosis: `Temporary validation test "${scenario.id}" ${reason}. No advanced-feature conclusion was reached.`,
+      evidence,
+      artifacts,
+    },
+  }
+}
+
+/**
+ * Checks whether the generated fail-once scenario created a declared runtime state file.
+ *
+ * @param {object} strategy generated test strategy
+ * @returns {boolean} whether a regular declared runtime file exists
+ */
+function hasGeneratedRuntimeFile (strategy) {
+  const generatedFiles = new Set((strategy.files || []).map(file => path.resolve(file.path)))
+  for (const cleanupPath of strategy.cleanupPaths || []) {
+    const filename = path.resolve(cleanupPath)
+    if (generatedFiles.has(filename)) continue
+    try {
+      const stat = fs.lstatSync(filename)
+      if (!stat.isSymbolicLink() && stat.isFile()) return true
+    } catch {}
+  }
+  return false
+}
+
+/**
+ * Formats a parsed test count for a customer-facing diagnosis.
+ *
+ * @param {number|null} count observed test count
+ * @returns {string} formatted count
+ */
+function formatObservedCount (count) {
+  return count === null ? 'an unknown test count' : `${count} observed tests`
+}
+
+module.exports = { verifyGeneratedTestStrategy }

package/ci/test-optimization-validation/init-probe-preload.js

@@ -0,0 +1,163 @@
+'use strict'
+
+/* eslint-disable eslint-rules/eslint-process-env */
+
+const fs = require('node:fs')
+const Module = require('node:module')
+const path = require('node:path')
+
+const { sanitizeForReport } = require('./redaction')
+
+const PROBE_FILE_ENV = 'DD_TEST_OPTIMIZATION_INIT_PROBE_FILE'
+const probeFile = process.env[PROBE_FILE_ENV]
+const seenModuleLoads = new Set()
+
+if (probeFile) {
+  writeRecord('process-start', {
+    argv: process.argv,
+    cwd: process.cwd(),
+    detectedTools: detectTools(process.argv),
+    execArgv: process.execArgv,
+    nodeOptionsPresent: Boolean(process.env.NODE_OPTIONS),
+    pid: process.pid,
+    ppid: process.ppid,
+  })
+
+  const originalLoad = Module._load
+  Module._load = function loadWithProbe (request, parent, isMain) {
+    const loaded = originalLoad.apply(this, arguments)
+    const tool = detectTool(request) || detectTool(resolveFromParent(request, parent))
+
+    if (tool) {
+      const key = `${process.pid}:${request}:${tool.name}`
+      if (!seenModuleLoads.has(key)) {
+        seenModuleLoads.add(key)
+        writeRecord('module-load', {
+          argv: process.argv,
+          cwd: process.cwd(),
+          isMain: Boolean(isMain),
+          parentFilename: parent && parent.filename,
+          pid: process.pid,
+          ppid: process.ppid,
+          request,
+          tool,
+        })
+      }
+    }
+
+    return loaded
+  }
+}
+
+function resolveFromParent (request, parent) {
+  try {
+    return Module._resolveFilename(request, parent)
+  } catch {
+    return ''
+  }
+}
+
+function detectTools (values) {
+  const tools = []
+  const seen = new Set()
+
+  for (const value of values) {
+    const tool = detectTool(value)
+    if (!tool || seen.has(tool.name)) continue
+    seen.add(tool.name)
+    tools.push(tool)
+  }
+
+  return tools
+}
+
+function detectTool (value) {
+  if (typeof value !== 'string' || value.length === 0) return null
+
+  const normalized = value.split(path.sep).join('/').toLowerCase()
+
+  if (/(^|\/)(jest|jest\.js)$/.test(normalized) ||
+    /\/(?:jest|jest-cli|@jest\/core)\//.test(normalized) ||
+    normalized === 'jest' ||
+    normalized === 'jest-cli' ||
+    normalized === '@jest/core') {
+    return { name: 'jest', kind: 'test-runner' }
+  }
+
+  if (/(^|\/)(vitest|vitest\.mjs)$/.test(normalized) ||
+    /\/(?:vitest|@vitest\/runner)\//.test(normalized) ||
+    normalized === 'vitest' ||
+    normalized === '@vitest/runner') {
+    return { name: 'vitest', kind: 'test-runner' }
+  }
+
+  if (/(^|\/)(mocha|mocha\.js|_mocha)$/.test(normalized) ||
+    /\/mocha\//.test(normalized) ||
+    normalized === 'mocha') {
+    return { name: 'mocha', kind: 'test-runner' }
+  }
+
+  if (/\/@cucumber\/cucumber\//.test(normalized) ||
+    normalized === '@cucumber/cucumber' ||
+    normalized === 'cucumber' ||
+    normalized === 'cucumber-js') {
+    return { name: 'cucumber', kind: 'test-runner' }
+  }
+
+  if (/(^|\/)playwright(?:\.js)?$/.test(normalized) ||
+    /\/(?:@playwright\/test|playwright)\//.test(normalized) ||
+    normalized === '@playwright/test' ||
+    normalized === 'playwright' ||
+    normalized === 'playwright/test') {
+    return { name: 'playwright', kind: 'test-runner' }
+  }
+
+  if (/(^|\/)cypress(?:\.js)?$/.test(normalized) || /\/cypress\//.test(normalized) || normalized === 'cypress') {
+    return { name: 'cypress', kind: 'test-runner' }
+  }
+
+  if (/(^|\/)(nx|nx\.js)$/.test(normalized) || /\/nx\//.test(normalized) || normalized === 'nx') {
+    return { name: 'nx', kind: 'wrapper' }
+  }
+
+  if (/(^|\/)(turbo|turbo\.js)$/.test(normalized) || /\/turbo\//.test(normalized) || normalized === 'turbo') {
+    return { name: 'turbo', kind: 'wrapper' }
+  }
+
+  if (/(^|\/)(lage|lage\.js)$/.test(normalized) || /\/lage\//.test(normalized) || normalized === 'lage') {
+    return { name: 'lage', kind: 'wrapper' }
+  }
+
+  if (/(^|\/)(pnpm|pnpm\.cjs)$/.test(normalized) || /\/pnpm\//.test(normalized) || normalized === 'pnpm') {
+    return { name: 'pnpm', kind: 'package-manager' }
+  }
+
+  if (/(^|\/)(npm|npm-cli\.js)$/.test(normalized) || /\/npm\//.test(normalized) || normalized === 'npm') {
+    return { name: 'npm', kind: 'package-manager' }
+  }
+
+  if (/(^|\/)(yarn|yarn\.js)$/.test(normalized) || /\/yarn\//.test(normalized) || normalized === 'yarn') {
+    return { name: 'yarn', kind: 'package-manager' }
+  }
+
+  return null
+}
+
+function writeRecord (type, data) {
+  try {
+    const record = sanitizeForReport({
+      type,
+      time: new Date().toISOString(),
+      ...data,
+    })
+    const flags = fs.constants.O_WRONLY | fs.constants.O_APPEND | (fs.constants.O_NOFOLLOW || 0)
+    const file = fs.openSync(probeFile, flags)
+    try {
+      fs.writeFileSync(file, `${JSON.stringify(record)}\n`)
+    } finally {
+      fs.closeSync(file)
+    }
+  } catch {
+    // The probe must never change test behavior.
+  }
+}