rspec-mergify 0.2.0-x86_64-linux → 0.3.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f780ead2142231a815ead11c224dfaa6755bf705face5454b912a0f6411f3711
-  data.tar.gz: ca7701151c7015707c8a1e9d784844e7a8c939f21dd3c3afd01b61141e1038c5
+  metadata.gz: 4dabe88c5f64038181d8a4939b92178c44f3f06e8d83afdaa80a35d3683d8afd
+  data.tar.gz: 2de7f3aec3374465de5425ef58d7325f084626696b185f0e0d31011f82525c4f
 SHA512:
-  metadata.gz: f45dc1da3c292a7a5f05a8531ee63bf83fb804d0051beb7667075742522451bb6c36e1f2d99f4e0cdb56bd66e445860c5d9387331ae7ff8ae5b97fd15df70f69
-  data.tar.gz: 4b6295d176645780f74f2aebf3e6162110136163520624c4a274c12e7a06bd089103fc1f9d11712d5a6422e998fb3a4597f46a45830f3c8a74f463420dda3c0e
+  metadata.gz: 0a90d80f864b1a122e576f76475f2d91e46246a175e922da180dee5bb6205b7dd3e4efba5182747341676c6bd6aec5b523c556621910a6e5a65ad0935b0aadc2
+  data.tar.gz: d67e1e86f964c57c25aaf4afc0a45636c7f8e40279eccb9f3b7c2c0f9e8ab5cfe565c4fb5f10f69d7e5af9b0ca2af61e0061aadb964a5b8d9993f2b33b5ab436

data/README.md

@@ -18,6 +18,23 @@ gem 'rspec-mergify'
 
 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:
+
+| Platform | Requirement |
+|---|---|
+| Linux x86_64 / aarch64 (glibc) | **glibc 2.30 or newer** — Debian 11+, Ubuntu 20.04+, RHEL 9+, Amazon Linux 2023 |
+| Linux x86_64 / aarch64 (musl) | Alpine; on Ruby 3.1 also `apk add libgcc` |
+| macOS arm64 / x86_64 | — |
+| Windows x64 (UCRT) | — |
+
+Anywhere else, and on glibc older than 2.30 — RHEL, Rocky, AlmaLinux and Oracle Linux 8, Amazon Linux 2, CentOS 7 — the extension cannot load. The gem still installs and your suite still runs, but nothing is reported to Mergify. Pin the last pure-Ruby release on those systems:
+
+```ruby
+gem 'rspec-mergify', '0.1.4'
+```
+
 ## Configuration
 
 Set the `MERGIFY_TOKEN` environment variable with your Mergify API token.

data/lib/mergify/rspec/ci_insights.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
 require 'securerandom'
-require 'opentelemetry-sdk'
+require_relative 'trace'
 require_relative 'utils'
 require_relative 'native'
-require_relative 'synchronous_batch_span_processor'
 require_relative 'resources/rspec'
 
 module Mergify
   module RSpec
-    # Central orchestrator for Mergify Test Insights: sets up OpenTelemetry tracing,
-    # manages the tracer provider, and coordinates flaky detection and quarantine.
-    # rubocop:disable-next Metrics/ClassLength
+    # Central orchestrator for Mergify Test Insights: records the run's spans,
+    # uploads them, and coordinates flaky detection and quarantine.
     class CIInsights
       attr_reader :token, :repo_name, :api_url, :test_run_id,
-                  :tracer_provider, :tracer, :exporter,
+                  :recorder,
                   :branch_name,
                   :flaky_detector, :flaky_detector_error_message, :quarantined_tests
 
@@ -24,9 +22,8 @@ module Mergify
         @repo_name = Native.detect_repository_name
         @api_url = ENV.fetch('MERGIFY_API_URL', 'https://api.mergify.com')
         @test_run_id = SecureRandom.hex(8)
-        @tracer_provider = nil
-        @tracer = nil
-        @exporter = nil
+        @recorder = nil
+        @uploads = false
         @branch_name = nil
         @flaky_detector = nil
         @flaky_detector_error_message = nil
@@ -35,6 +32,21 @@ module Mergify
         setup_tracing if Utils.in_ci?
       end
 
