ci-queue 0.97.0 → 0.98.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d17fbfbe9128059d59548415b65bf99e86f6b9a3345ffd35c3e694bd1f5d1ec
-  data.tar.gz: e864440baac5ff4f930455e565509d78e7900243c251f2b5368e5bd2d8e1e114
+  metadata.gz: 020b8bf0b6887aa814e3f6b310bc62888e9a5e0af94c6ed652efc0af2b947ef7
+  data.tar.gz: 11e86bbe7b3e6bacfe96b84ae131c40222fb61a1afa9788f953c3a85db02d751
 SHA512:
-  metadata.gz: 0a7ecb6a7c387b76fab9d317bd619308cc6d4aa1d46684aa4c8a01546308613e1681fecabbebc4340bd9eb2dc8f68a8ca1e7fe0c19202c8b4224d4d260519bf1
-  data.tar.gz: d215b3fc1ef18fefa67493f2e447bc01a500224efbc61bc07c23bbb332e3dfe3855a73de16671ad8cdb2d59eeb1704a1765555d765b2d9a50532249b4f4d0280
+  metadata.gz: b02b9a927e82321c3792c5a479487ef2a80e1093e23d4614e1e3b9191b9a5b5f9691cbdc78bd2a2a566e97dcbcf6231c3d9df19521bc2408099b6e905c38ecfa
+  data.tar.gz: 39cbdb4ef28553b81373f5836a8267b1919815fcab5959893bf002a307b7341e6337e045b00dd8a06e4c93dba2a1b3bd05ca9b96672292b5e25b8f50cc507fbf

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ci-queue (0.97.0)
+    ci-queue (0.98.0)
       logger
 
 GEM

data/README.md

@@ -138,6 +138,57 @@ The runner also comes with a tool to investigate leaky tests:
 minitest-queue --queue path/to/test_order.log --failing-test 'SomeTest#test_something' bisect -Itest test/**/*_test.rb
 ```
 
+#### Parallel worker metadata
+
+Each result is stamped, as it is recorded in the process that ran the test, with:
+
+- `parallel_worker_pid`: the pid of the process that ran the test.
+- `parallel_worker_test_index`: a 0-based monotonic counter of results recorded by that process (requeued executions get their own index). Restarts at 0 in each forked process.
+- `parallel_worker_id`: an identifier injected by the embedding environment (e.g. a Rails parallel-testing worker number); `nil` when not applicable.
+
+All three fields are included (nil-safe) in `log/test_data.json` emitted by the test data reporter, making per-worker-process execution order reconstructable downstream (`PARTITION BY parallel_worker_id, parallel_worker_pid ORDER BY parallel_worker_test_index`).
+
+The worker id can be provided either programmatically or via the environment:
+
+```ruby
+Minitest::Queue.parallel_worker_id = 3
+```
+
+| Variable | Description |
+|---|---|
+| `CI_QUEUE_PARALLEL_WORKER_ID=N` | Sets `parallel_worker_id` for results produced by this process. Read once per process; the setter takes precedence. |
+
+Stamping is first-writer-wins. When ci-queue runs tests in-process (the normal
+`minitest-queue` flow), results are stamped automatically as they are recorded.
+Embedding environments that run tests in forked workers and transport results to
+another process (e.g. over DRb to a central reporting server) must stamp in the
+worker **before** sending:
+
+```ruby
+# in the forked worker, after running the test and before the DRb send
+Minitest::Queue.stamp_parallel_worker_metadata(result)
+```
+
+Otherwise the automatic stamp during reporting would capture the reporting
+process's pid and an arrival-order index interleaved across workers. Pre-stamped
+results pass through reporting untouched.
+
+Notes:
+
+- `parallel_worker_id` identifies a forked test process *inside* one queue worker.
+  It is unrelated to ci-queue's own `--worker` / `CI::Queue::Configuration#worker_id`,
+  which identifies the whole queue worker (typically one CI job).
+- The payload intentionally carries no build/job identity — like every other field
+  in `log/test_data.json`, scoping to a build/job (e.g. a `job_id` column making
+  `(job_id, parallel_worker_id, parallel_worker_pid)` unique across a build) is
+  expected to be attached by whatever pipeline ingests the file.
+- Stamping is mutex-guarded, so indexes are unique and gap-free even when results
+  are recorded from multiple threads. However, per-worker order reconstruction is
+  only meaningful with process-based (forked) workers: under thread-based
+  parallelization all threads share one `(parallel_worker_id, parallel_worker_pid)`
+  partition and the index reflects record order across threads.
+- This applies to minitest-queue only; rspec-queue does not emit these fields.
+
 ### RSpec [DEPRECATED]
 
 The rspec-queue runner is deprecated. The minitest-queue runner continues to be supported and is actively being improved. At Shopify, we strongly recommend that new projects set up their test suite using Minitest rather than RSpec.

