rspec-mergify 0.1.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3b9e1b83fe9ad90add227b5618ac7b4594883cf39c0eb58ab150feb0de9d916
-  data.tar.gz: e801b0a101413dea6c0d723e58d79c4a978cffdf252ca35332a64e47c4b75493
+  metadata.gz: 0e962d0dafd4d52189d682226bdfee4729bab091553a4b0ab261c1f371003b5c
+  data.tar.gz: 98b9017bf4067a6f4bc42a90a7ee957e3fb82899c368704c17c8b150b6234e03
 SHA512:
-  metadata.gz: 1a30b290d0860751b9a8be05cc18615415c0f3dc8ae16fbdd9ea877b54688767625e4d931e88f901ecbf8ca2dddc2e02eee457958ca31e7fb8fb305088912b66
-  data.tar.gz: 643aa383dbaa5324534aea467d8220642f3240182e16d57447d73e4dd44e4a0337d4de9514233b13498802057638d4574311bb046d57cd93898ddf1747361b00
+  metadata.gz: 6020c63eb271ebf4da6dcfaa1e7b6ef4f7b2a8e61741dc6840cc934021250eabb5592dcad2d57cbd41950285eb55370deff9c7bb3aa37aef8c1bf689f0ccf380
+  data.tar.gz: a50947dbb468eca3b1deec17218e15fd08c80a051101ad11c71e3f4af9b45488a1f3bf4ebc026e6b6ae0869b6834110b0caabda45794d990350923c4a70802ae

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,37 +1,29 @@
 # frozen_string_literal: true
 
 require 'securerandom'
-require 'opentelemetry-sdk'
+require_relative 'trace'
 require_relative 'utils'
-require_relative 'synchronous_batch_span_processor'
-require_relative 'resources/ci'
-require_relative 'resources/git'
-require_relative 'resources/github_actions'
-require_relative 'resources/jenkins'
-require_relative 'resources/buildkite'
-require_relative 'resources/mergify'
+require_relative 'native'
 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
 
       # rubocop:disable-next Metrics/MethodLength
       def initialize
         @token = ENV.fetch('MERGIFY_TOKEN', nil)
-        @repo_name = Utils.repository_name
+        @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
@@ -40,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)
 
@@ -49,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
@@ -81,62 +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
 
-      # rubocop:disable-next Metrics/MethodLength
+      # The cicd.* and vcs.* attributes come from the Rust core, which every
+      # 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 = [
-          Resources::CI.detect,
-          Resources::Git.detect,
-          Resources::GitHubActions.detect,
-          Resources::Jenkins.detect,
-          Resources::Buildkite.detect,
-          Resources::Mergify.detect,
-          Resources::RSpec.detect
-        ]
-        base = resources.reduce(OpenTelemetry::SDK::Resources::Resource.create({})) do |merged, r|
-          merged.merge(r)
-        end
-        run_id_resource = OpenTelemetry::SDK::Resources::Resource.create('test.run.id' => @test_run_id)
-        base.merge(run_id_resource)
-      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

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
-require 'net/http'
-require 'json'
-require 'uri'
 require 'set'
 require_relative 'utils'
+require_relative 'native'
+require_relative 'version'
 
 module Mergify
   module RSpec
@@ -74,34 +73,25 @@ module Mergify
         @tests_to_process = []
         @budget = 0.0
 
-        fetch_context
-        validate!
+        @context = fetch_context
+        raise FlakyDetectionDisabledError unless Native::Budget.should_run(@context, @mode)
       end
 
-      # rubocop:disable-next Metrics/MethodLength,Metrics/AbcSize
+      # Which tests this session reruns, and how long it may spend doing it,
+      # both come from the shared budget engine -- so a Ruby suite and a Python
+      # one facing the same context spend the same time.
+      #
+      # The engine sizes the budget from the existing tests *in this session*,
+      # where this class counted every existing test the context knew about. A
+      # session running part of a suite was handed the whole suite's budget; it
+      # now gets its own.
       def prepare_for_session(test_ids)
-        existing = Set.new(@context[:existing_test_names])
-        unhealthy = Set.new(@context[:unhealthy_test_names])
-
-        @tests_to_process =
-          if @mode == 'new'
-            test_ids.reject { |id| existing.include?(id) }
-          else
-            test_ids.select { |id| unhealthy.include?(id) }
-          end
-
-        budget_ratio = if @mode == 'new'
-                         @context[:budget_ratio_for_new_tests]
-                       else
-                         @context[:budget_ratio_for_unhealthy_tests]
-                       end
+        plan = Native::Budget.compute(@context, @mode, test_ids, [])
 
