Fix OrderReporter producing empty test_order.log in parallel DRb mode

## Situation

OrderReporter writes test identifiers in its before_test method, but in
Rails parallel DRb mode (forked processes), before_test is never called.
The parallelization server only calls prerecord and record on the parent
process's reporters. Since tests execute in forked workers via
Minitest.run_one_method (which bypasses reporters entirely), the
test_order.log file is truncated on start and never written to.

This makes it impossible to bisect order-dependent flaky test failures
because the test order is never recorded.

## Execution

Instead of relying on the reporter API (which lacks worker identity in
DRb mode), prepend a TestOrderTracking module onto Minitest::Test that
hooks into before_setup. This fires inside the forked worker process
during run_one_method, where Process.pid correctly identifies the worker.

Each forked worker writes to its own file (test_order.worker-{pid}.log)
with sync writes enabled (workers never call report, so buffered writes
risk data loss on crash). The parent process's main test_order.log is
used in non-parallel mode where the parent is the test process.

On start, stale worker files from previous runs are cleaned up.

Author: gmalette

ruby/lib/minitest/queue/order_reporter.rb

@@ -2,38 +2,87 @@
 require 'minitest/reporters'
 
 class Minitest::Queue::OrderReporter < Minitest::Reporters::BaseReporter
+  # Hook prepended onto Minitest::Test to capture test order from within the
+  # worker process. In DRb parallel mode, reporters only receive prerecord/record
+  # in the parent, but before_setup runs inside the forked worker where we can
+  # identify the process.
+  module TestOrderTracking
+    def before_setup
+      if (reporter = Minitest::Queue::OrderReporter.active_instance)
+        reporter.track_test_order(self.class.name, self.name)
+      end
+      super
+    end
+  end
+
+  class << self
+    attr_accessor :active_instance
+  end
+
   def initialize(options = {})
     @path = options.delete(:path)
-    @file = nil
+    @dir = File.dirname(@path)
+    @basename = File.basename(@path, File.extname(@path))
+    @ext = File.extname(@path)
     @flush_every = Integer(ENV.fetch('CI_QUEUE_ORDER_FLUSH_EVERY', '50'))
     @flush_every = 1 if @flush_every < 1
     @pending = 0
+    @parent_pid = nil
+    @files = {}
+    @mutex = Mutex.new
     super
   end
 
   def start
     super
-    file.truncate(0)
+    @parent_pid = Process.pid
+    self.class.active_instance = self
+
+    # Clean stale worker files from previous runs
+    Dir.glob(File.join(@dir, "#{@basename}.worker-*#{@ext}")).each do |f|
+      File.delete(f)
+    end
+
+    # Truncate the main file
+    file_for_pid(@parent_pid).truncate(0)
   end
 
-  def before_test(test)
-    super
-    file.puts("#{test.class.name}##{test.name}")
+  def track_test_order(klass_name, test_name)
+    pid = Process.pid
+    f = file_for_pid(pid)
+    f.puts("#{klass_name}##{test_name}")
     @pending += 1
     if @pending >= @flush_every
-      file.flush
+      f.flush
       @pending = 0
     end
   end
 
   def report
-    file.flush
-    file.close
+    self.class.active_instance = nil
+    @files.each_value do |f|
+      f.flush
+      f.close
+    end
   end
 
   private
 
-  def file
-    @file ||= File.open(@path, 'a+')
+  def file_for_pid(pid)
+    @mutex.synchronize do
+      @files[pid] ||= begin
+        path = if pid == @parent_pid
+          @path
+        else
+          File.join(@dir, "#{@basename}.worker-#{pid}#{@ext}")
+        end
+        f = File.open(path, 'a+')
+        # Forked workers don't call report, so sync writes to avoid data loss
+        f.sync = true if pid != @parent_pid
+        f
+      end
+    end
   end
 end
+
+Minitest::Test.prepend(Minitest::Queue::OrderReporter::TestOrderTracking)