data/lib/ci/queue/version.rb

@@ -2,7 +2,7 @@
 
 module CI
   module Queue
-    VERSION = '0.97.0'
+    VERSION = '0.98.0'
     DEV_SCRIPTS_ROOT = ::File.expand_path('../../../../../redis', __FILE__)
     RELEASE_SCRIPTS_ROOT = ::File.expand_path('../redis', __FILE__)
   end

data/lib/minitest/queue/test_data.rb

@@ -49,7 +49,7 @@ module Minitest
       end
 
       def test_duration
-        @test.time
+        @test.time || 0.0
       end
 
       def test_start_timestamp
@@ -73,6 +73,22 @@ module Minitest
         @test.source_location.last
       end
 
+      # The parallel_worker_* fields are stamped by
+      # Minitest::Queue.stamp_parallel_worker_metadata in the worker process
+      # that ran the test. They are nil for embedders that don't produce
+      # them (results lacking the accessors, or no worker id configured).
+      def parallel_worker_id
+        @test.parallel_worker_id if @test.respond_to?(:parallel_worker_id)
+      end
+
+      def parallel_worker_test_index
+        @test.parallel_worker_test_index if @test.respond_to?(:parallel_worker_test_index)
+      end
+
+      def parallel_worker_pid
+        @test.parallel_worker_pid if @test.respond_to?(:parallel_worker_pid)
+      end
+
       # Error class only considers failures wheras the other error fields also consider skips
       def error_class
         return nil unless @test.failure
@@ -119,6 +135,9 @@ module Minitest
           test_finish_timestamp: test_finish_timestamp,
           test_file_path: test_file_path,
           test_file_line_number: test_file_line_number,
+          parallel_worker_id: parallel_worker_id,
+          parallel_worker_test_index: parallel_worker_test_index,
+          parallel_worker_pid: parallel_worker_pid,
           error_class: error_class,
           error_message: error_message,
           error_file_path: error_file_path,

data/lib/minitest/queue.rb

@@ -111,10 +111,22 @@ module Minitest
     attr_accessor :queue_id, :queue_entry
   end
 
+  # Per-worker-process execution metadata, stamped on each result in the
+  # process that ran the test (before any DRb send in embedding
+  # environments), so that per-process execution order is reconstructable
+  # downstream: PARTITION BY parallel_worker_id, parallel_worker_pid
+  # ORDER BY parallel_worker_test_index.
+  module ParallelWorkerMetadata
+    attr_accessor :parallel_worker_id, :parallel_worker_test_index, :parallel_worker_pid
+  end
+
   module Queue
     extend ::CI::Queue::OutputHelpers
     attr_writer :run_command_formatter, :project_root
 
+    PARALLEL_WORKER_METADATA_MUTEX = Mutex.new
+    private_constant :PARALLEL_WORKER_METADATA_MUTEX
+
     def run_command_formatter
       @run_command_formatter ||= if defined?(Rails) && defined?(Rails::TestUnitRailtie)
         RAILS_RUN_COMMAND_FORMATTER
@@ -155,6 +167,60 @@ module Minitest
     end
 
     class << self