+      # Send the run, once, at the end. Failing to report a run is worth
+      # saying out loud but never worth failing a suite that just passed,
+      # so this answers with a message instead of raising.
+      def flush
+        return nil unless @recorder && @uploads
+        return nil if @recorder.finished_spans.empty?
+
+        owner, repo = Utils.split_full_repo_name(@repo_name)
+        client = Native::Client.new(@api_url, @token, owner, repo, Mergify::RSpec::VERSION)
+        client.upload_trace(@recorder.resource_attributes, @recorder.finished_spans.map(&:to_h))
+        nil
+      rescue Native::ApiError, Utils::InvalidRepositoryFullNameError => e
+        e.message
+      end
+
       def mark_test_as_quarantined_if_needed(example_id) # rubocop:disable Naming/PredicateMethod
         return false unless @quarantined_tests&.include?(example_id)
 
@@ -44,30 +56,25 @@ module Mergify
 
       private
 
+      # Recording is unconditional; whether the run is *uploaded* is what the
+      # token and repository decide. Debug and test runs keep their spans and
+      # send nothing, which is what they always did -- the difference is that
+      # the collector is the same object either way instead of two processors.
       def setup_tracing
-        processor, exp = build_processor
-        return unless processor
-
-        @exporter = exp
         resource = build_resource
-        @tracer_provider = OpenTelemetry::SDK::Trace::TracerProvider.new(resource: resource)
-        @tracer_provider.add_span_processor(processor)
-        @tracer = @tracer_provider.tracer('rspec-mergify', Mergify::RSpec::VERSION)
-        @branch_name = extract_branch_name(resource)
+        @recorder = Trace::Recorder.new(resource_attributes: resource,
+                                        traceparent: ENV.fetch('MERGIFY_TRACEPARENT', nil))
+        @uploads = uploadable?
+        # Only a pull request has a base branch, and that is what puts flaky
+        # detection in 'new' mode. GitHub Actions still sets GITHUB_BASE_REF on
+        # every other event, to an empty string, so empty counts as absent.
+        base_branch_name = resource['vcs.ref.base.name']
+        @base_branch_name = base_branch_name unless base_branch_name.to_s.empty?
+        @branch_name = @base_branch_name || resource['vcs.ref.head.name']
         load_flaky_detector
         load_quarantine
       end
 
-      def build_processor
-        if debug_mode? || test_mode?
-          build_in_memory_processor
-        elsif @token && @repo_name
-          build_otlp_processor
-        else
-          [nil, nil]
-        end
-      end
-
       def debug_mode?
         ENV.key?('RSPEC_MERGIFY_DEBUG')
       end
@@ -76,59 +83,23 @@ module Mergify
         ENV['_RSPEC_MERGIFY_TEST'] == 'true'
       end
 
-      def build_in_memory_processor
-        exp = OpenTelemetry::SDK::Trace::Export::InMemorySpanExporter.new
-        processor = OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(exp)
-        [processor, exp]
-      end
+      # A run is uploaded when there is somewhere to upload it to and nothing
+      # asking us not to: debug and test runs record and keep.
+      def uploadable?
+        return false if debug_mode? || test_mode?
+        return false unless @token && @repo_name && Native.available?
 
-      def build_otlp_processor
-        owner, repo = Utils.split_full_repo_name(@repo_name)
-        endpoint = "#{@api_url}/v1/ci/#{owner}/repositories/#{repo}/traces"
-        exp = create_otlp_exporter(endpoint)
-        processor = SynchronousBatchSpanProcessor.new(exp)
-        [processor, exp]
+        true
       end
 
       # The cicd.* and vcs.* attributes come from the Rust core, which every
-      # Mergify test client shares, so a provider gains them everywhere at once.
-      # What stays here is what only Ruby knows: the test framework, and the id
-      # this run invented for itself.
+      # Mergify test client shares, so a CI provider added there reaches every
+      # client at once. What stays here is what only Ruby knows: the test
+      # framework and its language, and the id this run invented for itself.
       def build_resource
