rspec-mergify 0.2.0 → 0.4.0

data/lib/mergify/rspec/resources/rspec.rb

@@ -1,20 +1,24 @@
 # frozen_string_literal: true
 
-require 'opentelemetry-sdk'
 require 'rspec/core/version'
 
 module Mergify
   module RSpec
     module Resources
-      # Detects OpenTelemetry Resource attributes for RSpec.
+      # The resource attributes only Ruby knows: which framework ran the suite,
+      # and in which language.
       module RSpec
         module_function
 
         def detect
-          OpenTelemetry::SDK::Resources::Resource.create(
+          {
             'test.framework' => 'rspec',
-            'test.framework.version' => ::RSpec::Core::Version::STRING
-          )
+            'test.framework.version' => ::RSpec::Core::Version::STRING,
+            # Mergify takes a test's language from here when the span does not
+            # name one. The OpenTelemetry SDK sets this on its default resource,
+            # but this gem never used that resource, so nothing had ever sent it.
+            'telemetry.sdk.language' => 'ruby'
+          }
         end
       end
     end

data/lib/mergify/rspec/session_verdict.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'test_selection'
+
+module Mergify
+  module RSpec
+    # What the session concluded about each example, folded as RSpec reports
+    # it, and written to Mergify when the session ends.
+    #
+    # Test Selection answers a merge-queue rerun from its predecessor's
+    # verdict: which examples failed, whether anything ran at all. The verdict
+    # is sent in one request before the trace upload, so the answer is there
+    # seconds after the session ends rather than whenever trace ingestion gets
+    # to it (INC-2434).
+    #
+    # One status per example, its FINAL one -- the status RSpec reported once
+    # flaky detection's reruns were over, which is what decided the exit code.
+    # A verdict that disagreed with the exit code would either replay examples
+    # that did not gate, or skip the one that did.
+    class SessionVerdict
+      # A failure the quarantine absorbed is `quarantined_failed`: it did not
+      # gate the job, so a rerun must not replay it, but it did run and fail,
+      # so it is not green either.
+      PRECEDENCE = { 'passed' => 0, 'skipped' => 1, 'quarantined_failed' => 2, 'failed' => 3 }.freeze
+
+      # How sending went, for the report. `sent` is false both when nothing
+      # had to be sent and when the request failed; `error` tells them apart.
+      Result = Struct.new(:sent, :truncated, :error, keyword_init: true) do
+        # Said only when the verdict did not reach Mergify whole. Wording
+        # validated by Alexandre on 2026-09-15 (MRGFY-9313), pytest-mergify's
+        # verbatim; a change here is a product decision.
+        def report
+          if error
+            "#{TestSelection.wrap("Mergify couldn't record this run's results. If this merge-queue batch is " \
+                                  'retried, this job will run its full test suite.')}\nError: #{error}\n"
+          elsif truncated
+            "#{TestSelection.wrap("Mergify recorded this run's counts but not its failing tests. If this " \
+                                  'merge-queue batch is retried, this job will run its full test suite.')}\n"
+          end
+        end
+      end
+
+      def initialize
+        @final = {}
+        @runtime_seconds = 0.0
+      end
+
+      def record(example_id, status, run_time)
+        @runtime_seconds += run_time.to_f
+        previous = @final[example_id]
+        @final[example_id] = status if previous.nil? || PRECEDENCE.fetch(status) > PRECEDENCE.fetch(previous)
+      end
+
+      def total_test_runtime_ms
+        (@runtime_seconds * 1000).to_i
+      end
+
+      # The engine's own definitions: `executed` counts every example that
+      # reached a status, a skipped one included, and `failed` includes the
+      # quarantined failures.
+      def counts
+        statuses = @final.values
+        {
+          'executed_count' => statuses.size,
+          'passed_count' => statuses.count('passed'),
+          'failed_count' => statuses.count { |status| %w[failed quarantined_failed].include?(status) },
+          'skipped_count' => statuses.count('skipped')
+        }
+      end
+
+      def failing_tests
+        ids_with('failed')
+      end
+
+      def quarantined_failing_tests
+        ids_with('quarantined_failed')
+      end
+
+      private
+
+      def ids_with(status)
+        @final.filter_map { |id, final| id if final == status }
+      end
+    end
+  end
+end

