rspec-mergify 2026.10.7 → 2026.10.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c8b41d3c9e361bcea64889951b41d214d237d06a56ee0873d725f1106b9c21a
-  data.tar.gz: 86f2ccc52676008a737da28ae8877ec49b84f7dc4f484847f0f3d3c83f1496bf
+  metadata.gz: 82681fca0d5d6710db90d1efb22a5ae4d23b175e55519bf8fbf91e44d48d386f
+  data.tar.gz: fdae1d6d362f960d5c93f27991227f59d751f27547c3534361de4ca35ad20aca
 SHA512:
-  metadata.gz: e9c95b28c61e098fc580b9a854f3bbc3d8f9dc94d5084bd98d5fd0fe3bcf7d090711c3e993651739501bfb5fa11ef091a92e5959cbb78098883bfad9b5ce8882
-  data.tar.gz: 0cb4388da6ad71ae24ca0315fb29dde8e7995c031b79f29c37a177da5c77df548ffe8216c5b8af5931f810eb39999eab5ad5145dc0c2b20022588629906c45c6
+  metadata.gz: 85e472d4c201ed2a59ab570d045c71a3d3c275fd87b7442ebe14b3a2cf7ba5989dec8a3bcef7fa3d0ee996c9c17d9052a8e5308db83d284949ad2db0e1a90e74
+  data.tar.gz: 1ff736c8192c6b9ca2e8775bceaf39478c88f56df5e5604801424933e4fe9ecb209c5d819b3352fdb483800fdc9eb303007260b51ffea7aa91c343289b03ec6c

data/README.md