-        resources = [
-          OpenTelemetry::SDK::Resources::Resource.create(Native.detect_attributes),
-          Resources::RSpec.detect,
-          OpenTelemetry::SDK::Resources::Resource.create('test.run.id' => @test_run_id)
-        ]
-        resources.reduce(OpenTelemetry::SDK::Resources::Resource.create({})) do |merged, r|
-          merged.merge(r)
-        end
-      end
-
-      def extract_branch_name(resource)
-        attrs = resource.attribute_enumerator.to_h
-        @base_branch_name = attrs['vcs.ref.base.name']
-        @base_branch_name || attrs['vcs.ref.head.name']
-      end
-
-      # rubocop:disable-next Metrics/MethodLength
-      def create_otlp_exporter(endpoint)
-        require 'opentelemetry-exporter-otlp'
-        original_env = ENV.fetch('OTEL_EXPORTER_OTLP_TRACES_ENDPOINT', nil)
-        ENV['OTEL_EXPORTER_OTLP_TRACES_ENDPOINT'] = endpoint
-        begin
-          OpenTelemetry::Exporter::OTLP::Exporter.new(
-            endpoint: endpoint,
-            headers: { 'Authorization' => "Bearer #{@token}" },
-            compression: 'gzip'
-          )
-        ensure
-          if original_env
-            ENV['OTEL_EXPORTER_OTLP_TRACES_ENDPOINT'] = original_env
-          else
-            ENV.delete('OTEL_EXPORTER_OTLP_TRACES_ENDPOINT')
-          end
-        end
+        Native.detect_attributes
+              .merge(Resources::RSpec.detect)
+              .merge('test.run.id' => @test_run_id)
       end
 
       # rubocop:disable-next Metrics/MethodLength

data/lib/mergify/rspec/flaky_detection.rb

@@ -126,8 +126,7 @@ module Mergify
       def set_test_deadline(test_id, timeout: nil)
         return unless @metrics.key?(test_id)
 
-        remaining_tests = [remaining_tests_count, 1].max
-        per_test_budget = remaining_budget / remaining_tests
+        per_test_budget = next_test_share
 
         allocated =
           if timeout
@@ -198,17 +197,21 @@ module Mergify
         context
       end
 
-      def remaining_budget
-        used = budget_used
-        [@budget - used, 0.0].max
-      end
-
       def budget_used
         @metrics.sum { |_, m| m.total_duration }
       end
 
-      def remaining_tests_count
-        @tests_to_process.count { |id| !@metrics.key?(id) || @metrics[id].deadline.nil? }
+      # What is left of the budget, divided over the tests still waiting for a
+      # share of it. The engine works in milliseconds; RSpec durations are
+      # seconds.
+      def next_test_share
+        Native::Budget.dynamic_share_ms(
+          @budget * 1000, budget_used * 1000, @tests_to_process.size, processed_tests_count
+        ) / 1000.0
+      end
+
+      def processed_tests_count
+        @tests_to_process.count { |id| @metrics.key?(id) && !@metrics[id].deadline.nil? }
       end
     end
   end

data/lib/mergify/rspec/formatter.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 require 'rspec/core/formatters/base_formatter'
-require 'opentelemetry-sdk'
+require_relative 'trace'
+
+require 'mergify/rspec/native'
 
 module Mergify
   module RSpec
-    # RSpec formatter that creates OpenTelemetry spans for Mergify Test Insights and
+    # RSpec formatter that records spans for Mergify Test Insights and
     # prints a terminal report. It is purely observational and does not modify
     # test execution.
     # rubocop:disable-next Metrics/ClassLength
@@ -17,18 +19,14 @@ module Mergify
                                          :example_pending,
                                          :stop
 
-      # rubocop:disable-next Metrics/MethodLength
       def start(notification)
         super
 
         @ci_insights = Mergify::RSpec.ci_insights
-        return unless @ci_insights&.tracer
-
-        extract_distributed_trace_context
+        return unless @ci_insights&.recorder
 
