From 2d500afa93f8aebda1c82b25baeeaf8a94950d85 Mon Sep 17 00:00:00 2001
From: Alex Lopez <alex.lopez@datadoghq.com>
Date: Mon, 10 Aug 2026 15:11:04 +0200
Subject: [PATCH 1/9] Drop flavor concerns from junit test collection

---
 .gitlab/build/bazel/test.yml |  5 ++---
 tasks/bazel.py               | 11 +++--------
 2 files changed, 5 insertions(+), 11 deletions(-)

diff --git a/.gitlab/build/bazel/test.yml b/.gitlab/build/bazel/test.yml
index 1a0400842b1d..39f16f558961 100644
--- a/.gitlab/build/bazel/test.yml
+++ b/.gitlab/build/bazel/test.yml
@@ -14,10 +14,9 @@
       aud: ci-identities
   variables:
     EXTERNAL_LINKS_PATH: external_links_$CI_JOB_ID.json
-    FLAVOR: base
-    BEP_FILE: $CI_PROJECT_DIR/bazel-bep-$FLAVOR.json
+    BEP_FILE: $CI_PROJECT_DIR/bazel-bep.json
   after_script:
-    - dda inv -- -e bazel.collect-junit --flavor=$FLAVOR --output-tgz=junit-${CI_JOB_NAME}.tgz --bep-file=$BEP_FILE || true
+    - dda inv -- -e bazel.collect-junit --output-tgz=junit-${CI_JOB_NAME}.tgz --bep-file=$BEP_FILE
     - !reference [.upload_junit_source]
   artifacts:
     expire_in: 2 weeks
diff --git a/tasks/bazel.py b/tasks/bazel.py
index d733d43b2718..a52d110cf9d2 100644
--- a/tasks/bazel.py
+++ b/tasks/bazel.py
@@ -399,12 +399,11 @@ def _annotate_junit_cache_status(xml_path: Path, cache_status: dict[str, bool])
 
 @task(
     help={
-        "flavor": f"Agent flavor ({', '.join(f.name for f in AgentFlavor)}). Embedded in each JUnit XML.",
         "output_tgz": "Destination path for the output tgz (e.g. junit-bazel-base.tgz).",
         "bep_file": "Path to a Bazel BEP JSON file (--build_event_json_file); drives test.xml discovery and annotates each testsuite with bazel.cached.",
     },
 )
-def collect_junit(ctx, flavor, output_tgz, bep_file):
+def collect_junit(ctx, output_tgz, bep_file):
     """Collect Bazel test results and package them for junit_upload.
 
     Merges the test.xml files produced by the rules_go test runner (one per
@@ -412,7 +411,7 @@ def collect_junit(ctx, flavor, output_tgz, bep_file):
     with the existing junit_upload machinery (same format as --junit-tar from
     dda inv test).
     """
-    from tasks.libs.common.junit_upload_core import enrich_junitxml, produce_junit_tar
+    from tasks.libs.common.junit_upload_core import produce_junit_tar
 
     # BEP is the authoritative source: it lists exactly the test.xml files
     # produced by this invocation, avoiding stale results from previous runs
@@ -423,8 +422,6 @@ def collect_junit(ctx, flavor, output_tgz, bep_file):
         print("error: no test.xml files found in BEP output", file=sys.stderr)
         sys.exit(1)
 
-    agent_flavor = AgentFlavor[flavor]
-
     with tempfile.TemporaryDirectory() as tmpdir:
         merged = ET.Element("testsuites")
         collected = 0
@@ -455,11 +452,9 @@ def collect_junit(ctx, flavor, output_tgz, bep_file):
             )
             sys.exit(1)
 
-        merged_path = Path(tmpdir) / f"junit-bazel-{flavor}.xml"
+        merged_path = Path(tmpdir) / "junit-bazel.xml"
         ET.ElementTree(merged).write(str(merged_path), encoding="unicode")
 
-        enrich_junitxml(str(merged_path), agent_flavor)
-
         if cache_status:
             _annotate_junit_cache_status(merged_path, cache_status)
 

From dda9f27682a71d6c90831c7eea200a6e0810a117 Mon Sep 17 00:00:00 2001
From: Alex Lopez <alex.lopez@datadoghq.com>
Date: Mon, 10 Aug 2026 16:16:18 +0200
Subject: [PATCH 2/9] Find logs too

---
 tasks/bazel.py                  | 97 ++++++++++++++++++++++-----------
 tasks/unit_tests/bazel_tests.py | 76 +++++++++++++++++++++-----
 2 files changed, 127 insertions(+), 46 deletions(-)

diff --git a/tasks/bazel.py b/tasks/bazel.py
index a52d110cf9d2..2a7849b81dcf 100644
--- a/tasks/bazel.py
+++ b/tasks/bazel.py
@@ -9,6 +9,7 @@
 import xml.etree.ElementTree as ET
 from datetime import datetime
 from pathlib import Path
+from typing import TypedDict
 
 from invoke import task
 
@@ -100,27 +101,28 @@ def _label_to_import_path(label: str) -> str:
     return _IMPORT_PREFIX if not pkg_part else f"{_IMPORT_PREFIX}/{pkg_part}"
 
 