@@ -6,6 +6,7 @@ RSpec plugin for [Mergify Test Engine](https://docs.mergify.com/test-engine/).
 
 - **Test tracing** — Sends OpenTelemetry traces for every test to Mergify's API
 - **Flaky test detection** — Intelligently reruns tests to detect flakiness with budget constraints
+- **Test retry** — On the default branch, runs a failing example again, once rspec-retry's tries failed, within a time budget Mergify sets
 - **Test quarantine** — Quarantines failing tests so they don't block CI
 - **Test selection** — Runs first the examples a merge-queue bisection step failed in the step above, and stops once one fails again
 
@@ -21,7 +22,7 @@ Then run `bundle install`.
 
 ### Supported platforms
 
-The gem ships precompiled, so nothing is built on your machine. Each platform gem carries an extension for Ruby 3.1 through 4.0:
+The gem runs on `mergify-ci-core`, which Bundler installs with it. That gem ships precompiled, so nothing is built on your machine. Each of its platform gems carries an extension for Ruby 3.1 through 4.0:
 
 | Platform | Requirement |
 |---|---|
@@ -52,7 +53,8 @@ The plugin activates automatically when running in CI (detected via the `CI` env
 | `MERGIFY_CI_DEBUG` | Print the session verdict and the spans instead of sending them, and upload nothing | `false` |
 | `MERGIFY_TRACEPARENT` | W3C distributed trace context | — |
 | `MERGIFY_TEST_JOB_NAME` | Mergify test job name | — |
-| `MERGIFY_TEST_SELECTION_ENABLE` | Opt this job into test selection (see below) | `false` |
+| `MERGIFY_FAIL_FIRST_ENABLE` | Set to `false` to never run first what a merge-queue bisection step of this job failed before | `true` |
+| `MERGIFY_TEST_RETRY_ENABLE` | Set to `false` to have this job retry no failing test, whatever the repository sets | `true` |
 
 The names these replace, `RSPEC_MERGIFY_ENABLE` and `RSPEC_MERGIFY_DEBUG`, are
 deprecated: they still work when the new name is not set, and the summary says
@@ -78,18 +80,32 @@ as usual. No example is ever skipped, so a green step still comes from a full
 suite. A quarantined failure does not stop the run; a `--fail-fast` of your own
 still stops at the first failure.
 
-**This is off until you turn it on, per job.** Set
-`MERGIFY_TEST_SELECTION_ENABLE=true` on the job you want to run its failures
-first. Installing the gem is not enough. Anything that is not a recognised yes
-(unset, empty, `false`, unparsable) means no, and a job that has not opted in
-never asks.
-
-Once opted in:
+**It is on by default.** A job that must always run its suite in its usual
+order sets `MERGIFY_FAIL_FIRST_ENABLE=false`, and never asks. Only a recognised
+no (`false`, `no`, `off`, `0`) turns it off. `MERGIFY_TEST_SELECTION_ENABLE`,
+its former name, is still read while the new one is unset or empty, and the
+summary at the end of the run says to switch. It is also enabled per
+organization on Mergify's side: until yours has it, every run is served the
+full suite, says nothing about it, and still sends
+its results, which show what Fail First would do there.
+
+It only ever asks in a build of a merge-queue batch, the only builds a
+bisection step can be: on GitHub Actions, the event of the draft pull request
+the queue opened; on any other build, the queue's git note on the branch, one
+`git ls-remote` against `origin` that runs while the tests are being collected.
+Every other build asks nothing and sends nothing. Of a batch's builds, only
+those below a failed batch, and not retrying their own checks, ask: the
+others cannot be a bisection step, and send their results only when the
+batch holds two pull requests or more, so a bisection step may read them, or
+when they failed. A build where git cannot answer (no `origin`, credentials
+the test step does not hold) asks, as it would without this.
+
+When it runs:
 
 - the order applies **after** RSpec's own filters — file and line arguments,
   `--tag`, `-e`, `--only-failures` all still narrow the run;
-- examples are matched by their id (`./spec/models/user_spec.rb[1:2]`), the
-  identity RSpec itself reruns failures by;
+- examples are matched by the name Mergify knows them by (see
+  [Test names](#test-names));
 - any error, timeout, or unrecognised answer runs the full suite in its usual
   order;
 - at the end of the run the gem sends Mergify what it concluded (the counts
@@ -100,11 +116,36 @@ Once opted in:
 Each parallel_tests worker, and each CI job handed a slice of the spec files,
 reports its own collection, by the examples it collects.
 
+### Test names
+
+Mergify knows each example by its file, its groups and its description:
+`spec/models/user_spec.rb > User > #full_name > joins first and last`. Adding,
+moving or removing an example renames no other. An example written without a
+description (`it { is_expected.to validate_presence_of(:email) }`) is named by
+its code, and examples a file names alike get their place after the name
+(`[1:2]`), as RSpec numbers them.
+
+Earlier releases named an example by its place instead
+(`./spec/models/user_spec.rb[1:2]`). A quarantine entry or a flaky-detection
+history under such a name still matches, but each example's history on the
+dashboard starts over under its new name. Quarantine an example again under
+its new name: an entry under its old one follows the place, so the example
+that holds it changes when one is added above.
+
+A suite that reported through
+[rspec_junit_formatter](https://github.com/sj26/rspec_junit_formatter) and
+`mergify ci junit-process` keeps its quarantine entries and flaky-detection
+history the same way: an example is still matched under the name those
+uploads gave it (`spec.models.user_spec.User#full_name joins first and last`).
+An example written without a description gets that name only once it ran, so
+on the pull request that switches, flaky detection may take it for a new
+test.
+
 ### Parallel runs
 
 [parallel_tests](https://github.com/grosser/parallel_tests) and [turbo_tests](https://github.com/serpapi/turbo_tests) need no setup. Each worker is a separate RSpec process, and each reports to Mergify as its own session:
 
-- flaky detection sizes each worker's rerun budget from the tests that worker runs;
+- flaky detection sizes each worker's rerun budget from the tests that worker runs, and test retry gives each worker a budget of its own;
 - each worker prints its own Mergify report, so a report covers only that worker's tests.
 
 Suites split across CI jobs (knapsack, `circleci tests split`, Buildkite `parallelism`) behave the same way, one session per job.
@@ -131,8 +172,10 @@ bundle install
 bundle exec rake test
 ```
 
-`rake test` compiles the extension in Cargo's dev profile first: running
-`rspec` alone skips every binding example when the extension isn't built.
+`rake test` compiles `mergify-ci-core`'s extension in Cargo's dev profile
+first, with that gem's own bundle (`clients/mergify-ci-core`, `bundle install`
+there too): running `rspec` alone skips every binding example when the
+extension isn't built.
 
 ### Linting
 

data/THIRD_PARTY_LICENSES

@@ -8,8 +8,8 @@ The source code of each component is available from the repository listed
 next to it, as the Mozilla Public License 2.0 requires for the components
 under it.
 
-Apache License 2.0 (230)
-MIT License (73)
+Apache License 2.0 (233)
+MIT License (74)
 Unicode License v3 (19)
 ISC License (5)
 BSD 3-Clause "New" or "Revised" License (4)
@@ -23,7 +23,7 @@ Apache License 2.0 (Apache-2.0)
 
 Used by:
   - cmov 0.5.4 (https://github.com/RustCrypto/utils)
-  - ctutils 0.4.3 (https://github.com/RustCrypto/utils)
+  - ctutils 0.4.6 (https://github.com/RustCrypto/utils)
   - encode_unicode 1.0.0 (https://github.com/tormol/encode_unicode)
   - encoding_rs 0.8.42 (https://github.com/hsivonen/encoding_rs)
   - multiversion_no_op 1.0.0 (https://github.com/hsivonen/multiversion_no_op)
@@ -4882,6 +4882,7 @@ Apache License 2.0 (Apache-2.0)
 Used by:
   - ahash 0.8.12 (https://github.com/tkaitchuck/ahash)
   - async-channel 2.5.0 (https://github.com/smol-rs/async-channel)
+  - async-compression 0.4.51 (https://github.com/Nullus157/async-compression)
   - async-executor 1.14.0 (https://github.com/smol-rs/async-executor)
   - async-io 2.6.0 (https://github.com/smol-rs/async-io)
   - async-lock 3.4.2 (https://github.com/smol-rs/async-lock)
@@ -4894,6 +4895,8 @@ Used by:
   - bitflags 2.13.1 (https://github.com/bitflags/bitflags)
   - blocking 1.7.0 (https://github.com/smol-rs/blocking)
   - cfg-if 1.0.4 (https://github.com/rust-lang/cfg-if)
+  - compression-codecs 0.4.46 (https://github.com/Nullus157/async-compression)
+  - compression-core 0.4.34 (https://github.com/Nullus157/async-compression)
   - concurrent-queue 2.5.0 (https://github.com/smol-rs/concurrent-queue)
   - core-foundation-sys 0.8.7 (https://github.com/servo/core-foundation-rs)
   - core-foundation 0.10.1 (https://github.com/servo/core-foundation-rs)
@@ -8357,7 +8360,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 Community Data License Agreement Permissive 2.0 (CDLA-Permissive-2.0)
 
 Used by:
-  - webpki-root-certs 1.0.10 (https://github.com/rustls/webpki-roots)
+  - webpki-root-certs 1.0.11 (https://github.com/rustls/webpki-roots)
 
 # Community Data License Agreement - Permissive - Version 2.0
 
@@ -8791,7 +8794,7 @@ THIS SOFTWARE.
 ISC License (ISC)
 
 Used by:
-  - rustls-webpki 0.103.15 (https://github.com/rustls/webpki)
+  - rustls-webpki 0.103.16 (https://github.com/rustls/webpki)
 
 Except as otherwise noted, this project is licensed under the following
 (ISC-style) terms:
@@ -9826,10 +9829,10 @@ SOFTWARE.
 MIT License (MIT)
 
 Used by:
-  - jsonschema-regex 0.60.0 (https://github.com/Stranger6667/jsonschema)
-  - jsonschema-value 0.60.0 (https://github.com/Stranger6667/jsonschema)
-  - jsonschema 0.60.0 (https://github.com/Stranger6667/jsonschema)
-  - referencing 0.60.0 (https://github.com/Stranger6667/jsonschema)
+  - jsonschema-regex 0.60.1 (https://github.com/Stranger6667/jsonschema)
+  - jsonschema-value 0.60.1 (https://github.com/Stranger6667/jsonschema)
+  - jsonschema 0.60.1 (https://github.com/Stranger6667/jsonschema)
+  - referencing 0.60.1 (https://github.com/Stranger6667/jsonschema)
 
 MIT License
 
@@ -10083,6 +10086,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 MIT License (MIT)
 
 Used by:
+  - tokio-util 0.7.19 (https://github.com/tokio-rs/tokio)
   - tokio 1.54.1 (https://github.com/tokio-rs/tokio)
 
 MIT License

data/lib/mergify/rspec/configuration.rb

@@ -40,25 +40,21 @@ module Mergify
           # Also when the native extension did not load, which nothing can
           # tell apart from a run outside CI: the summary then says why it
           # reports nothing.
-          config.prepend_before(:suite) { Configuration.attach_formatter(config) } if reports? || !Native.available?
+          if reports? || !Mergify::CI::Core::Native.available?
+            config.prepend_before(:suite) { Configuration.attach_formatter(config) }
+          end
 
           # Flaky detection: prepared for every example of the run.
           config.before(:suite) do
             ci = Mergify::RSpec.test_run
             if ci
-              all_ids = ::RSpec.world.example_groups.flat_map(&:descendants).flat_map(&:examples).map(&:id)
-              ci.prepare_reruns(all_ids)
+              examples = ::RSpec.world.example_groups.flat_map(&:descendants).flat_map(&:examples)
+              names = ci.names
+              ci.prepare_reruns(examples.map { |example| names.of(example) },
+                                examples.to_h { |example| [names.of(example), names.formers(example)] })
             end
           end
 
-          # Quarantine: mark tests before execution
-          config.before(:each) do |example|
-            ci = Mergify::RSpec.test_run
-            next unless ci&.quarantined_tests&.include?(example.id)
-
-            example.metadata[:mergify_quarantined] = true
-          end
-
           # Each try of an example, which a retry plugin's loop (rspec-retry's)
           # makes inside the `around` hook below: the first `before` hook every
           # try runs, and the last `after` one.
@@ -81,12 +77,17 @@ module Mergify
             test_run&.reports? ? Configuration.run_example(example, test_run) : example.run
           end
 
-          # Quarantine: override failed quarantined test results. The failure is
-          # noted for flaky detection first, which would otherwise take a
-          # quarantined attempt that failed for one that passed.
+          # Quarantine: override failed quarantined test results. Asked once
+          # the example ran: one written without a description has the name a
+          # JUnit upload gave it only then, when RSpec has written it one from
+          # its matcher. The failure is noted for flaky detection first, which
+          # would otherwise take a quarantined attempt that failed for one
+          # that passed.
           config.after(:each) do |example|
-            next unless example.metadata[:mergify_quarantined] && example.exception
+            ci = Mergify::RSpec.test_run
+            next unless example.exception && ci&.quarantined_tests&.include?(ci.names.keys(example))
 
+            example.metadata[:mergify_quarantined] = true
             example.metadata[:mergify_quarantined_failure] = true
             example.metadata[:mergify_quarantined_exception] = example.exception
             example.instance_variable_set(:@exception, nil)
@@ -104,23 +105,25 @@ module Mergify
       # an example group starts. What each group runs is read from
       # `RSpec.world.filtered_examples`, which RSpec memoized while counting the
       # run.
+      # rubocop:disable-next Metrics/MethodLength
       def select_examples
         ci = Mergify::RSpec.test_run
         return unless ci
 
         examples = collected
-        return unless ci.select(examples.map(&:id))
+        names = ci.names
+        return unless ci.select(examples.map { |example| names.of(example) })
 
         # Ordered, not filtered: a served example this run did not collect is
         # expected -- a parallel worker holds part of the job's failures.
         fail_first = ci.fail_first
-        FailureFirst.apply(fail_first, examples, reporter: ::RSpec.configuration.reporter) if fail_first
+        FailureFirst.apply(fail_first, examples, names, reporter: ::RSpec.configuration.reporter) if fail_first
       rescue StandardError => e
         # This runs on every CI run, opted in or not, and RSpec would answer a
         # raise here by running nothing: a fault of this gem must cost the run
         # its order, never its tests.
         ::RSpec.configuration.error_stream.puts(
-          "Mergify Test Selection failed, so the full suite runs: #{e.class}: #{e.message}"
+          "Mergify could not apply Fail First, so the full suite runs: #{e.class}: #{e.message}"
         )
       end
 
@@ -143,44 +146,87 @@ module Mergify
       # engine around `example.run`, and its outcome read off the exception it
       # left behind. Its first run is the example's first attempt, and the
       # tries a retry plugin makes after it, inside that run; flaky detection's
-      # reruns follow, each a try alone.
+      # reruns follow, or test retry's, each a try alone.
       def run_example(example, test_run)
+        name = test_run.names.of(example)
         detector = test_run.flaky_detector
-        tries = run_first(example, test_run, detector)
-        return unless detector&.rerunning_test?(example.id)
+        retrier = test_run.test_retrier
+        retrier = nil unless retrier&.answers_for?(name)
+        tries = run_first(example, name, test_run, detector, retrier)
+        if detector&.rerunning_test?(name)
+          detect_flakiness(example, name, detector, retrier, tries)
+        elsif retrier
+          retry_failure(example, name, retrier, tries)
+        end
+      end
 
+      # Flaky detection reruns the example, within its budget. Where test
+      # retry answers for the example, the reruns answer its failure too.
+      def detect_flakiness(example, name, detector, retrier, tries)
         initial_exception = example.exception
         first_failure = tries.failure || initial_exception
-        first_failure = rerun(example, detector, first_failure) if detector.start_reruns(example.id)
+        first_failure = rerun(example, name, detector, retrier, first_failure) if detector.start_reruns(name)
 
         # Which attempt decides the result is the session's rule: in 'new'
         # mode any failure fails the test, the retry plugin's tries included,
         # so a new flaky test cannot be merged; in 'unhealthy' mode the reruns
-        # only learn, and the example's own result stands.
+        # only learn, and the example's own result stands, unless test retry
+        # says a rerun rescued it.
         final_exception = detector.rerun_failure_fails_the_test? ? first_failure : initial_exception
+        final_exception = nil if retrier&.rescued?(name)
         example.example.instance_variable_set(:@exception, final_exception)
       end
 
-      # The example's first run: its first attempt, timed by the engine up to
-      # the second try where a retry plugin made one, then each try after it,
-      # handed to the session once the first reached flaky detection. What the
-      # first attempt was is kept for its span.
-      def run_first(example, test_run, detector)
-        id = example.id
-        detector&.attempt_started(id)
-        tries = run_tries(example) { detector&.attempt_stopped(id) }
-        detector&.attempt_ended(id, first_failed?(example, tries) ? :failed : :passed)
-        tries.later.each { |try| test_run.record_retry(id, try.status, try.duration_ms) }
+      # Test retry runs the failed example again, each time the session grants
+      # one more attempt, until one passes: the example then passes, as a pass
+      # of a retry plugin's would. Otherwise its first run's failure stands.
+      # Each attempt is one try, as flaky detection's reruns are.
+      def retry_failure(example, name, retrier, tries)
+        failure = example.exception
+        return unless failure
+
+        without_retries(example) { run_retries(example, name, retrier, tries.last_ms) }
+        example.example.instance_variable_set(:@exception, retrier.rescued?(name) ? nil : failure)
+      end
+
+      # Each attempt the session grants the example, once the one before it
+      # failed after `attempt_ms`.
+      def run_retries(example, name, retrier, attempt_ms)
+        while retrier.grant?(name, attempt_ms)
+          reset_for_rerun(example)
+          attempt_ms = run_tries(example).last_ms
+          retrier.record(name, example.exception ? :failed : :passed, attempt_ms)
+        end
+      end
+
+      # The first run of the example named `name`: its first attempt, timed by
+      # the engine up to the second try where a retry plugin made one, then
+      # each try after it, handed to the session once the first reached flaky
+      # detection and test retry. What the first attempt was is kept for its
+      # span.
+      def run_first(example, name, test_run, detector, retrier)
+        detector&.attempt_started(name)
+        tries = run_tries(example) { detector&.attempt_stopped(name) }
+        first_attempt_ended(example, name, tries, detector, retrier)
+        tries.later.each { |try| test_run.record_retry(name, try.status, try.duration_ms) }
         example.metadata[:mergify_first_attempt] = { try: tries.first, ended_at: tries.first_ended_at } if tries.first
         tries
       end
 
+      # The example's first attempt is over: flaky detection and test retry
+      # take it before the tries after it.
+      def first_attempt_ended(example, name, tries, detector, retrier)
+        status = first_failed?(example, tries) ? :failed : :passed
+        detector&.attempt_ended(name, status)
+        retrier&.record(name, status, tries.first_ms)
+      end
+
       # Run the example once, noting each try a retry plugin makes of it; the
       # block is called as a second one starts.
       def run_tries(example, &)
         tries = Tries.new(&)
         example.metadata[:mergify_tries] = tries
-        example.run
+        tries.time { example.run }
         tries
       ensure
         example.metadata.delete(:mergify_tries)
@@ -212,16 +258,16 @@ module Mergify
       end
 
       # Which attempt decides the result is the session's rule (see
-      # `run_example`): answers the first failure, the reruns' included.
+      # `detect_flakiness`): answers the first failure, the reruns' included.
       # Each rerun is one try: a retry plugin's tries would hide its failure
       # behind the one that passed.
-      def rerun(example, detector, first_failure)
+      def rerun(example, name, detector, retrier, first_failure)
         without_retries(example) do
           until example.metadata[:is_last_rerun]
-            example.metadata[:is_last_rerun] = detector.last_rerun_for_test?(example.id)
+            example.metadata[:is_last_rerun] = detector.last_rerun_for_test?(name)
             reset_for_rerun(example)
 
-            run_attempt(example, detector)
+            run_attempt(example, name, detector, retrier)
             first_failure ||= example.exception
           end
         end
@@ -257,13 +303,15 @@ module Mergify
       end
 
       # Runs what the around hook wraps -- the before and after hooks included
-      # -- timed by the session, and answers its outcome.
-      def run_attempt(example, detector)
-        detector.attempt_started(example.id)
-        example.run
+      # -- timed by the session, and answers its outcome; test retry, where it
+      # answers for the example, is told of it too.
+      def run_attempt(example, name, detector, retrier)
+        detector.attempt_started(name)
+        attempt = run_tries(example)
         failed = example.exception || example.metadata.delete(:mergify_quarantined_failure)
         status = failed ? :failed : :passed
-        detector.attempt_ended(example.id, status)
+        detector.attempt_ended(name, status)
+        retrier&.record(name, status, attempt.last_ms)
         status
       end
 

data/lib/mergify/rspec/failure_first.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'set'
-require_relative 'native'
+require 'mergify/ci/core'
 
 module Mergify
   module RSpec
@@ -35,7 +35,7 @@ module Mergify
     # every example and group not started yet is left out, and the run exits 1.
     #
     # What to put first, when to stop, and the terminal block's words are the
-    # session's (`Native::Session#fail_first`), shared with every plugin: this
+    # session's (`Mergify::CI::Core::Native::Session#fail_first`), shared with every plugin: this
     # class reorders and quits.
     class FailureFirst
       class << self
@@ -57,8 +57,8 @@ module Mergify
 
         # Put first the examples the session puts first, and stop the run when
         # it says.
-        def apply(fail_first, examples, reporter:)
-          self.current = new(fail_first, examples)
+        def apply(fail_first, examples, names, reporter:)
+          self.current = new(fail_first, examples, names)
           current.reorder(top_level) if top_level
           reporter.register_listener(current, :example_finished)
           current
@@ -96,10 +96,11 @@ module Mergify
         end
       end
 
-      # An example's id is also the name Mergify knows it by.
-      def initialize(fail_first, examples)
+      # Each example goes by its id, which RSpec orders and reports it by,
+      # and is put first by the name Mergify knows it by (`names`).
+      def initialize(fail_first, examples, names)
         @fail_first = fail_first
-        @first_ids = fail_first.put_first(examples.map { |example| [example.id, example.id] }).to_set
+        @first_ids = fail_first.put_first(examples.map { |example| [example.id, names.of(example)] }).to_set
         @first_groups = groups_holding(examples.select { |example| @first_ids.include?(example.id) })
       end
 

data/lib/mergify/rspec/formatter.rb

@@ -3,7 +3,7 @@
 require 'rspec/core/formatters/base_formatter'
 require_relative 'configuration'
 
-require 'mergify/rspec/native'
+require 'mergify/ci/core'
 
 module Mergify
   module RSpec
@@ -34,8 +34,9 @@ module Mergify
 
         example = notification.example
         result = example.execution_result
-        @test_run.record_verdict(example.id, verdict_status(example), result.run_time)
-        recorded = @test_run.record_quarantine(example.id, real_outcome(example))
+        names = @test_run.names
+        @test_run.record_verdict(names.of(example), verdict_status(example), result.run_time)
+        recorded = @test_run.record_quarantine(names.keys(example), real_outcome(example))
         @has_error = true if result.status == :failed
         @test_run.record_case(case_of(example, recorded))
       end
@@ -120,7 +121,7 @@ module Mergify
       def case_of(example, recorded)
         first = first_attempt(example, recorded['absorbed'])
         {
-          'name' => example.id,
+          'name' => @test_run.names.of(example),
           'file' => example.metadata[:file_path].delete_prefix('./'),
           'function' => example.description,
           'start_unix_nano' => unix_nano(example.execution_result.started_at),
@@ -201,7 +202,7 @@ module Mergify
         return ['Mergify Test Engine is not configured.'] unless @test_run
         # A missing token or repository is the session's to say, with the
         # trace it could not upload.
-        return [] if Mergify::RSpec::Native.available?
+        return [] if Mergify::CI::Core::Native.available?
 
         [native_warning]
       end
@@ -211,7 +212,7 @@ module Mergify
       # git remote that is fine. Say what actually happened instead.
       def native_warning
         'WARNING: the Mergify native extension could not be loaded, so this run reports nothing: ' \
-          "#{Mergify::RSpec::Native.load_error&.message}"
+          "#{Mergify::CI::Core::Native.load_error&.message}"
       end
 
       # `text` in the colour of `severity` when RSpec colours its output, as

data/lib/mergify/rspec/names.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'mergify/ci/core'
+
+module Mergify
+  module RSpec
+    # The name Mergify knows each example by, which the gem hands the session
+    # wherever it speaks of one: the example's span and its verdict, the
+    # quarantine, flaky detection and Fail First.
+    #
+    # An example is named as minitest-mergify names a spec test, by
+    # `CI::Core::TestNames`: `<file> > <groups> > <description>`. The file is
+    # the one RSpec reruns the example from, so an example a shared group
+    # gives a spec is that spec's, relative to the directory the run started
+    # in. Nothing in it counts examples: RSpec's own id,
+    # `./spec/x_spec.rb[1:2]`, numbers an example by its place in its group,
+    # so adding one renamed every one after it, which then took the
+    # quarantine entry and the history of the one before. An example written
+    # without a description is titled by its block's code: RSpec writes it
+    # one from its matcher only once it ran, long after the session asked
+    # about it. A name its file repeats is followed by the example's place
+    # (`[1:2]`), so those examples stay apart.
+    #
+    # An example has two former names, which Mergify's lists may still hold
+    # it under: its id, which every earlier release named it by, and the
+    # name a JUnit upload gave it, for a suite that reported through
+    # rspec_junit_formatter and `mergify ci junit-process` before.
+    class Names
+      # `root` is the directory the run started in.
+      def initialize(root)
+        @root = root
+      end
+
+      def of(example)
+        name_all unless example.metadata.key?(:mergify_name)
+        example.metadata.fetch(:mergify_name)
+      end
+
+      # The names the example had before, which Mergify's lists may still
+      # hold it under.
+      def formers(example)
+        [example.id, junit_name(example)].compact
+      end
+
+      # Every name Mergify's lists may hold the example under, which the
+      # quarantine is asked with.
+      def keys(example)
+        [of(example), *formers(example)]
+      end
+
+      private
+
+      # Name every example RSpec loaded, each in its metadata: whether a name
+      # needs the example's place depends on the others of its file.
+      def name_all
+        names = unplaced_names
+        repeated = names.values.compact.tally.select { |_, count| count > 1 }.keys.to_set
+        names.each do |example, name|
+          example.metadata[:mergify_name] = name.nil? || repeated.include?(name) ? placed(example) : name
+        end
+      end
+
+      # Every example RSpec loaded, by its name without its place: nil for
+      # one that has no title.
+      def unplaced_names
+        examples = ::RSpec.world.example_groups.flat_map(&:descendants).flat_map(&:examples)
+        examples.to_h do |example|
+          title = title(example)
+          [example, title && spec_name(example, title)]
+        end
+      end
+
+      # Its name with its place after its title, as RSpec writes it: `[1:2]`.
+      def placed(example)
+        spec_name(example, [title(example), "[#{example.metadata[:scoped_id]}]"].compact.join(' '))
+      end
+
+      # Its description, or the code of its block when it was written without
+      # one; nil when there is none to read.
+      def title(example)
+        description = example.metadata[:description].to_s
+        return description unless description.empty?
+
+        block = example.metadata[:block]
+        CI::Core::TestNames.block_text(block) if block
+      end
+
+      # The name `mergify ci junit-process` gave the example from
+      # rspec_junit_formatter's report, `<class name>.<name>`: the class name
+      # the file of its outermost group, without its extension and with `/`
+      # as `.`, and the name its full description. Nil for an example written
+      # without a description that has not run yet: RSpec writes it one only
+      # once it ran.
+      def junit_name(example)
+        return if example.metadata[:description].to_s.empty?
+
+        # The formatter cuts the file's name at its first dot.
+        directory, name = File.split(example.example_group.parent_groups.last.metadata[:file_path])
+        classname = "#{directory}/#{name.sub(/\..*/, '')}".tr('/', '.').gsub(/\A\.+|\.+\z/, '')
+        "#{classname}.#{example.full_description}"
+      end
+
+      def spec_name(example, title)
+        groups = example.example_group.parent_groups.reverse.map(&:description)
+        CI::Core::TestNames.spec_name(example.metadata[:rerun_file_path], groups, title, @root)
+      end
+    end
+  end
+end

data/lib/mergify/rspec/quarantine.rb

@@ -16,15 +16,18 @@ module Mergify
         @list = list
       end
 
-      def include?(example_id)
-        @list.include?([example_id])
+      # Whether the list holds an example under any of `keys`, its names (see
+      # `Names#keys`).
+      def include?(keys)
+        @list.include?(keys)
       end
 
-      # Account for an example that ended with `outcome` (`'passed'`,
-      # `'failed'` or `'skipped'`, before the quarantine turned a failure into
-      # `pending`), as `{ 'quarantined' => bool, 'absorbed' => bool }`.
-      def record(example_id, outcome)
-        @list.record([example_id], outcome)
+      # Account for an example known by `keys` that ended with `outcome`
+      # (`'passed'`, `'failed'` or `'skipped'`, before the quarantine turned a
+      # failure into `pending`), as `{ 'quarantined' => bool, 'absorbed' =>
+      # bool }`.
+      def record(keys, outcome)
+        @list.record(keys, outcome)
       end
     end
   end

data/lib/mergify/rspec/test_retry.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mergify
+  module RSpec
+    # Test retry for one RSpec run, as its session prepared it.
+    #
+    # Which failures it answers for, whether an example runs once more, and
+    # whether a retry rescued it are the session's: on a push to the default
+    # branch, every failing example but the ones the quarantine holds and the
+    # ones Mergify classifies as broken, up to the repository's retries, within
+    # one budget for the run. What is left here is how RSpec runs an attempt,
+    # which `Configuration#retry_failure` does.
+    class TestRetrier
+      # `reruns` is the session's.
+      def initialize(reruns)
+        @reruns = reruns
+      end
+
+      # Whether a failure of the example named `name` is test retry's to
+      # answer for: false where it does not run.
+      def answers_for?(name)
+        @reruns.retry_answers_for?(name)
+      end
+
+      # An attempt at the example ended with `status` (`:passed` or
+      # `:failed`) after `duration_ms`: its first, a rerun of flaky
+      # detection's, or one of retry's. Its first reaches flaky detection
+      # through its phases, so test retry is told apart.
+      def record(name, status, duration_ms)
+        @reruns.record_retry_attempt(name, status.to_s, duration_ms)
+      end
+
+      # Whether the example, whose attempt just failed after `attempt_ms`,
+      # runs once more. Asked once that attempt is recorded, and once the
+      # retry plugin's tries of it are over.
+      def grant?(name, attempt_ms)
+        @reruns.grant_retry(name, attempt_ms)
+      end
+
+      # Whether an attempt after the example's first passed, rescuing it.
+      def rescued?(name)
+        @reruns.rescued?(name)
+      end
+    end
+  end
+end

data/lib/mergify/rspec/test_run.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require_relative 'utils'
-require_relative 'native'
+require 'mergify/ci/core'
 require_relative 'flaky_detection'
+require_relative 'test_retry'
+require_relative 'names'
 require 'json'
 require 'rspec/core/version'
 require 'set'
@@ -21,15 +23,15 @@ module Mergify
         # RSpec runs examples, in one process that can wait for every one put
         # first.
         fail_first: { unit: 'test', waits_for_all: true, workers_stop_the_run: false },
-        # RSpec reruns an example as it goes, and retries no failure, in one
-        # process that plans the run's budget once.
-        reruns: { plans_repeats: false, retries_failures: false },
+        # RSpec reruns an example as it goes, and retries a failed one in
+        # place, in one process that plans the run's budgets once.
+        reruns: { plans_repeats: false, retries_failures: true },
         framework: { name: 'rspec', version: ::RSpec::Core::Version::STRING, language: 'ruby' }
       }.freeze
 
       attr_reader :session, :repo_name, :test_run_id,
-                  :flaky_detector, :quarantined_tests,
-                  :captured_session_verdict
+                  :flaky_detector, :test_retrier, :quarantined_tests,
+                  :captured_session_verdict, :names
 
       # `doubles` has the session play Mergify in memory, answering and keeping
       # what it would send (the session's test doubles, by port, as a Hash:
@@ -37,19 +39,24 @@ module Mergify
       # build their TestRun themselves -- or, for a run in another process,
       # install it from a file required before `rspec_mergify`. The instance
       # the gem builds takes none, and the gem reads no switch for them.
+      # rubocop:disable-next Metrics/MethodLength
       def initialize(doubles: nil)
         # What this process reads once: the CI context, the trace a caller
         # handed down, and the run's id; and the deprecated names the run
         # sets, which the summary names.
-        @session = Native::Session.start(Mergify::RSpec::VERSION, output, doubles, enabled?, **FRAMEWORK,
-                                         deprecated_variables: Utils.deprecated_env_names_in_use)
+        @session = Mergify::CI::Core::Native::Session.start(
+          Mergify::RSpec::VERSION, output, doubles, enabled?, client: 'rspec-mergify', **FRAMEWORK,
+                                                              deprecated_variables: Utils.deprecated_env_names_in_use
+        )
         @repo_name = @session.repository_name
         @test_run_id = @session.run_id
         @reruns = nil
         @flaky_detector = nil
+        @test_retrier = nil
         @quarantined_tests = nil
         @captured_session_verdict = nil
         @examples_to_run = nil
+        @names = Names.new(Dir.pwd)
 
         set_up if reports?
       end
@@ -63,8 +70,8 @@ module Mergify
 
       # Hand the session what this run is about to execute, and answer how it
       # executes it, as the session decided: a Hash whose `outcome` is `full`
-      # or `failure_first` (see `Native::Session#select`). Every example
-      # runs.
+      # or `failure_first` (see `Mergify::CI::Core::Native::Session#select`).
+      # Every example runs.
       #
       # Called once RSpec has loaded the spec files and applied every filter
       # of its own -- file and line arguments, `--tag`, `-e`,
@@ -74,11 +81,11 @@ module Mergify
       # own identity: the engine matches each against the previous attempt of
       # the same slice. It travels on the verdict and the trace of a run that
       # asked for the selection.
-      def select(example_ids)
+      def select(names)
         return unless reports?
 
-        @examples_to_run = example_ids.size
-        @session.select(example_ids)
+        @examples_to_run = names.size
+        @session.select(names)
       end
 
       # The run's Fail First, which the session hands out when Mergify
@@ -87,10 +94,10 @@ module Mergify
         @session.fail_first
       end
 
-      # Record an example's final status, as RSpec reported it, for the
-      # session's verdict.
-      def record_verdict(example_id, status, run_time)
-        @session.record_test(example_id, status, run_time.to_f)
+      # Record the final status of the example named `name`, as RSpec
+      # reported it, for the session's verdict.
+      def record_verdict(name, status, run_time)
+        @session.record_test(name, status, run_time.to_f)
       end
 
       # Write what this session concluded to Mergify, before the spans go.
@@ -112,19 +119,19 @@ module Mergify
       end
 
       # Hand the session an example once it finished, as the formatter says
-      # it (see `Native::Session#record_case`): its span joins the run's
+      # it (see `Mergify::CI::Core::Native::Session#record_case`): its span joins the run's
       # trace.
       def record_case(example)
         @session.record_case(example)
       end
 
-      # A retry plugin (rspec-retry) tried the example again after its first
-      # attempt, which ended with `status` (`'passed'` or `'failed'`) after
-      # `duration_ms`: the session counts it on the example's span, and as one
-      # of its runs where flaky detection runs, never against its budget or
-      # its execution cap.
-      def record_retry(example_id, status, duration_ms)
-        @session.record_retry(example_id, status, duration_ms)
+      # A retry plugin (rspec-retry) tried the example named `name` again
+      # after its first attempt, which ended with `status` (`'passed'` or
+      # `'failed'`) after `duration_ms`: the session counts it on the
+      # example's span, and as one of its runs where flaky detection runs,
+      # never against its budget or its execution cap.
+      def record_retry(name, status, duration_ms)
+        @session.record_retry(name, status, duration_ms)
       end
 
       # Have the session send the run's trace, once, at the end: the examples
@@ -145,20 +152,25 @@ module Mergify
         @session.summary(Utils.parallel_worker?)
       end
 
-      # Prepare flaky detection for the examples this run is about to run.
-      # Which of them it reruns, and whether it runs at all, are the
-      # session's.
-      def prepare_reruns(example_ids)
-        @reruns = @session.prepare_reruns(example_ids)
+      # Prepare flaky detection and test retry for the examples this run is
+      # about to run, by their names, each one Mergify's lists may still hold
+      # under its former names (`former_names`, a list by name). Which of them
+      # each reruns, and whether it runs at all, are the session's. No example
+      # opts out of test retry: RSpec's metadata has no key of Mergify's.
+      def prepare_reruns(names, former_names)
+        @session.state_former_names(former_names)
+        @reruns = @session.prepare_reruns(names)
         detection = @reruns&.detection
         @flaky_detector = detection && FlakyDetector.new(@reruns, detection)
+        @test_retrier = @reruns && TestRetrier.new(@reruns)
       end
 
-      # Account for an example's real outcome against the quarantine list.
-      def record_quarantine(example_id, outcome)
+      # Account for the real outcome of the example known by `keys` against
+      # the quarantine list.
+      def record_quarantine(keys, outcome)
         return { 'quarantined' => false, 'absorbed' => false } unless @quarantined_tests
 
-        @quarantined_tests.record(example_id, outcome)
+        @quarantined_tests.record(keys, outcome)
       end
 
       private
@@ -188,7 +200,7 @@ module Mergify
       # be on whatever its value, so that `false` silently stopped the upload;
       # both names now take a boolean.
       def debug_mode?
-        Utils.env_truthy?(Utils.renamed_env(Utils::CI_DEBUG_ENV))
+        Mergify::CI::Core::Utils.env_truthy?(Utils.renamed_env(Utils::CI_DEBUG_ENV))
       end
 
       # Where the session sends the verdict and the trace: shown in debug mode,
@@ -200,7 +212,7 @@ module Mergify
       # The gem's enable switch, under every name it has had: the run then
       # reports outside CI too.
       def enabled?
-        Utils.env_truthy?(Utils.renamed_env(Utils::CI_ENABLE_ENV))
+        Mergify::CI::Core::Utils.env_truthy?(Utils.renamed_env(Utils::CI_ENABLE_ENV))
       end
     end
   end

data/lib/mergify/rspec/tries.rb

@@ -25,6 +25,15 @@ module Mergify
         @on_second = on_second
         @started_ms = nil
         @first_ended_at = nil
+        @run_ms = 0.0
+      end
+
+      # Run the block, the run of the example its tries are made in, timed.
+      def time
+        started_ms = now_ms
+        yield
+      ensure
+        @run_ms = now_ms - started_ms
       end
 
       def start
@@ -53,6 +62,18 @@ module Mergify
         @ended.drop(1)
       end
 
+      # How long the first try took; the whole run where no try started (a
+      # skipped example, an `around` hook that raised before running it).
+      def first_ms
+        first ? first.duration_ms : @run_ms
+      end
+
+      # How long the last try took, as `first_ms`: what the next attempt is
+      # expected to take.
+      def last_ms
+        @ended.empty? ? @run_ms : @ended.last.duration_ms
+      end
+
       # The first failure a try left on the example, the quarantine's aside.
       def failure
         @ended.find(&:exception)&.exception

data/lib/mergify/rspec/utils.rb

@@ -6,18 +6,16 @@ module Mergify
     #
     # CI detection used to live here -- the provider table, the git shelling
     # out, the per-provider environment mappings. It is the Rust core's now, via
-    # the extension in Mergify::RSpec::Native, so that every Mergify test client
-    # detects identically. What is left is what is genuinely Ruby's: parsing a
-    # repository name the API needs split, and reading the plugin's own
-    # switches.
+    # the extension in Mergify::CI::Core::Native, so that every Mergify test
+    # client detects identically. What is left is what is genuinely Ruby's:
+    # parsing a repository name the API needs split, and reading the plugin's
+    # own switches.
     module Utils
       module_function
 
       # Raised when a repository full name (owner/repo) is malformed.
       class InvalidRepositoryFullNameError < StandardError; end
 
-      TRUTHY_STRINGS = %w[y yes t true on 1].freeze
-
       CI_ENABLE_ENV = 'MERGIFY_CI_ENABLE'
       CI_DEBUG_ENV = 'MERGIFY_CI_DEBUG'
 
@@ -29,11 +27,6 @@ module Mergify
         CI_DEBUG_ENV => 'RSPEC_MERGIFY_DEBUG'
       }.freeze
 
-      # Returns true when the named environment variable holds a truthy value.
-      def env_truthy?(key)
-        TRUTHY_STRINGS.include?(ENV.fetch(key, '').downcase)
-      end
-
       # The variable to read for a setting in DEPRECATED_ENV_NAMES: its new
       # name once that is set to something, its deprecated one until then.
       def renamed_env(name)

data/lib/mergify/rspec/version.rb

@@ -8,6 +8,6 @@ module Mergify
     # which resolved against whatever repository happened to be the working
     # directory at load time -- the monorepo's namespaced tags here, the user's
     # own tags once the gem was installed.
-    VERSION = '2026.10.7'
+    VERSION = '2026.10.9'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-mergify
 version: !ruby/object:Gem::Version
-  version: 2026.10.7
+  version: 2026.10.9
 platform: ruby
 authors:
 - Mergify
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: mergify-ci-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2026.10.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2026.10.9
 description: 'RSpec integration for Mergify Test Engine: OpenTelemetry tracing, flaky
   test detection, and test quarantine.'
 email:
@@ -40,8 +54,9 @@ files:
 - lib/mergify/rspec/failure_first.rb
 - lib/mergify/rspec/flaky_detection.rb
 - lib/mergify/rspec/formatter.rb
-- lib/mergify/rspec/native.rb
+- lib/mergify/rspec/names.rb
 - lib/mergify/rspec/quarantine.rb
+- lib/mergify/rspec/test_retry.rb
 - lib/mergify/rspec/test_run.rb
 - lib/mergify/rspec/tries.rb
 - lib/mergify/rspec/utils.rb

data/lib/mergify/rspec/native.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-module Mergify
-  module RSpec
-    # The Rust extension over mergify-ci-session: the session shared with the
-    # pytest and TypeScript clients.
-    #
-    # Loading is best-effort by design. A precompiled gem carries one extension
-    # per Ruby under `<ruby>/`, the source gem compiles one alongside this file,
-    # and a platform we publish neither for gets neither. Detection is one input
-    # to telemetry, not the point of the gem, so an absent extension degrades
-    # what we can report rather than breaking the suite under test -- the same
-    # fail-open posture the napi binding takes when a platform has no prebuilt
-    # binary. `load_error` keeps the reason, for callers that want to say so.
-    module Native
-      class << self
-        # The LoadError that prevented the extension loading, or nil.
-        attr_accessor :load_error
-
-        def available?
-          load_error.nil?
-        end
-
-        # Which of the two failed requires actually explains the absence.
-        #
-        # A precompiled gem ships lib/mergify/rspec/<ruby>/mergify_ci.<dlext>,
-        # so when one is packed for this Ruby that require is the real attempt:
-        # it fails with something like "version `GLIBC_2.29' not found", and the
-        # fallback that follows only ever adds "cannot load such file", which
-        # sends the reader looking for the wrong thing. With no extension for
-        # this Ruby -- the source gem, or a platform we publish no gem for --
-        # it is the other way round.
-        # Require a file next to this one, returning the LoadError instead of
-        # raising it. Two attempts read better as values than as nested rescues.
-        def attempt_require(path)
-          require_relative path
-          nil
-        rescue LoadError => e
-          e
-        end
-
-        def load_failure_reason(versioned, fallback)
-          packed = Dir.glob(File.join(__dir__, RUBY_VERSION.to_f.to_s, 'mergify_ci.*')).any?
-          packed ? versioned : fallback
-        end
-      end
-    end
-  end
-end
-
-# Precompiled gems ship lib/mergify/rspec/<ruby>/mergify_ci.<dlext>; the source
-# gem and any local `rake compile` put one beside this file instead.
-versioned_error = Mergify::RSpec::Native.attempt_require("#{RUBY_VERSION.to_f}/mergify_ci")
-fallback_error = versioned_error && Mergify::RSpec::Native.attempt_require('mergify_ci')
-
-if fallback_error
-  Mergify::RSpec::Native.load_error =
-    Mergify::RSpec::Native.load_failure_reason(versioned_error, fallback_error)
-end
-
-unless Mergify::RSpec::Native.available?
-  # Stand in for the extension so callers can just ask, and get the same answer
-  # they would get from a machine that is not in CI. Branching on availability
-  # at every call site would only spread the same nil back through the caller.
-  module Mergify
-    module RSpec
-      module Native
-        # A session that detects nothing, as on a machine that is not in CI.
-        class Session
-          def self.start(*)
-            new
-          end
-
-          # Nothing detected, so nothing to report to.
-          def reports?
-            false
-          end
-
-          def repository_name
-            nil
-          end
-
-          # Nothing detected: no run to name.
-          def run_id
-            nil
-          end
-
-          # Nothing to send a verdict with: it neither folds nor reports.
-          def record_test(_example_id, _status, _run_time); end
-
-          # Nothing to ask with: every example runs.
-          def select(_example_ids)
-            { 'outcome' => 'full' }
-          end
-
-          def executed_count
-            0
-          end
-
-          def report_verdict(_failed_outside_examples); end
-
-          def captured_verdict
-            nil
-          end
-
-          # Nothing to send a trace with either.
-          def record_case(_example); end
-
-          def record_retry(_example_id, _status, _duration_ms); end
-
-          def report_trace(_failed); end
-
-          # Nothing reported: nothing to say.
-          def summary(_partial)
-            []
-          end
-
-          def captured_trace
-            nil
-          end
-
-          # Nothing to rerun with.
-          def prepare_reruns(_example_ids)
-            nil
-          end
-        end
-      end
-    end
-  end
-end