ci(all-green): fix junit workflow attribution via per-test ci.* tags

datadog-ci junit upload reads GITHUB_WORKFLOW/GITHUB_RUN_ID/GITHUB_RUN_NUMBER
from its own process env to set each test's Pipeline/Job facets. Uploading
every sibling workflow's junit results from one batched call inside All
Green attributed every test to the "All Green" workflow instead of the one
that produced it.

Revert the per-run-upload workaround from a previous commit (extra
datadog-ci invocations, one per sibling workflow) in favor of stamping each
job's own CI metadata as junit XML properties at mocha-run time (while its
own GITHUB_* env vars are still correct), then lifting them into real
per-test ci.pipeline.*/ci.job.name tags via --xpath-tag at upload time -
mirroring the existing node_version tagging pattern, restoring the single
batched upload.

Also drop upload-junit.mjs's custom XML merging: --auto-discovery already
recursively finds and uploads every matching file in one CLI invocation, so
merging reports into one document first added regex-based XML surgery for
no benefit.

Generated by Claude Code.

Author: rochdev

.mochamultireporterrc.js

@@ -1,18 +1,34 @@
 'use strict'
 
+// eslint-disable-next-line eslint-rules/eslint-process-env
+const isCI = Boolean(process.env.CI)
+
 const reporterEnabled = ['spec']
+if (isCI) reporterEnabled.push('./scripts/junit-reporter.js')
 
-// eslint-disable-next-line eslint-rules/eslint-process-env
-if (process.env.CI) {
-  reporterEnabled.push('./scripts/junit-reporter.js')
-}
+// datadog-ci junit upload derives the Pipeline/Job UI facets from GITHUB_* env vars in its own
+// process at upload time, which are All Green's own since it uploads every sibling workflow's
+// results in a single call. Stamping them here instead, while this job's own GITHUB_* values are
+// still correct, lets `--xpath-tag` (see scripts/upload-junit.mjs) remap them onto the real
+// ci.pipeline.*/ci.job.* tags per test instead.
+const GITHUB_ENV = process.env // eslint-disable-line eslint-rules/eslint-process-env
+const {
+  GITHUB_JOB, GITHUB_RUN_ID, GITHUB_WORKFLOW, GITHUB_RUN_NUMBER, GITHUB_SERVER_URL, GITHUB_REPOSITORY,
+} = GITHUB_ENV
 
 module.exports = {
   reporterEnabled,
   scriptsJunitReporterJsReporterOptions: {
     mochaFile: `./node-${process.versions.node}-junit.xml`,
     properties: {
       node_version: process.versions.node,
+      ...(isCI && {
+        'ci.pipeline.name': GITHUB_WORKFLOW,
+        'ci.pipeline.id': GITHUB_RUN_ID,
+        'ci.pipeline.number': GITHUB_RUN_NUMBER,
+        'ci.pipeline.url': `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}`,
+        'ci.job.name': GITHUB_JOB,
+      }),
     },
   },
 }

scripts/all-green.mjs

@@ -4,7 +4,7 @@ import { summary } from '@actions/core'
 import { context } from '@actions/github'
 import { downloadArtifacts } from './download-artifacts.mjs'
 import { logUploads } from './run-upload.mjs'
-import { uploadJunitForRun } from './upload-junit.mjs'
+import { uploadAllJunit } from './upload-junit.mjs'
 import {
   uploadAllCoverageToDatadog, uploadCoverage, sendCodecovNotifications, hasCodecovCommit,
 } from './upload-coverage.mjs'
@@ -105,42 +105,33 @@ async function getRuns () {
 }
 
 // Runs whose reports have already been downloaded/merged, and the resulting promises — each
-// sibling workflow's reports are downloaded and its junit/Codecov uploads go out as soon as that
+// sibling workflow's reports are downloaded and its Codecov upload goes out as soon as that
 // workflow reaches a final state, instead of waiting for every workflow to finish, so a fast