-def _test_xml_candidates(
+def _test_output_candidates(
     label: str,
     uri: str,
     cfg_id: str,
     local_exec_root: str | None,
     config_testlogs: dict[str, Path],
+    output_name: str,
 ) -> list[Path]:
-    """Candidate paths for test.xml, in priority order.
+    """Candidate paths for a Bazel test output, in priority order.
 
     BEP URIs are file:// for local actions and bytestream:// for remote-cache
-    hits; for the latter Bazel still materializes test.xml on disk at
-    <localExecRoot>/<testlogs-dir>/<label>/test.xml.
+    hits; for the latter Bazel often still materializes outputs on disk at
+    <localExecRoot>/<testlogs-dir>/<label>/<output_name>.
     """
     paths: list[Path] = []
     if uri.startswith("file://"):
         paths.append(Path(uri.removeprefix("file://")))
     testlogs_dir = config_testlogs.get(cfg_id)
     if local_exec_root and testlogs_dir:
-        # Label "//pkg/foo:bar_test" -> "pkg/foo/bar_test/test.xml".
+        # Label "//pkg/foo:bar_test" -> "pkg/foo/bar_test/<output_name>".
         label_rel = label.lstrip("/").replace(":", "/")
-        paths.append(Path(local_exec_root) / testlogs_dir / label_rel / "test.xml")
+        paths.append(Path(local_exec_root) / testlogs_dir / label_rel / output_name)
     return paths
 
 
@@ -216,7 +218,9 @@ def _bazel_test_funcs_from_bep(bep_path: Path) -> dict[str, set[str]]:
         if label not in test_action:
             continue
         uri, cfg_id = test_action[label]
-        funcs = _test_xml_funcs(_test_xml_candidates(label, uri, cfg_id, ctx.local_exec_root, ctx.config_testlogs))
+        funcs = _test_xml_funcs(
+            _test_output_candidates(label, uri, cfg_id, ctx.local_exec_root, ctx.config_testlogs, "test.xml")
+        )
         covered.setdefault(_label_to_import_path(label), set()).update(funcs)
 
     return covered
@@ -313,16 +317,37 @@ def ensure_test_parity(ctx, bep, flavor_name, verbose=False, emit_metrics=False)
         sys.exit(1)
 
 
-def _parse_bep(bep_path: Path) -> tuple[list[Path], dict[str, bool]]:
+class BepTestArtifacts(TypedDict):
+    cached: bool
+    xml_paths: list[Path]
+    log_paths: list[Path]
+
+
+def _resolve_test_output_path(
+    label: str,
+    uri: str,
+    cfg_id: str,
+    ctx: _BepContext,
+    output_name: str,
+) -> Path:
+    candidates = _test_output_candidates(label, uri, cfg_id, ctx.local_exec_root, ctx.config_testlogs, output_name)
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate
+    raise RuntimeError(
+        f"Could not resolve {output_name} for {label}. "
+        f"uri={uri!r}, cfg_id={cfg_id!r}, candidates={[str(p) for p in candidates]}"
+    )
+
+
+def _parse_bep(bep_path: Path) -> dict[str, BepTestArtifacts]:
     """Parse a BEP JSON file in one pass.
 
-    Returns (xml_paths, cache_status) where xml_paths are the test.xml files
-    produced by this specific invocation, and cache_status maps import_path →
-    was_cached.
+    Returns a mapping keyed by Go import path. Each value contains the cache
+    status and the test.xml/test.log files produced by this invocation.
     """
     ctx = _BepContext()
-    test_action: dict[str, list[tuple[str, str]]] = {}
-    cache_status: dict[str, bool] = {}
+    test_actions: list[tuple[str, str, str, str, bool]] = []
 
     with bep_path.open() as f:
         for line in f:
@@ -339,24 +364,29 @@ def _parse_bep(bep_path: Path) -> tuple[list[Path], dict[str, bool]]:
             match eid:
                 case {"testResult": {"label": label}} if label:
                     tr = event.get("testResult", {})
-                    import_path = _label_to_import_path(label)
-                    cache_status[import_path] = bool(
-                        tr.get("cachedLocally") or tr.get("executionInfo", {}).get("cachedRemotely")
-                    )
                     cfg_id = eid["testResult"].get("configuration", {}).get("id", "")
-                    for output in tr.get("testActionOutput", []):
-                        if output.get("name") == "test.xml":
-                            test_action.setdefault(label, []).append((output.get("uri", ""), cfg_id))
-                            break
-
-    xml_paths: list[Path] = []
-    for label, actions in test_action.items():
-        for uri, cfg_id in actions:
-            for candidate in _test_xml_candidates(label, uri, cfg_id, ctx.local_exec_root, ctx.config_testlogs):
-                if candidate.is_file():
-                    xml_paths.append(candidate)
-                    break
-    return xml_paths, cache_status
+                    output_uris = {
+                        output.get("name"): output.get("uri", "")
+                        for output in tr.get("testActionOutput", [])
+                        if output.get("name")
+                    }
+                    missing_outputs = [name for name in ("test.xml", "test.log") if name not in output_uris]
+                    if missing_outputs:
+                        raise RuntimeError(
+                            f"BEP testResult for {label} did not include {missing_outputs}; "
+                            f"available outputs: {sorted(output_uris)}"
+                        )
+                    cached = bool(tr.get("cachedLocally") or tr.get("executionInfo", {}).get("cachedRemotely"))
+                    test_actions.append((label, cfg_id, output_uris["test.xml"], output_uris["test.log"], cached))
+
+    results: dict[str, BepTestArtifacts] = {}
+    for label, cfg_id, xml_uri, log_uri, cached in test_actions:
+        import_path = _label_to_import_path(label)
+        artifacts = results.setdefault(import_path, {"cached": cached, "xml_paths": [], "log_paths": []})
+        artifacts["cached"] = cached
+        artifacts["xml_paths"].append(_resolve_test_output_path(label, xml_uri, cfg_id, ctx, "test.xml"))
+        artifacts["log_paths"].append(_resolve_test_output_path(label, log_uri, cfg_id, ctx, "test.log"))
+    return results
 
 
 def _is_gotestsum_shaped(suite: ET.Element) -> bool:
@@ -413,11 +443,12 @@ def collect_junit(ctx, output_tgz, bep_file):
     """
     from tasks.libs.common.junit_upload_core import produce_junit_tar
 
-    # BEP is the authoritative source: it lists exactly the test.xml files
+    # BEP is the authoritative source: it lists exactly the test.xml and test.out files
     # produced by this invocation, avoiding stale results from previous runs
     # with a different Bazel configuration.
-    xml_paths, cache_status = _parse_bep(Path(bep_file))
-    xml_files = [p for p in xml_paths if p.is_file()]
+    test_artifacts = _parse_bep(Path(bep_file))
+    xml_files = [p for artifacts in test_artifacts.values() for p in artifacts["xml_paths"]]
+    cache_status = {import_path: artifacts["cached"] for import_path, artifacts in test_artifacts.items()}
     if not xml_files:
         print("error: no test.xml files found in BEP output", file=sys.stderr)
         sys.exit(1)
diff --git a/tasks/unit_tests/bazel_tests.py b/tasks/unit_tests/bazel_tests.py
index 7c059940ccd8..f722e21df6e1 100644
--- a/tasks/unit_tests/bazel_tests.py
+++ b/tasks/unit_tests/bazel_tests.py
@@ -124,8 +124,10 @@ def test_reconstructs_cached_result_via_testlogs(self):
         with tempfile.TemporaryDirectory() as tmpdir:
             exec_root = Path(tmpdir) / "exec_root"
             reconstructed = exec_root / "bazel-out/k8-fastbuild/testlogs/pkg/foo/foo_test/test.xml"
+            reconstructed_log = reconstructed.parent / "test.log"
             reconstructed.parent.mkdir(parents=True)
             reconstructed.write_text(_JUNIT_XML)
+            reconstructed_log.write_text("PASS\n")
 
             bep_path = Path(tmpdir) / "bep.json"
             bep_path.write_text(
@@ -144,7 +146,8 @@ def test_reconstructs_cached_result_via_testlogs(self):
                                 "testResult": {
                                     "cachedLocally": True,
                                     "testActionOutput": [
-                                        {"name": "test.xml", "uri": "bytestream://example/blobs/abc/123"}
+                                        {"name": "test.xml", "uri": "bytestream://example/blobs/abc/123"},
+                                        {"name": "test.log", "uri": "bytestream://example/blobs/def/456"},
                                     ],
                                 },
                             }
@@ -153,16 +156,25 @@ def test_reconstructs_cached_result_via_testlogs(self):
                 )
             )
 