ruby/test/minitest/queue/order_reporter_test.rb

@@ -9,45 +9,98 @@ def setup
       @reporter = OrderReporter.new(path: log_path)
     end
 
+    def teardown
+      OrderReporter.active_instance = nil
+      # Clean up worker files
+      Dir.glob(File.join(File.dirname(log_path), "test_order.worker-*")).each do |f|
+        File.delete(f)
+      end
+    end
+
     def test_start
       @reporter.start
       @reporter.report
       assert_equal [], File.readlines(log_path).map(&:chomp)
     end
 
-    def test_before_test
+    def test_track_test_order
       @reporter.start
-      @reporter.before_test(runnable('a'))
-      @reporter.before_test(runnable('b'))
+      @reporter.track_test_order('Minitest::Test', 'a')
+      @reporter.track_test_order('Minitest::Test', 'b')
       @reporter.report
       assert_equal ['Minitest::Test#a', 'Minitest::Test#b'], File.readlines(log_path).map(&:chomp)
     end
 
+    def test_before_setup_hook
+      @reporter.start
+      # Simulate what happens when a test runs: before_setup fires the hook
+      test_instance = Minitest::Test.new('a')
+      test_instance.before_setup
+      @reporter.report
+      assert_equal ['Minitest::Test#a'], File.readlines(log_path).map(&:chomp)
+    end
+
     unless truffleruby?
-      def test_forking
-        pid = fork do
-          @reporter.start
+      def test_forked_workers_write_per_pid_files
+        @reporter.start
+
+        pids = 3.times.map do
+          fork do
+            # Simulate a forked worker running tests
+            @reporter.track_test_order('Minitest::Test', "test_#{Process.pid}")
+            # Workers don't call report; sync mode ensures data is written
+          end
+        end
+        pids.each { |pid| Process.waitpid(pid) }
+
+        @reporter.report
+
+        # Main file should be empty (parent ran no tests)
+        assert_equal [], File.readlines(log_path).map(&:chomp)
+
+        # Each worker should have its own file
+        pids.each do |pid|
+          worker_path = File.join(File.dirname(log_path), "test_order.worker-#{pid}.log")
+          assert File.exist?(worker_path), "Expected #{worker_path} to exist"
+          assert_equal ["Minitest::Test#test_#{pid}"], File.readlines(worker_path).map(&:chomp)
         end
-        pids = 5.times.map do
+      end
+
+      def test_forked_workers_via_before_setup_hook
+        @reporter.start
+
+        pids = 3.times.map do
           fork do
-            @reporter.before_test(runnable(Process.pid))
-            @reporter.report
+            test_instance = Minitest::Test.new("test_#{Process.pid}")
+            test_instance.before_setup
           end
         end
-        (pids + [pid]).map do |pid|
-          Process.waitpid(pid)
+        pids.each { |pid| Process.waitpid(pid) }
+
+        @reporter.report
+
+        # Each worker should have its own file via the hook
+        pids.each do |pid|
+          worker_path = File.join(File.dirname(log_path), "test_order.worker-#{pid}.log")
+          assert File.exist?(worker_path), "Expected #{worker_path} to exist"
+          assert_equal ["Minitest::Test#test_#{pid}"], File.readlines(worker_path).map(&:chomp)
         end
+      end
+
+      def test_start_cleans_stale_worker_files
+        # Create a stale worker file
+        stale_path = File.join(File.dirname(log_path), "test_order.worker-99999.log")
+        File.write(stale_path, "stale\n")
 
-        assert_equal pids.map { |pid| "Minitest::Test##{pid}" }.sort, File.readlines(log_path).map(&:chomp).sort
+        @reporter.start
+        @reporter.report
+
+        refute File.exist?(stale_path), "Stale worker file should be cleaned up"
       end
     end
 
     private
 
-    def delete_log
-      File.delete(log_path) if File.exists?(log_path)
-    end
-
     def log_path
       @path ||= File.join(Dir.tmpdir, 'test_order.log')
     end