-        mean_duration_s = @context[:existing_tests_mean_duration_ms] / 1000.0
-        existing_count = @context[:existing_test_names].size
-        min_budget_s = @context[:min_budget_duration_ms] / 1000.0
-
-        ratio_budget = budget_ratio * mean_duration_s * existing_count
-        @budget = [ratio_budget, min_budget_s].max
+        @tests_to_process = plan['tests_to_process']
+        # The engine works in milliseconds; everything downstream compares
+        # against RSpec's durations, which are seconds.
+        @budget = plan['available_budget_ms'] / 1000.0
       end
 
       # rubocop:disable-next Metrics/MethodLength
@@ -113,7 +103,7 @@ module Mergify
 
         return unless @tests_to_process.include?(test_id)
 
-        if test_id.length > @context[:max_test_name_length]
+        if test_id.length > @context['max_test_name_length']
           @over_length_tests.add(test_id)
           return
         end
@@ -136,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
@@ -153,7 +142,7 @@ module Mergify
         return false unless @metrics.key?(test_id)
 
         metrics = @metrics[test_id]
-        min_exec = @context[:min_test_execution_count]
+        min_exec = @context['min_test_execution_count']
         (metrics.initial_duration * min_exec) > metrics.remaining_time
       end
 
@@ -161,7 +150,7 @@ module Mergify
         return false unless @metrics.key?(test_id)
 
         metrics = @metrics[test_id]
-        metrics.will_exceed_deadline? || metrics.rerun_count >= @context[:max_test_execution_count]
+        metrics.will_exceed_deadline? || metrics.rerun_count >= @context['max_test_execution_count']
       end
 
       def test_metrics(test_id)
@@ -196,67 +185,33 @@ module Mergify
 
       private
 
-      # rubocop:disable-next Metrics/AbcSize,Metrics/MethodLength
+      # A nil context means the repository has not opted into flaky detection,
+      # which is the expected default rather than a failure.
       def fetch_context
-        owner, repo = Utils.split_full_repo_name(@full_repository_name)
-        uri = URI("#{@url}/v1/ci/#{owner}/repositories/#{repo}/flaky-detection-context")
-
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == 'https'
-        http.open_timeout = 10
-        http.read_timeout = 10
-
-        request = Net::HTTP::Get.new(uri)
-        request['Authorization'] = "Bearer #{@token}"
-
-        response = http.request(request)
-        case response.code.to_i
-        when 200
-          parse_context(response.body)
-        when 404
-          # A 404 means the repository has not opted into flaky detection; this
-          # is the expected default, not an error.
-          raise FlakyDetectionDisabledError
-        else
-          raise "Mergify API returned HTTP #{response.code}"
-        end
-      end
+        raise FlakyDetectionDisabledError unless Native.available?
 
-      # rubocop:disable-next Metrics/MethodLength,Metrics/AbcSize
-      def parse_context(body)
-        data = JSON.parse(body, symbolize_names: true)
-        @context = {
-          budget_ratio_for_new_tests: data[:budget_ratio_for_new_tests].to_f,
-          budget_ratio_for_unhealthy_tests: data[:budget_ratio_for_unhealthy_tests].to_f,
-          existing_test_names: Array(data[:existing_test_names]),
-          existing_tests_mean_duration_ms: data[:existing_tests_mean_duration_ms].to_f,
-          unhealthy_test_names: Array(data[:unhealthy_test_names]),
-          max_test_execution_count: data[:max_test_execution_count].to_i,
-          max_test_name_length: data[:max_test_name_length].to_i,
-          min_budget_duration_ms: data[:min_budget_duration_ms].to_f,
-          min_test_execution_count: data[:min_test_execution_count].to_i
-        }
-      end
-
-      def validate!
-        return unless @mode == 'new' && @context[:existing_test_names].empty?
-
-        # Without a baseline, `new` mode would treat every test as new and rerun
-        # the whole suite. Skip instead of surfacing an error.
-        raise FlakyDetectionDisabledError
-      end
+        owner, repo = Utils.split_full_repo_name(@full_repository_name)
+        context = Native::Client.new(@url, @token, owner, repo, VERSION).fetch_flaky_context
+        raise FlakyDetectionDisabledError if context.nil?
 
-      def remaining_budget
-        used = budget_used
-        [@budget - used, 0.0].max
+        context
       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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Mergify
+  module RSpec
+    # The Rust extension over mergify-ci-core: CI detection 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
+      # Raised when a Mergify API call fails outright.
+      #
+      # Distinct from StandardError on purpose: callers degrade on an API
+      # failure, and a bare rescue there would swallow genuine bugs in the
+      # binding as though the backend were down.
+      class ApiError < StandardError; end
+
+      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
+        class << self
+          def detect_provider
+            nil
+          end
+
+          def detect_repository_name
+            nil
+          end
+
+          def detect_attributes
+            {}
+          end
+        end
+      end
+    end
+  end
+end