-            xml_paths, cache_status = _parse_bep(bep_path)
-            self.assertEqual(xml_paths, [reconstructed])
-            self.assertEqual(cache_status, {f"{_IMPORT_PREFIX}/pkg/foo": True})
+            self.assertEqual(
+                _parse_bep(bep_path),
+                {
+                    f"{_IMPORT_PREFIX}/pkg/foo": {
+                        "cached": True,
+                        "xml_paths": [reconstructed],
+                        "log_paths": [reconstructed_log],
+                    }
+                },
+            )
 
     def test_local_result_not_duplicated_via_reconstructed_path(self):
         with tempfile.TemporaryDirectory() as tmpdir:
             exec_root = Path(tmpdir) / "exec_root"
             reconstructed = exec_root / "bazel-out/k8-fastbuild/testlogs/pkg/foo/foo_test/test.xml"
+            reconstructed_log = reconstructed.parent / "test.log"
             reconstructed.parent.mkdir(parents=True)
             reconstructed.write_text(_JUNIT_XML)
+            reconstructed_log.write_text("PASS\n")
             # The file:// URI Bazel reports for a local (non-cached) action
             # points at the same underlying file as the reconstructed path.
             file_uri_path = reconstructed
@@ -182,7 +194,10 @@ def test_local_result_not_duplicated_via_reconstructed_path(self):
                             {
                                 "id": {"testResult": {"label": "//pkg/foo:foo_test", "configuration": {"id": "cfg1"}}},
                                 "testResult": {
-                                    "testActionOutput": [{"name": "test.xml", "uri": file_uri_path.as_uri()}]
+                                    "testActionOutput": [
+                                        {"name": "test.xml", "uri": file_uri_path.as_uri()},
+                                        {"name": "test.log", "uri": reconstructed_log.as_uri()},
+                                    ]
                                 },
                             }
                         ),
@@ -190,17 +205,22 @@ def test_local_result_not_duplicated_via_reconstructed_path(self):
                 )
             )
 
-            xml_paths, _ = _parse_bep(bep_path)
-            self.assertEqual(xml_paths, [file_uri_path])
+            artifacts = _parse_bep(bep_path)
+            self.assertEqual(artifacts[f"{_IMPORT_PREFIX}/pkg/foo"]["xml_paths"], [file_uri_path])
+            self.assertEqual(artifacts[f"{_IMPORT_PREFIX}/pkg/foo"]["log_paths"], [reconstructed_log])
 
     def test_repeated_test_result_for_same_label_all_kept(self):
         # A sharded or retried target reports multiple testResult events for
-        # the same label, each with its own test.xml; none should be dropped.
+        # the same label, each with its own test.xml/test.log; none should be dropped.
         with tempfile.TemporaryDirectory() as tmpdir:
             first = Path(tmpdir) / "shard_0.xml"
             second = Path(tmpdir) / "shard_1.xml"
+            first_log = Path(tmpdir) / "shard_0.log"
+            second_log = Path(tmpdir) / "shard_1.log"
             first.write_text(_JUNIT_XML)
             second.write_text(_JUNIT_XML)
+            first_log.write_text("PASS\n")
+            second_log.write_text("PASS\n")
 
             bep_path = Path(tmpdir) / "bep.json"
             bep_path.write_text(
@@ -209,27 +229,57 @@ def test_repeated_test_result_for_same_label_all_kept(self):
                         _bep_line(
                             {
                                 "id": {"testResult": {"label": "//pkg/foo:foo_test", "configuration": {"id": "cfg1"}}},
-                                "testResult": {"testActionOutput": [{"name": "test.xml", "uri": first.as_uri()}]},
+                                "testResult": {
+                                    "testActionOutput": [
+                                        {"name": "test.xml", "uri": first.as_uri()},
+                                        {"name": "test.log", "uri": first_log.as_uri()},
+                                    ]
+                                },
                             }
                         ),
                         _bep_line(
                             {
                                 "id": {"testResult": {"label": "//pkg/foo:foo_test", "configuration": {"id": "cfg1"}}},
-                                "testResult": {"testActionOutput": [{"name": "test.xml", "uri": second.as_uri()}]},
+                                "testResult": {
+                                    "testActionOutput": [
+                                        {"name": "test.xml", "uri": second.as_uri()},
+                                        {"name": "test.log", "uri": second_log.as_uri()},
+                                    ]
+                                },
                             }
                         ),
                     ]
                 )
             )
 
-            xml_paths, _ = _parse_bep(bep_path)
-            self.assertEqual(sorted(xml_paths), sorted([first, second]))
+            artifacts = _parse_bep(bep_path)
+            self.assertEqual(sorted(artifacts[f"{_IMPORT_PREFIX}/pkg/foo"]["xml_paths"]), sorted([first, second]))
+            self.assertEqual(
+                sorted(artifacts[f"{_IMPORT_PREFIX}/pkg/foo"]["log_paths"]), sorted([first_log, second_log])
+            )
 
     def test_no_test_result_events_produces_nothing(self):
         with tempfile.TemporaryDirectory() as tmpdir:
             bep_path = Path(tmpdir) / "bep.json"
             bep_path.write_text(_bep_line({"id": {"workspace": {}}, "workspaceInfo": {"localExecRoot": "/exec/root"}}))