+      # Identifies which parallel worker this process is (e.g. Rails'
+      # parallel testing worker number). Injected by the embedding
+      # environment via this setter or the CI_QUEUE_PARALLEL_WORKER_ID
+      # environment variable; nil when not applicable.
+      attr_writer :parallel_worker_id
+
+      def parallel_worker_id
+        return @parallel_worker_id if @parallel_worker_id
+
+        # Memoized per process: re-read after a fork, but not on every test.
+        if @parallel_worker_id_env_pid != Process.pid
+          @parallel_worker_id_env_pid = Process.pid
+          @parallel_worker_id_from_env = parallel_worker_id_from_env
+        end
+        @parallel_worker_id_from_env
+      end
+
+      # Stamps per-process execution metadata on a result. Must be called
+      # in the process that ran the test so pid and per-process test index
+      # are captured worker-side.
+      #
+      # First writer wins: results that were already stamped are left
+      # untouched. Embedding environments that run tests in forked workers
+      # and transport results to another process (e.g. over DRb) MUST call
+      # this in the worker before sending, otherwise the stamp applied
+      # during reporting would carry the reporting process's pid and an
+      # arrival-order index interleaved across workers.
+      #
+      # The counter is mutex-guarded: results recorded from multiple threads
+      # (e.g. a DRb server dispatching each call on its own thread) get
+      # unique, gap-free indexes reflecting record order in this process.
+      # Returns the result when it was stamped, nil when it was skipped.
+      def stamp_parallel_worker_metadata(result)
+        return unless result.respond_to?(:parallel_worker_pid=)
+        return if result.parallel_worker_pid # already stamped worker-side
+
+        PARALLEL_WORKER_METADATA_MUTEX.synchronize do
+          pid = Process.pid
+          if @parallel_worker_metadata_pid != pid
+            # Restart the per-process counter in forked workers so that
+            # (parallel_worker_id, parallel_worker_pid, parallel_worker_test_index)
+            # always reflects execution order within a single process.
+            @parallel_worker_metadata_pid = pid
+            @parallel_worker_next_test_index = 0
+          end
+
+          result.parallel_worker_id = parallel_worker_id
+          result.parallel_worker_pid = pid
+          result.parallel_worker_test_index = @parallel_worker_next_test_index
+          @parallel_worker_next_test_index += 1
+        end
+        result
+      end
+
       def queue
         Minitest.queue
       end
@@ -179,6 +245,8 @@ module Minitest
       end
 
       def handle_test_result(reporter, example, result)
+        stamp_parallel_worker_metadata(result)
+
         if result.respond_to?(:queue_id=)
           result.queue_id = example.id
           result.queue_entry = example.queue_entry if result.respond_to?(:queue_entry=)
@@ -213,6 +281,17 @@ module Minitest
 
       private
 
+      def parallel_worker_id_from_env
+        value = ENV['CI_QUEUE_PARALLEL_WORKER_ID']
+        return nil if value.nil? || value.empty?
+
+        begin
+          Integer(value)
+        rescue ArgumentError
+          value
+        end
+      end
+
       def report_load_stats(queue)
         return unless CI::Queue.debug?
         return unless queue.respond_to?(:file_loader)
@@ -441,6 +520,7 @@ module Minitest
         if result
           result.start_timestamp = start_timestamp
           result.finish_timestamp = current_timestamp
+          result.time ||= (result.finish_timestamp - result.start_timestamp).to_f
         end
       end
 
@@ -608,11 +688,13 @@ if defined? Minitest::Result
   Minitest::Result.prepend(Minitest::Flakiness)
   Minitest::Result.prepend(Minitest::WithTimestamps)
   Minitest::Result.prepend(Minitest::ResultMetadata)
+  Minitest::Result.prepend(Minitest::ParallelWorkerMetadata)
 else
   Minitest::Test.prepend(Minitest::Requeueing)
   Minitest::Test.prepend(Minitest::Flakiness)
   Minitest::Test.prepend(Minitest::WithTimestamps)
   Minitest::Test.prepend(Minitest::ResultMetadata)
+  Minitest::Test.prepend(Minitest::ParallelWorkerMetadata)
 
   module MinitestBackwardCompatibility
     def source_location

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ci-queue
 version: !ruby/object:Gem::Version
-  version: 0.97.0
+  version: 0.98.0
 platform: ruby
 authors:
 - Jean Boussier