-// workflow's results land while slower ones are still running. junit needs this same per-run
-// granularity even though it has no per-workflow flag constraint like Codecov: `datadog-ci junit
-// upload` tags every uploaded test with the pipeline name/id/number it reads from
-// GITHUB_WORKFLOW/GITHUB_RUN_ID/GITHUB_RUN_NUMBER in the process environment, and since the upload
-// always runs from inside the All Green job, a single merged upload across every run would
-// attribute every test to the "All Green" workflow instead of the one that produced it — see
-// `uploadJunitForRun`. Datadog coverage has no comparable per-test attribution to lose, so it stays
-// batched into one call after every run is done instead — see `uploadAllCoverageToDatadog`.
+// workflow's Codecov coverage lands while slower ones are still running. The junit and Datadog
+// coverage uploads don't have Codecov's per-workflow flag constraint, so they're batched into one
+// call each after every run is done instead — see `uploadAllJunit`/`uploadAllCoverageToDatadog`.
 const processedRunIds = new Set()
 const processingPromises = []
 
 /**
  * Download a single finished workflow run's junit and coverage artifacts, merge them, and upload
- * the junit merge to Datadog (tagged with this run's own CI metadata) and the coverage merge to
- * Codecov.
+ * the coverage merge to Codecov.
  *
- * @param {{ id: number, name: string, run_number: number, run_attempt?: number }} run
+ * @param {{ id: number, name: string }} run
  * @returns {Promise<void>}
  */
 async function processRun (run) {
   const { downloaded, failed } = await downloadArtifacts(octokit, { owner, repo, token: GITHUB_TOKEN, runs: [run] })
 
-  const [junitResults, coverageResults] = await Promise.all([
-    uploadJunitForRun(run),
-    uploadCoverage(run, {
-      sha: HEAD_SHA,
-      branch: HEAD_BRANCH,
-      prNumber: PR_NUMBER,
-      eventName: GITHUB_EVENT_NAME,
-      baseRef: BASE_REF,
-    }),
-  ])
+  const coverageResults = await uploadCoverage(run, {
+    sha: HEAD_SHA,
+    branch: HEAD_BRANCH,
+    prNumber: PR_NUMBER,
+    eventName: GITHUB_EVENT_NAME,
+    baseRef: BASE_REF,
+  })
   const downloadSummary = failed > 0 ? `${downloaded} artifact(s), ${failed} failed` : `${downloaded} artifact(s)`
-  logUploads(`${run.name} (${downloadSummary})`, [...junitResults, ...coverageResults])
+  logUploads(`${run.name} (${downloadSummary})`, coverageResults)
 }
 
 /**
@@ -279,8 +270,8 @@ async function checkAllGreen () {
   console.log(`Waiting for ${processingPromises.length} workflow run report upload(s) to finish.`)
   await Promise.all(processingPromises)
 
-  const coverageResults = await uploadAllCoverageToDatadog()
-  logUploads('coverage (every run)', coverageResults)
+  const [junitResults, coverageResults] = await Promise.all([uploadAllJunit(), uploadAllCoverageToDatadog()])
+  logUploads('junit + coverage (every run)', [...junitResults, ...coverageResults])
 
   if (!done) {
     console.log(`State is still pending after ${RETRIES} retries.`)

scripts/run-upload.mjs

@@ -17,16 +17,12 @@ import { setTimeout as sleep } from 'node:timers/promises'
  *
  * @param {string} command
  * @param {string[]} args
- * @param {Record<string, string>} [env] Overrides merged on top of `process.env` for this call only.
  * @returns {Promise<UploadResult>}
  */
