fix(core): address Codex review on --trace

- Skip Perfetto helper server in non-TTY runs. `rstest run` previously
  awaited `traceController.waitForExit()` unconditionally, which hangs
  CI because the signal it waits for never arrives. `finalize()` now
  checks `process.stdin.isTTY` and writes the file without starting
  the server in non-interactive contexts.
- Give each PhaseTracker a unique `tid`. With `isolate: false` a worker
  runs multiple test files, and the previous "first testPath per pid"
  metadata collapsed every later file to the first one's label. Each
  tracker now gets a per-process incrementing tid; `buildTraceFile`
  emits `process_name = "worker <pid>"` once per pid and
  `thread_name = <test file>` once per (pid, tid), so multi-file
  workers render as separate thread tracks in Perfetto.

Author: fi3ework

packages/core/src/runtime/worker/phaseTracker.ts

@@ -42,17 +42,20 @@ type SliceCat = 'phase' | 'suite' | 'case';
  * - heap-usage counter samples (`ph: 'C'`, `cat: 'memory'`) at each phase
  *   boundary, so memory pressure shows up as a track in Perfetto UI
  *
- * All events use `pid = process.pid`. The host later merges these into a
- * single trace JSON file.
+ * All events use `pid = process.pid`. Each tracker (i.e. each test file)
+ * gets its own `tid`, so when a worker is reused across multiple files
+ * (`isolate: false`) each file shows up as its own thread track in
+ * Perfetto instead of collapsing to the first file's label. The host
+ * later merges every worker's events into a single trace JSON file.
  */
 export class PhaseTracker {
   private currentPhase: PhaseName | null = null;
   private currentStart = 0;
   private hasData = false;
   private readonly totals: PhaseTimings = emptyPhaseTimings();
   private readonly trace: TraceState | null;
-  /** Workers are single-threaded; pid doubles as tid for Perfetto tracks. */
   private readonly pid = process.pid;
+  private readonly tid = nextThreadId++;
 
   constructor(options: PhaseTrackerOptions = {}) {
     this.trace = options.trace
@@ -152,7 +155,7 @@ export class PhaseTracker {
       ts: startMs * 1000,
       dur: durMs * 1000,
       pid: this.pid,
-      tid: this.pid,
+      tid: this.tid,
       args: {
         testPath: this.trace.meta.testPath,
         project: this.trace.meta.project,
@@ -170,7 +173,7 @@ export class PhaseTracker {
       ph: 'C',
       ts: nowMs * 1000,
       pid: this.pid,
-      tid: this.pid,
+      tid: this.tid,
       args: {
         heapUsedMB: round2(mem.heapUsed / 1024 / 1024),
         heapTotalMB: round2(mem.heapTotal / 1024 / 1024),
@@ -181,3 +184,10 @@ export class PhaseTracker {
 }
 
 const round2 = (n: number): number => Math.round(n * 100) / 100;
+
+/**
+ * Monotonic counter for `tid` assignment within a worker process. Resets per
+ * process (each fork starts at 1), which is fine because Perfetto's `tid` is
+ * only required to be unique within a `pid`.
+ */
+let nextThreadId = 1;

packages/core/src/utils/trace.ts

@@ -42,14 +42,15 @@ const getTraceOutputPath = (rootPath: string): string => {
 
 /**
  * Wrap raw phase events into the Perfetto trace JSON envelope and prepend
- * per-pid metadata so each worker shows up under its test file name
- * (relative to `rootPath`) instead of the default `Process <pid>` label.
+ * Perfetto metadata so each (pid, tid) renders with the right label.
  *
- * Metadata emitted per pid:
- * - `process_name`: friendly test file path
- * - `process_sort_index`: order of first appearance, so the Perfetto UI
- *   lists files roughly in execution order instead of by pid
- * - `thread_name`: a stable "worker" label on the main thread
+ * - `process_name` (per pid) labels the worker as `worker <pid>` so multiple
+ *   files inside the same worker (with `isolate: false`) don't collapse to
+ *   the first file's path.
+ * - `process_sort_index` (per pid) lists workers in the order they first
+ *   produced events, instead of the OS pid order.
+ * - `thread_name` (per pid+tid) labels each tracker's thread track with the
+ *   test file path it ran (relative to `rootPath`).
  */
 const buildTraceFile = (
   events: TraceEvent[],
@@ -70,22 +71,32 @@ const buildTraceFile = (
     args,
   });
 
-  const seen = new Set<number>();
+  const seenPid = new Set<number>();
+  const seenThread = new Set<string>();
   const metadata: TraceEvent[] = [];
   let sortIndex = 0;
   for (const ev of events) {
-    if (seen.has(ev.pid)) continue;
     const testPath =
       typeof ev.args?.testPath === 'string' ? ev.args.testPath : undefined;
     if (!testPath) continue;
-    seen.add(ev.pid);
-    const rel = relative(rootPath, testPath);
-    const display = rel && !rel.startsWith('..') ? rel : testPath;
-    metadata.push(
-      meta('process_name', ev.pid, ev.tid, { name: display }),
-      meta('process_sort_index', ev.pid, ev.tid, { sort_index: sortIndex++ }),
-      meta('thread_name', ev.pid, ev.tid, { name: 'worker' }),
-    );
+
+    if (!seenPid.has(ev.pid)) {
+      seenPid.add(ev.pid);
+      metadata.push(
+        meta('process_name', ev.pid, ev.tid, { name: `worker ${ev.pid}` }),
+        meta('process_sort_index', ev.pid, ev.tid, {
+          sort_index: sortIndex++,
+        }),
+      );
+    }
+
+    const threadKey = `${ev.pid}:${ev.tid}`;
+    if (!seenThread.has(threadKey)) {
+      seenThread.add(threadKey);
+      const rel = relative(rootPath, testPath);
+      const display = rel && !rel.startsWith('..') ? rel : testPath;
+      metadata.push(meta('thread_name', ev.pid, ev.tid, { name: display }));
+    }
   }
   return { traceEvents: [...metadata, ...events] };
 };
@@ -268,6 +279,18 @@ export const createTraceController = (options: {
           color.gray('  Perfetto trace file: '),
           color.cyan(tracePath),
         );
+        // The helper server keeps the event loop alive until SIGINT, which
+        // would hang `rstest run` in CI. Only start it when stdin is a TTY
+        // (i.e. interactive), otherwise leave the file for the user to
+        // download from the CI artifact and open in Perfetto UI manually.
+        if (!process.stdin.isTTY) {
+          logger.log(
+            color.gray(
+              '  Drag the file above into https://ui.perfetto.dev to view.',
+            ),
+          );
+          return;
+        }
         if (!server) {
           try {
             server = await startTraceServer(tracePath);