data/lib/mergify/rspec/test_selection.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative 'utils'
+
+module Mergify
+  module RSpec
+    # Raised by `TestSelection#resolve` when Mergify refuses to choose a
+    # selection for this run, carrying the explanation to show. The caller
+    # stops the run with it.
+    class TestSelectionRefused < StandardError; end
+
+    # Whether this run should execute only part of what it collected.
+    #
+    # A merge-queue rerun only needs to replay the examples that failed on the
+    # previous attempt of the same job. Mergify decides that server-side from
+    # the run's own identity AND from the fingerprint of what the run
+    # collected, which is why the request leaves only once RSpec has loaded
+    # and filtered its examples. The answer is one of:
+    #
+    # * `full` -- run everything;
+    # * `subset` -- run only `tests`;
+    # * `empty` -- run nothing: the previous attempt ran these examples and
+    #   they passed, so the run exits green having executed none;
+    # * `refused` -- Mergify holds several candidate sessions for this job and
+    #   will not guess between them, so the run FAILS with its explanation.
+    #
+    # Every error, and every answer outside that list, runs the whole suite:
+    # the feature can remove work, never correctness. pytest-mergify's
+    # `TestSelection`, answer for answer and sentence for sentence.
+    #
+    # When an answer cannot be honoured the run executes everything and says
+    # so in `not_applied_reason`, never by rewriting `selection` or `reason`:
+    # those two carry Mergify's word.
+    # rubocop:disable-next Metrics/ClassLength
+    class TestSelection
+      ENABLE_ENV = 'MERGIFY_TEST_SELECTION_ENABLE'
+
+      CLIENT_NAME = 'rspec-mergify'
+      DOCS_URL = 'https://docs.mergify.com/ci-insights/test-frameworks/rspec/'
+
+      # What a refusal says when the server sent no wording of its own. The
+      # copy belongs to the server; this is a fallback, not the message.
+      FALLBACK_REFUSAL_MESSAGE = <<~MESSAGE.chomp
+        Mergify Test Selection stopped this run.
+
+        Several runs of this job report to Mergify under the same name, and they run the same tests — so Mergify cannot tell which one this run repeats, and it will not guess which tests to skip.
+
+        If this job runs more than once (a build matrix, for example), give each run its own name with MERGIFY_TEST_JOB_NAME:
+        #{DOCS_URL}
+
+        If this job only runs once, this is unexpected — please contact Mergify support.
+      MESSAGE
+
+      NOT_APPLIED_SENTENCE =
+        "Mergify's answer didn't match the tests this run collected, so the full suite ran."
+
+      # One sentence per reason the full suite ran. pytest-mergify's
+      # `_FULL_RUN_SENTENCES` verbatim (validated by Alexandre on 2026-09-11,
+      # MRGFY-8978), naming this gem where they name a client. A change here is
+      # a product decision.
+      FULL_RUN_SENTENCES = {
+        'no_predecessor' => 'First attempt of this batch, so the full suite ran.',
+        'not_a_merge_queue_run' => "This job isn't part of a merge queue run, so the full suite ran.",
+        'stale_run' => 'The batch branch was updated while this job was running, so the full suite ran.',
+        'no_matching_test_session' =>
+          "The previous attempt didn't run this exact set of tests, so the full suite ran.",
+        'matched_test_session_ran_no_test' => 'The previous attempt executed no tests, so the full suite ran.',
+        'predecessor_unknown' => "Mergify couldn't tell which previous run to start from, so the full suite ran.",
+        'indeterminate_test_session' =>
+          "Mergify couldn't tell which previous run to start from, so the full suite ran.",
+        'matched_test_session_partially_processed' =>
+          "Mergify didn't have the complete results of the previous attempt, so the full suite ran.",
+        'matched_test_session_dropped_cases' =>
+          "Mergify didn't have the complete results of the previous attempt, so the full suite ran.",
+        'matched_test_session_declaration_unreadable' =>
+          "Mergify didn't have the complete results of the previous attempt, so the full suite ran.",
+        'matched_test_session_incomplete' =>
+          'The previous attempt stopped before running all of its tests, so the full suite ran.',
+        'matched_test_session_failures_truncated' =>
+          'The previous attempt had too many failures for Mergify to list, so the full suite ran.',
+        'no_collection_fingerprint' =>
+          "This version of #{CLIENT_NAME} doesn't report what it collected, so the full suite ran. " \
+          'Upgrade it to let Mergify reduce reruns.',
+        'feature_disabled' => "Test selection isn't enabled for this organization yet, so the full suite ran.",
+        'not_requested' => "Test selection isn't available for this repository, so the full suite ran.",
+        'unrecognised_selection' =>
+          "Mergify answered in a way this version of #{CLIENT_NAME} doesn't understand, so the full suite " \
+          'ran. Upgrade it to let Mergify reduce reruns.',
+        'subset_served_without_tests' => NOT_APPLIED_SENTENCE,
+        'subset_matched_no_collected_test' => NOT_APPLIED_SENTENCE,
+        'subset_partly_absent_from_collection' => NOT_APPLIED_SENTENCE
+      }.freeze
+
+      # A newer engine may serve a reason this gem predates. The block must
+      # still read as a full run, and must never show the raw identifier.
+      UNKNOWN_REASON_SENTENCE = 'Mergify served the full suite.'
+
+      HEADER = '✂️ Test selection'
+
+      # How many re-executed examples the subset block lists before counting
+      # the rest.
+      LISTED_TESTS_MAX = 10
+
+      # The width the wording was validated at.
+      WRAP_WIDTH = 80
+
+      KNOWN_ANSWERS = %w[full subset empty refused].freeze
+
+      attr_reader :selection, :reason, :tests, :message, :init_error_msg,
+                  :not_applied_reason, :kept_count, :deselected_count, :kept_tests
+
+      class << self
+        # Whether this job asked for test selection. Opt-in and per job: a job
+        # that has not opted in asks nothing, which is what lets Mergify tell
+        # a repository that never opted in from one that did (MRGFY-9172).
+        # Trimmed, and anything unrecognised is off -- the direction that runs
+        # the whole suite.
+        def enabled?
+          Utils::TRUTHY_STRINGS.include?(ENV.fetch(ENABLE_ENV, '').strip.downcase)
+        end
+
+        # What Mergify answered, as the binding hands it over.
+        def served(answer)
+          new(selection: answer['selection'], reason: answer['reason'], tests: answer['tests'] || [],
+              message: answer['message'], served: true)
+        end
+
+        # A run Mergify did not answer: the repository has no such feature, or
+        # the request failed. Both run everything, and neither was offered
+        # anything, so neither is echoed as an answer.
+        def unanswered(init_error_msg: nil)
+          new(selection: 'full', reason: 'not_requested', tests: [], message: nil,
+              served: false, init_error_msg: init_error_msg)
+        end
+      end
+
+      # rubocop:disable-next Metrics/ParameterLists,Metrics/MethodLength
+      def initialize(selection:, reason:, tests:, message:, served:, init_error_msg: nil)
+        @selection = selection
+        @reason = reason
+        @tests = tests
+        @message = message
+        @served = served
+        @init_error_msg = init_error_msg
+        @not_applied_reason = nil
+        @kept_count = nil
+        @deselected_count = 0
+        @kept_tests = []
+
+        # A subset is only honoured with a non-empty list, and an answer this
+        # gem predates is never acted on: both run everything, and say so.
+        if @selection == 'subset'
+          @not_applied_reason = 'subset_served_without_tests' if @tests.empty?
+        else
+          @not_applied_reason = 'unrecognised_selection' unless KNOWN_ANSWERS.include?(@selection)
+          @tests = []
+        end
+      end
+
+      def served?
+        @served
+      end
+
+      def refused?
+        @not_applied_reason.nil? && @selection == 'refused'
+      end
+
+      # Decide what the answer leaves of this collection to run: the ids to
+      # keep, or nil for all of them. Raises `TestSelectionRefused` on a
+      # refusal, carrying the server's explanation.
+      #
+      # Matching is by exact example id, the identity this gem uploads. A
+      # subset is honoured all or not at all: one served id this run did not
+      # collect declines the whole answer and runs everything, rather than a
+      # reduced run over an arbitrary part of what was asked for.
+      # rubocop:disable-next Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      def resolve(ids)
+        return nil unless @not_applied_reason.nil?
+
+        raise TestSelectionRefused, @message.to_s.empty? ? FALLBACK_REFUSAL_MESSAGE : @message if refused?
+
+        if @selection == 'empty'
+          # A collection already empty is left alone: the run is then empty for
+          # a reason of its own, and announcing a skip over it would mislead.
+          return nil if ids.empty?
+
+          @deselected_count = ids.size
+          return Set.new
+        end
+
+        return nil unless @selection == 'subset'
+
+        subset = @tests.to_set
+        kept = ids.select { |id| subset.include?(id) }
+        matched = kept.to_set
+        # Identities, not counts, so a repeated id can never stand in for a
+        # missing one.
+        if matched != subset
+          @not_applied_reason =
+            matched.empty? ? 'subset_matched_no_collected_test' : 'subset_partly_absent_from_collection'
+          return nil
+        end
+
+        @kept_count = kept.size
+        @deselected_count = ids.size - kept.size
+        @kept_tests = kept
+        subset
+      end
+
+      # The block printed in the gem's "Mergify CI" report: what reduced this
+      # run, whether it was deliberate, and whether its green can be trusted.
+      # Prose, and no identifier from the API ever reaches it.
+      # rubocop:disable-next Metrics/MethodLength
+      def report
+        if @init_error_msg
+          # The error text on its own line: it is what support will ask for,
+          # and it usually carries a URL that wrapping would split.
+          return block("Mergify couldn't be asked whether this run could be reduced, so the full suite ran.") +
+                 "Error: #{@init_error_msg}\n"
+        end
+
+        if refused?
+          # The server's explanation was printed when the run stopped; the
+          # block only says where to look.
+          return block('Mergify stopped this run before any test ran; its explanation is in the error above.')
+        end
+
+        return block(FULL_RUN_SENTENCES.fetch(@not_applied_reason, UNKNOWN_REASON_SENTENCE)) if @not_applied_reason
+        return empty_block if @selection == 'empty'
+        return subset_block if @selection == 'subset' && @kept_count
+
+        block(FULL_RUN_SENTENCES.fetch(@reason, UNKNOWN_REASON_SENTENCE))
+      end
+
+      private
+
+      def empty_block
+        skipped = @deselected_count
+        # Nothing was collected: the block is the title alone, rather than a
+        # paragraph about skipping "all 0 tests".
+        return "#{HEADER}\n" if skipped.zero?
+
+        passed, them =
+          skipped == 1 ? ['its only test passed back then', 'it'] : ["all #{skipped} tests passed back then", 'them']
+        block("The code under test hasn't changed since the previous attempt of this job, and #{passed}. " \
+              "Mergify skipped #{them}: the job is green, and no test was executed.")
+      end
+
+      # rubocop:disable-next Metrics/MethodLength
+      def subset_block
+        failed = @kept_count
+        skipped = @deselected_count
+        sentence =
+          if skipped.zero?
+            which, them =
+              failed == 1 ? ['its only test failed', 'it'] : ["all #{failed} of its tests failed", 'all of them']
+            "The code under test hasn't changed since the previous attempt of this job, where #{which}. " \
+              "Mergify re-executed #{them}:"
+          else
+            those = failed == 1 ? 'that one' : "those #{failed}"
+            "The code under test hasn't changed since the previous attempt of this job, where #{failed} of its " \
+              "#{count_tests(failed + skipped)} failed. Mergify re-executed only #{those} and skipped the " \
+              "#{skipped} that had already passed:"
+          end
+
+        lines = @kept_tests.first(LISTED_TESTS_MAX).map { |id| "  #{id}" }
+        remaining = @kept_tests.size - LISTED_TESTS_MAX
+        lines << "  … and #{remaining} more" if remaining.positive?
+        "#{block(sentence)}\n#{lines.join("\n")}\n"
+      end
+
+      def count_tests(count)
+        count == 1 ? '1 test' : "#{count} tests"
+      end
+
+      def block(text)
+        "#{HEADER}\n\n#{TestSelection.wrap(text)}\n"
+      end
+
+      class << self
+        # Greedy word wrap, the way Python's `textwrap.fill` does it for this
+        # prose: words are never split, and a word longer than the width sits
+        # on a line of its own.
+        def wrap(text, width = WRAP_WIDTH)
+          lines = []
+          text.split.each do |word|
+            if lines.empty? || lines.last.length + 1 + word.length > width
+              lines << word.dup
+            else
+              lines.last << ' ' << word
+            end
+          end
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/mergify/rspec/trace.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Mergify
+  module RSpec
+    # The little of OpenTelemetry this plugin actually used.
+    #
+    # A test run needs identifiers, a start and an end, some attributes and a
+    # status -- and the shared Rust client does the rest: the wire format, the
+    # compression, the retries, the size limit. The SDK brought samplers,
+    # context propagation machinery, batch processors and an exporter registry
+    # to do the part that fits here, and its dependency tree landed in every
+    # consumer's bundle. So the spans are assembled directly.
+    module Trace
+      # W3C traceparent: version-traceid-spanid-flags, all lowercase hex.
+      TRACEPARENT = /\A00-(?<trace_id>[0-9a-f]{32})-(?<span_id>[0-9a-f]{16})-[0-9a-f]{2}\z/
+
+      # A span being recorded, and once finished, the record itself.
+      class Span
+        attr_reader :name, :trace_id, :span_id, :parent_span_id, :attributes
+        attr_accessor :status, :status_message
+
+        def initialize(name:, trace_id:, span_id:, parent_span_id: nil, attributes: {})
+          @name = name
+          @trace_id = trace_id
+          @span_id = span_id
+          @parent_span_id = parent_span_id
+          @attributes = attributes.transform_keys(&:to_s)
+          @status = 'unset'
+          @status_message = nil
+          @start_unix_nano = Trace.now_unix_nano
+          @end_unix_nano = nil
+        end
+
+        # Ids travel as bytes and are read as hex -- in a traceparent, in a
+        # backend URL, in a log line.
+        def hex_trace_id
+          @trace_id.unpack1('H*')
+        end
+
+        def hex_span_id
+          @span_id.unpack1('H*')
+        end
+
+        def set_attribute(key, value)
+          @attributes[key.to_s] = value
+        end
+
+        def error!(message)
+          @status = 'error'
+          @status_message = message
+        end
+
+        def ok!
+          @status = 'ok'
+        end
+
+        def finish
+          @end_unix_nano ||= Trace.now_unix_nano
+          self
+        end
+
+        # The shape the binding accepts, which is the wire format's own.
+        # rubocop:disable-next Metrics/MethodLength
+        def to_h
+          {
+            'name' => @name,
+            'trace_id' => @trace_id,
+            'span_id' => @span_id,
+            'parent_span_id' => @parent_span_id,
+            'start_unix_nano' => @start_unix_nano,
+            'end_unix_nano' => @end_unix_nano || Trace.now_unix_nano,
+            'attributes' => @attributes,
+            'status' => @status,
+            'status_message' => @status_message
+          }.compact
+        end
+      end
+
+      # Collects a run's spans and hands them to the client in one upload.
+      #
+      # Deliberately not streaming: a suite's spans are worth one request at the
+      # end, and exporting mid-run would put HTTP in the middle of the thing
+      # being timed. That was already why the gem replaced the SDK's batch
+      # processor with its own.
+      class Recorder
+        attr_reader :resource_attributes, :finished_spans, :trace_id
+
+        # `traceparent` is the W3C header a caller can hand down to put this
+        # run inside a trace it already started; the session span then hangs off
+        # that caller's span rather than starting a trace of its own.
+        def initialize(resource_attributes: {}, traceparent: nil)
+          @resource_attributes = resource_attributes.transform_keys(&:to_s)
+          inherited = Trace.parse_traceparent(traceparent)
+          @trace_id = inherited ? inherited.first : Trace.generate_trace_id
+          @root_parent_span_id = inherited&.last
+          @finished_spans = []
+        end
+
+        def start_span(name, parent: nil, attributes: {})
+          Span.new(
+            name: name,
+            trace_id: @trace_id,
+            span_id: Trace.generate_span_id,
+            parent_span_id: parent&.span_id || @root_parent_span_id,
+            attributes: attributes
+          )
+        end
+
+        def record(span)
+          @finished_spans << span.finish
+          span
+        end
+
+        def clear
+          @finished_spans = []
+        end
+      end
+
+      class << self
+        def now_unix_nano
+          (Time.now.to_r * 1_000_000_000).to_i
+        end
+
+        def generate_trace_id
+          SecureRandom.bytes(16)
+        end
+
+        def generate_span_id
+          SecureRandom.bytes(8)
+        end
+
+        # The trace this run belongs to, when a parent handed one down.
+        # Returns [trace_id, parent_span_id] as raw bytes, or nil.
+        def parse_traceparent(header)
+          match = TRACEPARENT.match(header.to_s)
+          return nil unless match
+
+          [[match[:trace_id]].pack('H*'), [match[:span_id]].pack('H*')]
+        end
+      end
+    end
+  end
+end