-            self.assertEqual(_parse_bep(bep_path), ([], {}))
+            self.assertEqual(_parse_bep(bep_path), {})
+
+    def test_missing_log_is_error(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            xml_path = Path(tmpdir) / "test.xml"
+            xml_path.write_text(_JUNIT_XML)
+            bep_path = Path(tmpdir) / "bep.json"
+            bep_path.write_text(
+                _bep_line(
+                    {
+                        "id": {"testResult": {"label": "//pkg/foo:foo_test", "configuration": {"id": "cfg1"}}},
+                        "testResult": {"testActionOutput": [{"name": "test.xml", "uri": xml_path.as_uri()}]},
+                    }
+                )
+            )
+
+            with self.assertRaisesRegex(RuntimeError, "did not include .*test.log"):
+                _parse_bep(bep_path)
 
 
 class TestBazelTestFuncsFromBep(unittest.TestCase):

From 9259d96120799b52b4cb8229378562777534b5c8 Mon Sep 17 00:00:00 2001
From: Alex Lopez <alex.lopez@datadoghq.com>
Date: Mon, 10 Aug 2026 17:05:02 +0200
Subject: [PATCH 3/9] Add tool to get json from the logs

---
 bazel/tools/testlogs_to_json/BUILD.bazel      |  23 ++++
 .../testlogs_to_json/testlogs_to_json.go      | 130 ++++++++++++++++++
 .../testlogs_to_json/testlogs_to_json_test.go | 106 ++++++++++++++
 3 files changed, 259 insertions(+)
 create mode 100644 bazel/tools/testlogs_to_json/BUILD.bazel
 create mode 100644 bazel/tools/testlogs_to_json/testlogs_to_json.go
 create mode 100644 bazel/tools/testlogs_to_json/testlogs_to_json_test.go

diff --git a/bazel/tools/testlogs_to_json/BUILD.bazel b/bazel/tools/testlogs_to_json/BUILD.bazel
new file mode 100644
index 000000000000..78c98691e012
--- /dev/null
+++ b/bazel/tools/testlogs_to_json/BUILD.bazel
@@ -0,0 +1,23 @@
+load("@rules_go//go:def.bzl", "go_binary", "go_library", "go_test")
+
+go_library(
+    name = "testlogs_to_json_lib",
+    srcs = ["testlogs_to_json.go"],
+    importpath = "github.com/DataDog/datadog-agent/bazel/tools/testlogs_to_json",
+    visibility = ["//visibility:private"],
+    deps = ["@rules_go//go/tools/bzltestutil"],
+)
+
+go_binary(
+    name = "testlogs_to_json",
+    embed = [":testlogs_to_json_lib"],
+    visibility = ["//visibility:public"],
+)
+
+# gazelle:dd_agent_go_test off
+go_test(
+    name = "testlogs_to_json_test",
+    srcs = ["testlogs_to_json_test.go"],
+    embed = [":testlogs_to_json_lib"],
+    gotags = [],  # keep
+)
diff --git a/bazel/tools/testlogs_to_json/testlogs_to_json.go b/bazel/tools/testlogs_to_json/testlogs_to_json.go
new file mode 100644
index 000000000000..f5582c16a20f
--- /dev/null
+++ b/bazel/tools/testlogs_to_json/testlogs_to_json.go
@@ -0,0 +1,130 @@
+package main
+
+import (
+	"bufio"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/bazelbuild/rules_go/go/tools/bzltestutil"
+)
+
+type manifestEntry struct {
+	pkg     string
+	logPath string
+}
+
+type options struct {
+	manifestPath string
+	outputPath   string
+}
+
+func main() {
+	if err := run(os.Args[1:], os.Stdout, os.Stderr); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func run(args []string, stdout, stderr io.Writer) error {
+	opts, err := parseFlags(args)
+	if err != nil {
+		return err
+	}
+
+	entries, err := readManifest(opts.manifestPath)
+	if err != nil {
+		return err
+	}
+
+	var out io.Writer = stdout
+	var outFile *os.File
+	if opts.outputPath != "" && opts.outputPath != "-" {
+		outFile, err = os.Create(opts.outputPath)
+		if err != nil {
+			return fmt.Errorf("create output %q: %w", opts.outputPath, err)
+		}
+		defer outFile.Close()
+		out = outFile
+	}
+
+	if err := convert(entries, out); err != nil {
+		return err
+	}
+
+	fmt.Fprintf(stderr, "Converted %d Bazel test logs to test2json\n", len(entries))
+	return nil
+}
+
+func parseFlags(args []string) (options, error) {
+	var opts options
+	fs := flag.NewFlagSet("testlogs_to_json", flag.ContinueOnError)
+	fs.SetOutput(io.Discard)
+	fs.StringVar(&opts.manifestPath, "manifest", "", "Path to a tab-separated manifest: <go import path>\\t<test.log path>")
+	fs.StringVar(&opts.outputPath, "output", "-", "Path to write test2json JSONL output, or '-' for stdout")
+	if err := fs.Parse(args); err != nil {
+		return opts, err
+	}
+	if opts.manifestPath == "" {
+		return opts, errors.New("missing required -manifest")
+	}
+	if fs.NArg() != 0 {
+		return opts, fmt.Errorf("unexpected positional arguments: %s", strings.Join(fs.Args(), " "))
+	}
+	return opts, nil
+}
+
+func readManifest(path string) ([]manifestEntry, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, fmt.Errorf("open manifest %q: %w", path, err)
+	}
+	defer f.Close()
+
+	var entries []manifestEntry
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.TrimSpace(line) == "" {
+			continue
+		}
+		pkg, logPath, ok := strings.Cut(line, "\t")
+		if !ok || pkg == "" || logPath == "" {
+			return nil, fmt.Errorf("invalid manifest line: expected <go import path>\\t<test.log path>, got %q", line)
+		}
+		if strings.Contains(logPath, "\t") {
+			return nil, fmt.Errorf("invalid manifest line: too many tab-separated fields, got %q", line)
+		}
+		entries = append(entries, manifestEntry{pkg: pkg, logPath: logPath})
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("read manifest %q: %w", path, err)
+	}
+	return entries, nil
+}
+
+func convert(entries []manifestEntry, out io.Writer) error {
+	for _, entry := range entries {
+		f, err := os.Open(entry.logPath)
+		if err != nil {
+			return fmt.Errorf("open test log %q for package %s: %w", entry.logPath, entry.pkg, err)
+		}
+
+		converter := bzltestutil.NewConverter(out, entry.pkg, bzltestutil.Timestamp)
+		_, copyErr := io.Copy(converter, f)
+		closeErr := f.Close()
+		if copyErr != nil {
+			return fmt.Errorf("convert test log %q for package %s: %w", entry.logPath, entry.pkg, copyErr)
+		}
+		if closeErr != nil {
+			return fmt.Errorf("close test log %q for package %s: %w", entry.logPath, entry.pkg, closeErr)
+		}
+		if err := converter.Close(); err != nil {
+			return fmt.Errorf("close converter for test log %q package %s: %w", entry.logPath, entry.pkg, err)
+		}
+	}
+	return nil
+}
diff --git a/bazel/tools/testlogs_to_json/testlogs_to_json_test.go b/bazel/tools/testlogs_to_json/testlogs_to_json_test.go
new file mode 100644
index 000000000000..3999c8a5af67
--- /dev/null
+++ b/bazel/tools/testlogs_to_json/testlogs_to_json_test.go
@@ -0,0 +1,106 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestReadManifest(t *testing.T) {
+	dir := t.TempDir()
+	manifestPath := filepath.Join(dir, "manifest.tsv")
+	if err := os.WriteFile(manifestPath, []byte(strings.Join([]string{
+		"",
+		"github.com/DataDog/datadog-agent/pkg/foo\t/path/to/foo.log",
+		"github.com/DataDog/datadog-agent/pkg/bar\t/path with spaces/bar.log",
+	}, "\n")), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	entries, err := readManifest(manifestPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want := []manifestEntry{
+		{pkg: "github.com/DataDog/datadog-agent/pkg/foo", logPath: "/path/to/foo.log"},
+		{pkg: "github.com/DataDog/datadog-agent/pkg/bar", logPath: "/path with spaces/bar.log"},
+	}
+	if len(entries) != len(want) {
+		t.Fatalf("got %d entries, want %d: %#v", len(entries), len(want), entries)
+	}
+	for i := range want {
+		if entries[i] != want[i] {
+			t.Fatalf("entry %d = %#v, want %#v", i, entries[i], want[i])
+		}
+	}
+}
+
+func TestReadManifestRejectsInvalidLine(t *testing.T) {
+	dir := t.TempDir()
+	manifestPath := filepath.Join(dir, "manifest.tsv")
+	if err := os.WriteFile(manifestPath, []byte("github.com/DataDog/datadog-agent/pkg/foo /path/to/foo.log\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := readManifest(manifestPath)
+	if err == nil || !strings.Contains(err.Error(), "invalid manifest line") {
+		t.Fatalf("expected invalid manifest error, got %v", err)
+	}
+}
+
+func TestConvertMultipleLogs(t *testing.T) {
+	dir := t.TempDir()
+	fooLog := filepath.Join(dir, "foo.log")
+	barLog := filepath.Join(dir, "bar.log")
+	if err := os.WriteFile(fooLog, []byte("=== RUN   TestFoo\n--- PASS: TestFoo (0.01s)\nPASS\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(barLog, []byte("=== RUN   TestBar\n    bar_test.go:12: boom\n--- FAIL: TestBar (0.02s)\nFAIL\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	var out bytes.Buffer
+	err := convert([]manifestEntry{
+		{pkg: "github.com/DataDog/datadog-agent/pkg/foo", logPath: fooLog},
+		{pkg: "github.com/DataDog/datadog-agent/pkg/bar", logPath: barLog},
+	}, &out)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var events []map[string]any
+	for _, line := range strings.Split(strings.TrimSpace(out.String()), "\n") {
+		var event map[string]any
+		if err := json.Unmarshal([]byte(line), &event); err != nil {
+			t.Fatalf("invalid JSON line %q: %v", line, err)
+		}
+		events = append(events, event)
+	}
+
+	assertEvent(t, events, "github.com/DataDog/datadog-agent/pkg/foo", "TestFoo", "pass")
+	assertEvent(t, events, "github.com/DataDog/datadog-agent/pkg/foo", "", "pass")
+	assertEvent(t, events, "github.com/DataDog/datadog-agent/pkg/bar", "TestBar", "fail")
+	assertEvent(t, events, "github.com/DataDog/datadog-agent/pkg/bar", "", "fail")
+}
+
+func assertEvent(t *testing.T, events []map[string]any, pkg, testName, action string) {
+	t.Helper()
+	for _, event := range events {
+		if event["Package"] == pkg && event["Action"] == action {
+			if testName == "" {
+				if _, ok := event["Test"]; !ok {
+					return
+				}
+				continue
+			}
+			if event["Test"] == testName {
+				return
+			}
+		}
+	}
+	t.Fatalf("did not find event package=%q test=%q action=%q in %#v", pkg, testName, action, events)
+}

From fb5dca79ba50aa3020d04d5398aa976338348750 Mon Sep 17 00:00:00 2001
From: Alex Lopez <alex.lopez@datadoghq.com>
Date: Mon, 10 Aug 2026 17:29:49 +0200
Subject: [PATCH 4/9] Create new task for all post processing, add json output
 to it

---
 .gitlab/build/bazel/test.yml |  3 +-
 tasks/bazel.py               | 56 +++++++++++++++++++++++++++++-------
 2 files changed, 47 insertions(+), 12 deletions(-)

diff --git a/.gitlab/build/bazel/test.yml b/.gitlab/build/bazel/test.yml
index 39f16f558961..0658cd92ad63 100644
--- a/.gitlab/build/bazel/test.yml
+++ b/.gitlab/build/bazel/test.yml
@@ -15,8 +15,9 @@
   variables:
     EXTERNAL_LINKS_PATH: external_links_$CI_JOB_ID.json
     BEP_FILE: $CI_PROJECT_DIR/bazel-bep.json
+    RESULT_JSON: output.json
   after_script:
-    - dda inv -- -e bazel.collect-junit --output-tgz=junit-${CI_JOB_NAME}.tgz --bep-file=$BEP_FILE
+    - dda inv -- -e bazel.process-test-results --bep-file=$BEP_FILE --junit-tar=junit-${CI_JOB_NAME}.tgz --result-json=$RESULT_JSON
     - !reference [.upload_junit_source]
   artifacts:
     expire_in: 2 weeks
diff --git a/tasks/bazel.py b/tasks/bazel.py
index 2a7849b81dcf..3aafa7f873d9 100644
--- a/tasks/bazel.py
+++ b/tasks/bazel.py
@@ -427,13 +427,7 @@ def _annotate_junit_cache_status(xml_path: Path, cache_status: dict[str, bool])
     tree.write(str(xml_path))
 
 
-@task(
-    help={
-        "output_tgz": "Destination path for the output tgz (e.g. junit-bazel-base.tgz).",
-        "bep_file": "Path to a Bazel BEP JSON file (--build_event_json_file); drives test.xml discovery and annotates each testsuite with bazel.cached.",
-    },
-)
-def collect_junit(ctx, output_tgz, bep_file):
+def _collect_junit(test_artifacts, output_tgz):
     """Collect Bazel test results and package them for junit_upload.
 
     Merges the test.xml files produced by the rules_go test runner (one per
@@ -443,10 +437,6 @@ def collect_junit(ctx, output_tgz, bep_file):
     """
     from tasks.libs.common.junit_upload_core import produce_junit_tar
 
-    # BEP is the authoritative source: it lists exactly the test.xml and test.out files
-    # produced by this invocation, avoiding stale results from previous runs
-    # with a different Bazel configuration.
-    test_artifacts = _parse_bep(Path(bep_file))
     xml_files = [p for artifacts in test_artifacts.values() for p in artifacts["xml_paths"]]
     cache_status = {import_path: artifacts["cached"] for import_path, artifacts in test_artifacts.items()}
     if not xml_files:
@@ -492,3 +482,47 @@ def collect_junit(ctx, output_tgz, bep_file):
         produce_junit_tar([str(merged_path)], output_tgz)
 
     print(f"Packaged {collected} test suites → {output_tgz}")
+
+
+def _collect_test2json(ctx, test_artifacts, output_path):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        manifest_path = os.path.join(tmpdir, "manifest.tsv")
+        with open(manifest_path, "w") as manifest:
+            for entry in sorted(test_artifacts.keys()):
+                manifest.writelines(f'{entry}\t{log_path}\n' for log_path in test_artifacts[entry]["log_paths"])
+
+        bazel(
+            ctx,
+            "run",
+            "//bazel/tools/testlogs_to_json",
+            "--",
+            "-manifest",
+            manifest_path,
+            "-output",
+            os.path.abspath(output_path),
+        )
+
+
+@task(
+    help={
+        "bep_file": "Path to a Bazel BEP JSON file (--build_event_json_file) used to gather all necessary data.",
+    },
+)
+def process_test_results(ctx, bep_file, result_json, junit_tar):
+    """Collect results from Bazel-run tests and produce various artifacts.
+
+    This task:
+    - Produces a tgz JUnit XML file compatible with our existing upload machinery.
+    - Produces a test2json file with test results and a UTOF json file created from it.
+    - Displays test results in a human-friendly way (based on UTOF).
+    """
+    # BEP is the authoritative source: it lists exactly the test.xml and test.out files
+    # produced by this invocation, avoiding stale results from previous runs
+    # with a different Bazel configuration.
+    test_artifacts = _parse_bep(Path(bep_file))
+
+    # Produce the junit tar
+    _collect_junit(test_artifacts, junit_tar)
+
+    # Produce the test2json result file
+    _collect_test2json(ctx, test_artifacts, result_json)

From c8a2a19d70df1152c8f6e14ac103a4ce6d41d981 Mon Sep 17 00:00:00 2001
From: Alex Lopez <alex.lopez@datadoghq.com>
Date: Mon, 10 Aug 2026 18:07:12 +0200
Subject: [PATCH 5/9] UTOF support

---
 .gitlab/build/bazel/test.yml    | 10 +++++++---
 tasks/bazel.py                  | 28 +++++++++++++++++++---------
 tasks/unit_tests/bazel_tests.py | 14 ++++++++------
 3 files changed, 34 insertions(+), 18 deletions(-)

diff --git a/.gitlab/build/bazel/test.yml b/.gitlab/build/bazel/test.yml
index 0658cd92ad63..316f34262bab 100644
--- a/.gitlab/build/bazel/test.yml
+++ b/.gitlab/build/bazel/test.yml
@@ -15,7 +15,7 @@
   variables:
     EXTERNAL_LINKS_PATH: external_links_$CI_JOB_ID.json
     BEP_FILE: $CI_PROJECT_DIR/bazel-bep.json
-    RESULT_JSON: output.json
+    RESULT_JSON: test_output.json
   after_script:
     - dda inv -- -e bazel.process-test-results --bep-file=$BEP_FILE --junit-tar=junit-${CI_JOB_NAME}.tgz --result-json=$RESULT_JSON
     - !reference [.upload_junit_source]
@@ -23,8 +23,10 @@
     expire_in: 2 weeks
     when: always
     paths:
+      - $RESULT_JSON
+      - test_output_unified.json
       - junit-*.tgz
-      - bazel-bep-*.json
+      - bazel-bep.json
     reports:
       annotations:
         - $EXTERNAL_LINKS_PATH
@@ -81,8 +83,10 @@ bazel:test:macos-arm64:
     - !reference [.bazel:test:reporting, after_script]
   artifacts:
     paths:
+      - $RESULT_JSON
+      - test_output_unified.json
       - junit-*.tgz
-      - bazel-bep-*.json
+      - bazel-bep.json
       - bazel-exec.log
 
 # Windows splits the build from the Go tests, unlike the other platforms: the
diff --git a/tasks/bazel.py b/tasks/bazel.py
index 3aafa7f873d9..f14cebc9b7ba 100644
--- a/tasks/bazel.py
+++ b/tasks/bazel.py
@@ -319,8 +319,8 @@ def ensure_test_parity(ctx, bep, flavor_name, verbose=False, emit_metrics=False)
 
 class BepTestArtifacts(TypedDict):
     cached: bool
-    xml_paths: list[Path]
-    log_paths: list[Path]
+    xml_paths: list[Path]  # noqa: F841 - TypedDict field, not a local variable
+    log_paths: list[Path]  # noqa: F841 - TypedDict field, not a local variable
 
 
 def _resolve_test_output_path(
@@ -488,8 +488,10 @@ def _collect_test2json(ctx, test_artifacts, output_path):
     with tempfile.TemporaryDirectory() as tmpdir:
         manifest_path = os.path.join(tmpdir, "manifest.tsv")
         with open(manifest_path, "w") as manifest:
-            for entry in sorted(test_artifacts.keys()):
-                manifest.writelines(f'{entry}\t{log_path}\n' for log_path in test_artifacts[entry]["log_paths"])
+            for import_path in sorted(test_artifacts.keys()):
+                manifest.writelines(
+                    f'{import_path}\t{log_path}\n' for log_path in test_artifacts[import_path]["log_paths"]
+                )
 
         bazel(
             ctx,
@@ -506,9 +508,11 @@ def _collect_test2json(ctx, test_artifacts, output_path):
 @task(
     help={
         "bep_file": "Path to a Bazel BEP JSON file (--build_event_json_file) used to gather all necessary data.",
+        "result_json": "Path to write test2json JSONL output.",
+        "junit_tar": "Path to write the JUnit tgz.",
     },
 )
-def process_test_results(ctx, bep_file, result_json, junit_tar):
+def process_test_results(ctx, bep_file, result_json="test_output.json", junit_tar=""):
     """Collect results from Bazel-run tests and produce various artifacts.
 
     This task:
@@ -516,13 +520,19 @@ def process_test_results(ctx, bep_file, result_json, junit_tar):
     - Produces a test2json file with test results and a UTOF json file created from it.
     - Displays test results in a human-friendly way (based on UTOF).
     """
-    # BEP is the authoritative source: it lists exactly the test.xml and test.out files
+    # BEP is the authoritative source: it lists exactly the test.xml and test.log files
     # produced by this invocation, avoiding stale results from previous runs
     # with a different Bazel configuration.
     test_artifacts = _parse_bep(Path(bep_file))
 
-    # Produce the junit tar
-    _collect_junit(test_artifacts, junit_tar)
-
     # Produce the test2json result file
     _collect_test2json(ctx, test_artifacts, result_json)
+
+    # Produce UTOF and associated terminal output
+    from tasks.libs.testing.utof.go.generate import generate_unified_output
+
+    generate_unified_output(ctx, result_json, "bazel", "")
+
+    # Produce the junit tar
+    if junit_tar:
+        _collect_junit(test_artifacts, junit_tar)
diff --git a/tasks/unit_tests/bazel_tests.py b/tasks/unit_tests/bazel_tests.py
index f722e21df6e1..4e7e162f89be 100644
--- a/tasks/unit_tests/bazel_tests.py
+++ b/tasks/unit_tests/bazel_tests.py
@@ -12,7 +12,7 @@
     _is_gotestsum_shaped,
     _label_to_import_path,
     _parse_bep,
-    _test_xml_candidates,
+    _test_output_candidates,
     _test_xml_funcs,
 )
 
@@ -30,26 +30,28 @@ def test_root_package(self):
 
 class TestTestXmlCandidates(unittest.TestCase):
     def test_file_uri_only(self):
-        paths = _test_xml_candidates("//pkg/foo:bar_test", "file:///tmp/test.xml", "cfg1", None, {})
+        paths = _test_output_candidates("//pkg/foo:bar_test", "file:///tmp/test.xml", "cfg1", None, {}, "test.xml")
         self.assertEqual(paths, [Path("/tmp/test.xml")])
 
     def test_bytestream_uri_reconstructed_from_testlogs(self):
-        paths = _test_xml_candidates(
+        paths = _test_output_candidates(
             "//pkg/foo:bar_test",
             "bytestream://example/blobs/abc/123",
             "cfg1",
             "/exec/root",
             {"cfg1": Path("bazel-out/k8-fastbuild/testlogs")},
+            "test.xml",
         )
         self.assertEqual(paths, [Path("/exec/root/bazel-out/k8-fastbuild/testlogs/pkg/foo/bar_test/test.xml")])
 
     def test_both_candidates_in_priority_order(self):
-        paths = _test_xml_candidates(
+        paths = _test_output_candidates(
             "//pkg/foo:bar_test",
             "file:///tmp/test.xml",
             "cfg1",
             "/exec/root",
             {"cfg1": Path("bazel-out/k8-fastbuild/testlogs")},
+            "test.xml",
         )
         self.assertEqual(
             paths,
@@ -60,8 +62,8 @@ def test_both_candidates_in_priority_order(self):
         )
 
     def test_no_candidates_when_config_unknown(self):
-        paths = _test_xml_candidates(
-            "//pkg/foo:bar_test", "bytestream://example/blobs/abc/123", "cfg1", "/exec/root", {}
+        paths = _test_output_candidates(
+            "//pkg/foo:bar_test", "bytestream://example/blobs/abc/123", "cfg1", "/exec/root", {}, "test.xml"
         )
         self.assertEqual(paths, [])
 

From afab3eacbb983e7616c14dbe490f8d4674ec092e Mon Sep 17 00:00:00 2001
From: Alex Lopez <alex.lopez@datadoghq.com>
Date: Mon, 10 Aug 2026 18:38:42 +0200
Subject: [PATCH 6/9] Add copyright header to new tool code

---
 bazel/tools/testlogs_to_json/testlogs_to_json.go      | 5 +++++
 bazel/tools/testlogs_to_json/testlogs_to_json_test.go | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/bazel/tools/testlogs_to_json/testlogs_to_json.go b/bazel/tools/testlogs_to_json/testlogs_to_json.go
index f5582c16a20f..33281ff0cc64 100644
--- a/bazel/tools/testlogs_to_json/testlogs_to_json.go
+++ b/bazel/tools/testlogs_to_json/testlogs_to_json.go
@@ -1,3 +1,8 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2026-present Datadog, Inc.
+
 package main
 
 import (
diff --git a/bazel/tools/testlogs_to_json/testlogs_to_json_test.go b/bazel/tools/testlogs_to_json/testlogs_to_json_test.go
index 3999c8a5af67..6147870d176e 100644
--- a/bazel/tools/testlogs_to_json/testlogs_to_json_test.go
+++ b/bazel/tools/testlogs_to_json/testlogs_to_json_test.go
@@ -1,3 +1,8 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2026-present Datadog, Inc.
+
 package main
 
 import (

From d222638eec5b43f599d34d22db30bc47f584afea Mon Sep 17 00:00:00 2001
From: Alex Lopez <alex.lopez@datadoghq.com>
Date: Mon, 10 Aug 2026 18:52:44 +0200
Subject: [PATCH 7/9] Upload all artifacts on coverage job

---
 .gitlab/build/bazel/test.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.gitlab/build/bazel/test.yml b/.gitlab/build/bazel/test.yml
index 316f34262bab..3f267b44b88f 100644
--- a/.gitlab/build/bazel/test.yml
+++ b/.gitlab/build/bazel/test.yml
@@ -44,8 +44,10 @@ bazel:coverage:linux-amd64:
     - cp "$(bazel info output_path)/_coverage/_coverage_report.dat" "$CI_PROJECT_DIR/coverage-bazel-$CI_JOB_NAME_SLUG.out"
   artifacts:
     paths:
+      - $RESULT_JSON
+      - test_output_unified.json
       - junit-*.tgz
-      - bazel-bep-*.json
+      - bazel-bep.json
       - coverage-bazel-*.out
   variables:
     KUBERNETES_CPU_REQUEST: 16

From b0f1265448ee4dd69297e2893e98605db01c3a9f Mon Sep 17 00:00:00 2001
From: Alex Lopez <alex.lopez@datadoghq.com>
Date: Mon, 10 Aug 2026 19:15:05 +0200
Subject: [PATCH 8/9] Update license data

---
 LICENSE-3rdparty.csv | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/LICENSE-3rdparty.csv b/LICENSE-3rdparty.csv
index 7628b1cedc22..5198c6f4b121 100644
--- a/LICENSE-3rdparty.csv
+++ b/LICENSE-3rdparty.csv
@@ -849,6 +849,9 @@ core,github.com/awslabs/operatorpkg/unstructured,Apache-2.0,"Copyright Amazon.co
 core,github.com/aymerick/raymond/lexer,MIT,Copyright (c) 2015 Aymerick JEHANNE
 core,github.com/bahlo/generic-list-go,BSD-3-Clause,Copyright (c) 2009 The Go Authors. All rights reserved
 core,github.com/bazelbuild/rules_go/go/runfiles,Apache-2.0,Benjamin Staffin <benley@gmail.com> | Brian Silverman <bsilver16384@gmail.com> | Damien Martin-Guillerez <dmarting@google.com> | David Chen <dzc@google.com> | David Santiago <david.santiago@gmail.com> | David Zbarsky <dzbarsky@gmail.com> | Fabian Meumertzheim <fabian@meumertzhe.im> | Google Inc. | Han-Wen Nienhuys <hanwen@google.com> | Ian Cottrell <iancottrell@google.com> | Jake Voytko <jake@reviewninja.com> | Jay Conrod <jayconrod@google.com> | Josh Powell <powelljo@us.ibm.com> | Justine Alexandra Roberts Tunney <jart@google.com> | Kristina Chodorow <kchodorow@google.com> | Lukacs Berki <lberki@google.com> | Tyler French <french.tyler.d@gmail.com> | Yuki Yugui Sonoda <yugui@yugui.jp>
+core,github.com/bazelbuild/rules_go/go/tools/bzltestutil,Apache-2.0,Benjamin Staffin <benley@gmail.com> | Brian Silverman <bsilver16384@gmail.com> | Damien Martin-Guillerez <dmarting@google.com> | David Chen <dzc@google.com> | David Santiago <david.santiago@gmail.com> | David Zbarsky <dzbarsky@gmail.com> | Fabian Meumertzheim <fabian@meumertzhe.im> | Google Inc. | Han-Wen Nienhuys <hanwen@google.com> | Ian Cottrell <iancottrell@google.com> | Jake Voytko <jake@reviewninja.com> | Jay Conrod <jayconrod@google.com> | Josh Powell <powelljo@us.ibm.com> | Justine Alexandra Roberts Tunney <jart@google.com> | Kristina Chodorow <kchodorow@google.com> | Lukacs Berki <lberki@google.com> | Tyler French <french.tyler.d@gmail.com> | Yuki Yugui Sonoda <yugui@yugui.jp>
+core,github.com/bazelbuild/rules_go/go/tools/bzltestutil/chdir,Apache-2.0,Benjamin Staffin <benley@gmail.com> | Brian Silverman <bsilver16384@gmail.com> | Damien Martin-Guillerez <dmarting@google.com> | David Chen <dzc@google.com> | David Santiago <david.santiago@gmail.com> | David Zbarsky <dzbarsky@gmail.com> | Fabian Meumertzheim <fabian@meumertzhe.im> | Google Inc. | Han-Wen Nienhuys <hanwen@google.com> | Ian Cottrell <iancottrell@google.com> | Jake Voytko <jake@reviewninja.com> | Jay Conrod <jayconrod@google.com> | Josh Powell <powelljo@us.ibm.com> | Justine Alexandra Roberts Tunney <jart@google.com> | Kristina Chodorow <kchodorow@google.com> | Lukacs Berki <lberki@google.com> | Tyler French <french.tyler.d@gmail.com> | Yuki Yugui Sonoda <yugui@yugui.jp>
+core,github.com/bazelbuild/rules_go/go/tools/coverdata,Apache-2.0,Benjamin Staffin <benley@gmail.com> | Brian Silverman <bsilver16384@gmail.com> | Damien Martin-Guillerez <dmarting@google.com> | David Chen <dzc@google.com> | David Santiago <david.santiago@gmail.com> | David Zbarsky <dzbarsky@gmail.com> | Fabian Meumertzheim <fabian@meumertzhe.im> | Google Inc. | Han-Wen Nienhuys <hanwen@google.com> | Ian Cottrell <iancottrell@google.com> | Jake Voytko <jake@reviewninja.com> | Jay Conrod <jayconrod@google.com> | Josh Powell <powelljo@us.ibm.com> | Justine Alexandra Roberts Tunney <jart@google.com> | Kristina Chodorow <kchodorow@google.com> | Lukacs Berki <lberki@google.com> | Tyler French <french.tyler.d@gmail.com> | Yuki Yugui Sonoda <yugui@yugui.jp>
 core,github.com/bboreham/go-loser,Apache-2.0,bboreham <bjboreham@gmail.com>
 core,github.com/beevik/ntp,BSD-2-Clause,Al Cutter (AlCutter) | Andrey Smirnov (smira) | Anton Tolchanov (knyar) | Ask Bjørn Hansen (abh) | Brett Vickers (beevik) | Christian Cedercrantz (chrisceder) | Christopher Batey (chbatey) | Copyright © 2015-2023 Brett Vickers. All rights reserved | Leonid Evdokimov (darkk) | Meng Zhuo (mengzhuo) | Mikhail Salosin (AlphaB) | Silves-Xiang (silves-xiang)
 core,github.com/benbjohnson/clock,MIT,Copyright (c) 2014 Ben Johnson

From e161dd0cd9d232cf932161a165b5229d58b63303 Mon Sep 17 00:00:00 2001
From: Alex Lopez <alex.lopez@datadoghq.com>
Date: Mon, 10 Aug 2026 20:56:10 +0200
Subject: [PATCH 9/9] Force remote download of .log files just in case

---
 .bazelrc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.bazelrc b/.bazelrc
index a7b1487b0a3f..670b330e5a87 100644
--- a/.bazelrc
+++ b/.bazelrc
@@ -108,6 +108,7 @@ common:ci --config=adms
 common:ci --config=lint
 common:ci --noexperimental_convenience_symlinks # not CI-suitable: "These symlinks are only for the user's convenience"
 common:ci --remote_download_regex=.*/test\.xml$ # force-download test.xml even under --remote_download_outputs=toplevel, so junit collection can read it locally
+common:ci --remote_download_regex=.*/test\.log$ # force-download test.log for test2json postprocessing
 
 # Project/Language configs --------------------------------------------------------------------------------------
 import %workspace%/bazel/configs/go_tests.bazelrc