-function spawnUpload (command, args, env) {
+function spawnUpload (command, args) {
   return new Promise(resolve => {
     const start = Date.now()
-    const child = spawn(command, args, {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      env: env ? { ...process.env, ...env } : process.env,
-    })
+    const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'] })
     let output = ''
     child.stdout.on('data', chunk => { output += chunk })
     child.stderr.on('data', chunk => { output += chunk })
@@ -44,11 +40,10 @@ function spawnUpload (command, args, env) {
  *
  * @param {string} command
  * @param {string[]} args
- * @param {Record<string, string>} [env] Overrides merged on top of `process.env` for this call only.
  * @returns {Promise<UploadResult>}
  */
-export async function runUpload (command, args, env) {
-  const result = await spawnUpload(command, args, env)
+export async function runUpload (command, args) {
+  const result = await spawnUpload(command, args)
   if (result.code !== 0) process.exitCode = 1
   return result
 }

scripts/upload-junit.mjs

@@ -1,123 +1,39 @@
-import { mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
+import { existsSync } from 'node:fs'
 import { runUpload } from './run-upload.mjs'
 
 const INPUT_DIR = 'junit-results'
-const OUTPUT_DIR = 'junit-upload'
 
-// One sibling workflow's upload bundles every matrix cell's (e.g. per-Node-version) junit XML
-// together, so a per-test tag is the only way to tell which cell a result came from — the CI job
-// name/ID tags datadog-ci attaches are the same for every file in one upload call.
-// `.mochamultireporterrc.js` stamps each testsuite with a `node_version` property; this lifts it
-// into a real tag using the xpath pattern datadog-ci documents for `<property>` extraction.
-const NODE_VERSION_XPATH_TAG = "test.node_version=/testcase/..//property[@name='node_version']/@value"
+// Every sibling workflow's upload is merged into one call, so datadog-ci's own GITHUB_*-derived
+// Pipeline/Job facets would attribute every test to the All Green workflow instead of the one that
+// produced it. `.mochamultireporterrc.js` stamps each testsuite with its own job's CI metadata (plus
+// `node_version`) as XML properties at mocha-run time, while that job's own GITHUB_* env vars are
+// still correct; these xpath-tag mappings lift those properties into real per-test tags at upload
+// time, using the same reserved `ci.*` tag names datadog-ci's own GitHub Actions detection populates.
+const XPATH_TAGS = [
+  "test.node_version=/testcase/..//property[@name='node_version']/@value",
+  "ci.pipeline.name=/testcase/..//property[@name='ci.pipeline.name']/@value",
+  "ci.pipeline.id=/testcase/..//property[@name='ci.pipeline.id']/@value",
+  "ci.pipeline.number=/testcase/..//property[@name='ci.pipeline.number']/@value",
+  "ci.pipeline.url=/testcase/..//property[@name='ci.pipeline.url']/@value",
+  "ci.job.name=/testcase/..//property[@name='ci.job.name']/@value",
+]
 
 /**
- * Recursively collect every junit XML file beneath a directory. `download-artifacts.mjs` lays
- * files out as `junit-results/<run-id>/<artifact-name>/*.xml`, one artifact per matrix cell across
- * every sibling workflow run.
+ * Upload every sibling workflow's downloaded junit reports to Datadog in a single call.
+ * `--auto-discovery` already walks `junit-results/<run-id>/<artifact-name>/*.xml` recursively and
+ * uploads every matching file itself (with its own internal concurrency), so there's no need to
+ * merge the reports into one document first — each testcase's `node_version` and `ci.*` properties
+ * (see `XPATH_TAGS`) keep matrix cells and originating workflows distinguishable regardless of which
+ * file they came from.
  *
- * @param {string} dir
- * @param {string[]} out
- * @returns {string[]}
- */
-function collectJunitFiles (dir, out = []) {
-  let entries
-  try {
-    entries = readdirSync(dir, { withFileTypes: true })
-  } catch {
-    return out
-  }
-  for (const entry of entries) {
-    const full = join(dir, entry.name)
-    if (entry.isDirectory()) {
-      collectJunitFiles(full, out)
-    } else if (entry.name.endsWith('.xml')) {
-      out.push(full)
-    }
-  }
-  return out
-}
-
-/**
- * Parse a `<testsuites ...>` opening tag's attributes into a plain object.
- *
- * @param {string} attrsString
- * @returns {Record<string, string>}
- */
-function parseRootAttrs (attrsString) {
-  const attrs = {}
-  for (const match of attrsString.matchAll(/(\w+)="([^"]*)"/g)) attrs[match[1]] = match[2]
-  return attrs
-}
-
-/**
- * Merge every matrix cell's junit report into a single document, concatenating each report's
- * `<testsuite>` children under one `<testsuites>` root instead of uploading one file per cell —
- * every testcase already carries its own `node_version` property (see `NODE_VERSION_XPATH_TAG`),
- * so cells stay distinguishable after merging. The root's `time`/`tests`/`failures`/`skipped`
- * totals are recomputed across every report; unlike those, the root `name` isn't run-specific, so
- * the first report's value is kept as-is.
- *
- * @param {string[]} reportPaths
- * @returns {string}
- */
-function mergeJunit (reportPaths) {
-  let name
-  let inner = ''
-  const totals = { time: 0, tests: 0, failures: 0, skipped: 0 }
-
-  for (const reportPath of reportPaths) {
-    const contents = readFileSync(reportPath, 'utf8')
-    const match = contents.match(/<testsuites([^>]*)>([\s\S]*)<\/testsuites>\s*$/)
-    if (!match) continue
-
-    const [, attrsString, reportInner] = match
-    const attrs = parseRootAttrs(attrsString)
-    if (name === undefined && attrs.name) name = attrs.name
-    for (const key of Object.keys(totals)) totals[key] += Number(attrs[key]) || 0
-    inner += reportInner
-  }
-  name ??= 'Mocha Tests'
-
-  const skippedAttr = totals.skipped > 0 ? ` skipped="${totals.skipped}"` : ''
-  return '<?xml version="1.0" encoding="UTF-8"?>\n' +
-    `<testsuites name="${name}" time="${totals.time.toFixed(3)}" tests="${totals.tests}" ` +
-    `failures="${totals.failures}"${skippedAttr}>${inner}</testsuites>\n`
-}
-
-/**
- * Merge one sibling workflow run's downloaded junit reports into one file and upload it to Datadog,
- * tagged with that run's own GitHub Actions metadata instead of All Green's. `datadog-ci junit
- * upload` reads `GITHUB_WORKFLOW`/`GITHUB_RUN_ID`/`GITHUB_RUN_NUMBER`/`GITHUB_RUN_ATTEMPT` from the
- * process environment to set each uploaded test's pipeline name/id/number in Test Optimization; since
- * the upload always runs from inside the All Green job, every test would otherwise be attributed to
- * the "All Green" workflow instead of the one that actually produced it. Every matrix cell within the
- * run is still merged down to one document — each testcase's `node_version` property (see
- * `NODE_VERSION_XPATH_TAG`) is what keeps cells distinguishable afterward, not which file they
- * came from.
- *
- * @param {{ id: number, name: string, run_number: number, run_attempt?: number }} run
  * @returns {Promise<import('./run-upload.mjs').UploadResult[]>}
  */
-export async function uploadJunitForRun (run) {
-  const reportPaths = collectJunitFiles(join(INPUT_DIR, String(run.id)))
-  if (reportPaths.length === 0) return []
-
-  const outputDir = join(OUTPUT_DIR, String(run.id))
-  mkdirSync(outputDir, { recursive: true })
-  writeFileSync(join(outputDir, 'junit.xml'), mergeJunit(reportPaths))
+export async function uploadAllJunit () {
+  if (!existsSync(INPUT_DIR)) return []
 
   const result = await runUpload('datadog-ci', [
-    'junit', 'upload', '--service', 'dd-trace-js-tests', '--auto-discovery', outputDir,
-    '--xpath-tag', NODE_VERSION_XPATH_TAG,
-  ], {
-    GITHUB_WORKFLOW: run.name,
-    GITHUB_RUN_ID: String(run.id),
-    GITHUB_RUN_NUMBER: String(run.run_number),
-    GITHUB_RUN_ATTEMPT: String(run.run_attempt ?? 1),
-  })
+    'junit', 'upload', '--service', 'dd-trace-js-tests', '--auto-discovery', INPUT_DIR,
+    ...XPATH_TAGS.flatMap(tag => ['--xpath-tag', tag]),
+  ])
   return [result]
 }
-
-export { mergeJunit }