-        @session_span = @ci_insights.tracer.start_span(
+        @session_span = @ci_insights.recorder.start_span(
           'rspec session start',
-          with_parent: @parent_context,
           attributes: { 'test.scope' => 'session' }
         )
         @has_error = false
@@ -36,15 +34,14 @@ module Mergify
       end
 
       def example_started(notification)
-        return unless @ci_insights&.tracer && @session_span
+        return unless @ci_insights&.recorder && @session_span
 
         example = notification.example
-        parent_context = OpenTelemetry::Trace.context_with_span(@session_span)
         quarantined = @ci_insights.mark_test_as_quarantined_if_needed(example.id)
 
-        span = @ci_insights.tracer.start_span(
+        span = @ci_insights.recorder.start_span(
           example.id,
-          with_parent: parent_context,
+          parent: @session_span,
           attributes: build_example_attributes(example, quarantined)
         )
         @example_spans[example.id] = span
@@ -67,10 +64,10 @@ module Mergify
           set_error_attributes(span, result.exception)
           @has_error = true
         else
-          span.status = OpenTelemetry::Trace::Status.ok
+          span.ok!
         end
 
-        span.finish
+        @ci_insights.recorder.record(span)
       end
 
       def example_pending(notification)
@@ -81,7 +78,7 @@ module Mergify
         return unless span
 
         span.set_attribute('test.case.result.status', 'skipped')
-        span.finish
+        @ci_insights.recorder.record(span)
       end
 
       def stop(_notification)
@@ -92,14 +89,6 @@ module Mergify
 
       private
 
-      def extract_distributed_trace_context
-        traceparent = ENV.fetch('MERGIFY_TRACEPARENT', nil)
-        @parent_context = if traceparent
-                            propagator = OpenTelemetry::Trace::Propagation::TraceContext::TextMapPropagator.new
-                            propagator.extract({ 'traceparent' => traceparent })
-                          end
-      end
-
       def build_example_attributes(example, quarantined)
         {
           'test.scope' => 'case',
@@ -133,18 +122,18 @@ module Mergify
         span.set_attribute('exception.type', exception.class.to_s)
         span.set_attribute('exception.message', exception.message)
         span.set_attribute('exception.stacktrace', exception.backtrace&.join("\n") || '')
-        span.status = OpenTelemetry::Trace::Status.error(exception.message)
+        span.error!(exception.message)
       end
 
       def finish_session_span
         return unless @session_span
 
-        @session_span.status = if @has_error
-                                 OpenTelemetry::Trace::Status.error('One or more tests failed')
-                               else
-                                 OpenTelemetry::Trace::Status.ok
-                               end
-        @session_span.finish
+        if @has_error
+          @session_span.error!('One or more tests failed')
+        else
+          @session_span.ok!
+        end
+        @ci_insights.recorder.record(@session_span)
       end
 
       # rubocop:disable-next Metrics/MethodLength
@@ -167,12 +156,21 @@ module Mergify
       def print_configuration_warnings
         output.puts 'WARNING: MERGIFY_TOKEN is not set. Traces will not be sent to Mergify.' unless @ci_insights.token
 
+        return print_native_warning unless Mergify::RSpec::Native.available?
         return if @ci_insights.repo_name
 
         output.puts 'WARNING: Could not detect repository name. ' \
                     'Please set GITHUB_REPOSITORY or configure a git remote.'
       end
 
+      # The extension is what detects CI, so when it did not load there is no
+      # repository name either, and blaming that would send people hunting for a
+      # git remote that is fine. Say what actually happened instead.
+      def print_native_warning
+        output.puts 'WARNING: the Mergify native extension could not be loaded, so this run reports nothing: ' \
+                    "#{Mergify::RSpec::Native.load_error&.message}"
+      end
+
       def print_flaky_report
         return unless @ci_insights.flaky_detector.respond_to?(:make_report)
 
@@ -187,20 +185,13 @@ module Mergify
         output.puts report if report
       end
 
-      def flush_and_shutdown # rubocop:disable Metrics/MethodLength
-        return unless @ci_insights&.tracer_provider
+      # One upload, at the end. There is nothing to shut down any more: the
+      # recorder holds spans in memory and the client owns the connection.
+      def flush_and_shutdown
+        return unless @ci_insights&.recorder
 
-        begin
-          @ci_insights.tracer_provider.force_flush
-        rescue StandardError => e
-          print_export_error(e)
-        end
-
-        begin
-          @ci_insights.tracer_provider.shutdown
-        rescue StandardError => e
-          output.puts "Error while shutting down the tracer: #{e.message}"
-        end
+        error = @ci_insights.flush
+        print_export_error(StandardError.new(error)) if error
       end
 
       def print_export_error(error)

data/lib/mergify/rspec/native.rb

@@ -27,21 +27,42 @@ module Mergify
         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
 
-begin
-  # Precompiled gems ship lib/mergify/rspec/<ruby>/mergify_ci.<dlext>.
-  require_relative "#{RUBY_VERSION.to_f}/mergify_ci"
-rescue LoadError
-  begin
-    # Source gem, and any local `rake compile`.
-    require_relative 'mergify_ci'
-  rescue LoadError => e
-    Mergify::RSpec::Native.load_error = e
-  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?

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/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/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.3.0'
   end
 end

metadata

@@ -1,43 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rspec-mergify
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: x86_64-linux
 authors:
 - Mergify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-09-11 00:00:00.000000000 Z
+date: 2026-09-17 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
@@ -75,7 +47,7 @@ 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/trace.rb
 - lib/mergify/rspec/utils.rb
 - lib/mergify/rspec/version.rb
 - lib/rspec_mergify.rb

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