data/lib/mergify/rspec/utils.rb

@@ -45,6 +45,13 @@ module Mergify
         env_truthy?('CI') || env_truthy?('RSPEC_MERGIFY_ENABLE')
       end
 
+      # Returns true inside one of the processes parallel_tests or turbo_tests
+      # splits a suite across. Both set TEST_ENV_NUMBER, to an empty string for
+      # parallel_tests' first worker, so it is the key that counts.
+      def parallel_worker?
+        ENV.key?('TEST_ENV_NUMBER')
+      end
+
       # Split "owner/repo" into [owner, repo].
       # Raises InvalidRepositoryFullNameError when the format is wrong.
       def split_full_repo_name(full_repo_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 = '0.2.0'
+    VERSION = '0.4.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-mergify
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Mergify
@@ -9,34 +9,6 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: opentelemetry-exporter-otlp
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.29'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.29'
-- !ruby/object:Gem::Dependency
-  name: opentelemetry-sdk
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.4'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: rspec-core
   requirement: !ruby/object:Gem::Requirement
@@ -69,7 +41,9 @@ files:
 - lib/mergify/rspec/native.rb
 - lib/mergify/rspec/quarantine.rb
 - lib/mergify/rspec/resources/rspec.rb
-- lib/mergify/rspec/synchronous_batch_span_processor.rb
+- lib/mergify/rspec/session_verdict.rb
+- lib/mergify/rspec/test_selection.rb
+- lib/mergify/rspec/trace.rb
 - lib/mergify/rspec/utils.rb
 - lib/mergify/rspec/version.rb
 - lib/rspec_mergify.rb
@@ -94,7 +68,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: RSpec plugin for Mergify CI Insights
 test_files: []

data/lib/mergify/rspec/synchronous_batch_span_processor.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'opentelemetry-sdk'
-
-module Mergify
-  module RSpec
-    class ExportError < StandardError; end
-
-    # A span processor that queues spans in memory and exports them all in one
-    # batch when force_flush is called. This avoids HTTP requests during test
-    # execution.
-    class SynchronousBatchSpanProcessor < OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor
-      def initialize(exporter)
-        super
-        @queue = []
-      end
-
-      def on_finish(span)
-        return unless span.context.trace_flags.sampled?
-
-        @queue << span.to_span_data
-      end
-
-      def force_flush(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
-        spans = @queue.dup
-        @queue.clear
-        result = @span_exporter.export(spans)
-        raise ExportError, 'Failed to export traces' unless result == OpenTelemetry::SDK::Trace::Export::SUCCESS
-
-        OpenTelemetry::SDK::Trace::Export::SUCCESS
-      end
-    end
-  end
-end