rspec-mergify 0.0.0.dev

data/lib/mergify/rspec/formatter.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'rspec/core/formatters/base_formatter'
+require 'opentelemetry-sdk'
+
+module Mergify
+  module RSpec
+    # RSpec formatter that creates OpenTelemetry spans for CI Insights and
+    # prints a terminal report. It is purely observational and does not modify
+    # test execution.
+    # rubocop:disable Metrics/ClassLength
+    class Formatter < ::RSpec::Core::Formatters::BaseFormatter
+      ::RSpec::Core::Formatters.register self,
+                                         :start,
+                                         :example_started,
+                                         :example_finished,
+                                         :example_pending,
+                                         :stop
+
+      # rubocop:disable Metrics/MethodLength
+      def start(notification)
+        super
+
+        @ci_insights = Mergify::RSpec.ci_insights
+        return unless @ci_insights&.tracer
+
+        extract_distributed_trace_context
+
+        @session_span = @ci_insights.tracer.start_span(
+          'rspec session start',
+          with_parent: @parent_context,
+          attributes: { 'test.scope' => 'session' }
+        )
+        @has_error = false
+        @example_spans = {}
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def example_started(notification)
+        return unless @ci_insights&.tracer && @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(
+          example.id,
+          with_parent: parent_context,
+          attributes: build_example_attributes(example, quarantined)
+        )
+        @example_spans[example.id] = span
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def example_finished(notification)
+        return unless @example_spans
+
+        example = notification.example
+        span = @example_spans.delete(example.id)
+        return unless span
+
+        result = example.execution_result
+        status = result.status.to_s
+        span.set_attribute('test.case.result.status', status)
+        set_flaky_attributes(span, example)
+
+        if result.status == :failed
+          set_error_attributes(span, result.exception)
+          @has_error = true
+        else
+          span.status = OpenTelemetry::Trace::Status.ok
+        end
+
+        span.finish
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def example_pending(notification)
+        return unless @example_spans
+
+        example = notification.example
+        span = @example_spans.delete(example.id)
+        return unless span
+
+        span.set_attribute('test.case.result.status', 'skipped')
+        span.finish
+      end
+
+      def stop(_notification)
+        finish_session_span
+        print_report
+        flush_and_shutdown
+      end
+
+      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',
+          'code.filepath' => example.metadata[:file_path].delete_prefix('./'),
+          'code.function' => example.description,
+          'code.lineno' => example.metadata[:line_number] || 0,
+          'code.namespace' => example.example_group.description,
+          'code.file.path' => File.expand_path(example.metadata[:file_path]),
+          'code.line.number' => example.metadata[:line_number] || 0,
+          'cicd.test.quarantined' => quarantined
+        }
+      end
+
+      def set_flaky_attributes(span, example)
+        meta = example.metadata
+
+        rerun_count = meta[:mergify_rerun_count]
+        span.set_attribute('cicd.test.rerun_count', rerun_count) unless rerun_count.nil?
+
+        flaky = meta[:mergify_flaky]
+        span.set_attribute('cicd.test.flaky', flaky) unless flaky.nil?
+
+        flaky_detection = meta[:mergify_flaky_detection]
+        span.set_attribute('cicd.test.flaky_detection', flaky_detection) unless flaky_detection.nil?
+
+        new_test = meta[:mergify_new_test]
+        span.set_attribute('cicd.test.new', new_test) unless new_test.nil?
+      end
+
+      def set_error_attributes(span, exception)
+        span.set_attribute('exception.type', exception.class.to_s)
+        span.set_attribute('exception.message', exception.message)
+        span.status = OpenTelemetry::Trace::Status.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
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def print_report
+        output.puts ''
+        output.puts '--- Mergify CI ---'
+
+        unless @ci_insights
+          output.puts 'Mergify CI Insights is not configured.'
+          return
+        end
+
+        print_configuration_warnings
+        print_flaky_report
+        print_quarantine_report
+        output.puts "MERGIFY_TEST_RUN_ID=#{@ci_insights.test_run_id}"
+        output.puts '------------------'
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def print_configuration_warnings
+        output.puts 'WARNING: MERGIFY_TOKEN is not set. Traces will not be sent to Mergify.' unless @ci_insights.token
+
+        return if @ci_insights.repo_name
+
+        output.puts 'WARNING: Could not detect repository name. ' \
+                    'Please set GITHUB_REPOSITORY or configure a git remote.'
+      end
+
+      def print_flaky_report
+        return unless @ci_insights.flaky_detector.respond_to?(:make_report)
+
+        report = @ci_insights.flaky_detector.make_report
+        output.puts report if report
+      end
+
+      def print_quarantine_report
+        return unless @ci_insights.quarantined_tests.respond_to?(:report)
+
+        report = @ci_insights.quarantined_tests.report
+        output.puts report if report
+      end
+
+      def flush_and_shutdown # rubocop:disable Metrics/MethodLength
+        return unless @ci_insights&.tracer_provider
+
+        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
+      end
+
+      def print_export_error(error)
+        output.puts "Error while exporting traces: #{error.message}"
+        output.puts ''
+        output.puts 'Common issues:'
+        output.puts '  - Your MERGIFY_TOKEN might not be set or could be invalid'
+        output.puts '  - CI Insights might not be enabled for this repository'
+        output.puts '  - There might be a network connectivity issue with the Mergify API'
+        output.puts ''
+        output.puts 'Documentation: https://docs.mergify.com/ci-insights/test-frameworks/'
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/mergify/rspec/quarantine.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+require 'set'
+require_relative 'utils'
+
+module Mergify
+  module RSpec
+    # Fetches quarantined test names from the Mergify API and tracks which are used.
+    class Quarantine
+      attr_reader :quarantined_tests, :init_error_msg
+
+      def initialize(api_url:, token:, repo_name:, branch_name:)
+        @repo_name = repo_name
+        @branch_name = branch_name
+        @quarantined_tests = []
+        @used_tests = Set.new
+        @init_error_msg = nil
+
+        owner, repo = Utils.split_full_repo_name(repo_name)
+        fetch_quarantined_tests(api_url, token, owner, repo, branch_name)
+      rescue Utils::InvalidRepositoryFullNameError => e
+        @init_error_msg = e.message
+      end
+
+      def include?(example_id)
+        @quarantined_tests.include?(example_id)
+      end
+
+      def mark_as_used(example_id)
+        @used_tests.add(example_id)
+      end
+
+      # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+      def report
+        used, unused = @quarantined_tests.partition { |t| @used_tests.include?(t) }
+
+        lines = []
+        lines << 'Mergify Quarantine Report'
+        lines << "  Repository : #{@repo_name}"
+        lines << "  Branch     : #{@branch_name}"
+        lines << "  Quarantined tests from API: #{@quarantined_tests.size}"
+        lines << ''
+        lines << "  Quarantined tests run (#{used.size}):"
+        used.each { |t| lines << "    - #{t}" }
+        lines << ''
+        lines << "  Unused quarantined tests (#{unused.size}):"
+        unused.each { |t| lines << "    - #{t}" }
+        lines.join("\n")
+      end
+      # rubocop:enable Metrics/MethodLength,Metrics/AbcSize
+
+      private
+
+      # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+      def fetch_quarantined_tests(api_url, token, owner, repo, branch_name)
+        uri = URI("#{api_url}/v1/ci/#{owner}/repositories/#{repo}/quarantines")
+        uri.query = URI.encode_www_form(branch: branch_name)
+
+        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)
+        handle_response(response)
+      rescue Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNREFUSED, SocketError => e
+        @init_error_msg = "Failed to connect to Mergify API: #{e.message}"
+      end
+      # rubocop:enable Metrics/MethodLength,Metrics/AbcSize
+
+      def handle_response(response)
+        case response.code.to_i
+        when 200
+          data = JSON.parse(response.body)
+          @quarantined_tests = data.fetch('quarantined_tests', []).map { |t| t['test_name'] }
+        when 402
+          # No subscription — silently skip
+        else
+          @init_error_msg = "Mergify API returned HTTP #{response.code}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'opentelemetry-sdk'
+require_relative '../utils'
+
+module Mergify
+  module RSpec
+    module Resources
+      # Detects OpenTelemetry Resource attributes for the CI provider.
+      module CI
+        module_function
+
+        def detect
+          provider = Utils.ci_provider
+          return OpenTelemetry::SDK::Resources::Resource.create({}) if provider.nil?
+
+          OpenTelemetry::SDK::Resources::Resource.create(
+            'cicd.provider.name' => provider.to_s
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'opentelemetry-sdk'
+require_relative '../utils'
+
+module Mergify
+  module RSpec
+    module Resources
+      # Detects OpenTelemetry Resource attributes from git.
+      module Git
+        module_function
+
+        GIT_MAPPING = {
+          'vcs.ref.head.name' => [:to_s, -> { Utils.git('rev-parse', '--abbrev-ref', 'HEAD') }],
+          'vcs.ref.head.revision' => [:to_s, -> { Utils.git('rev-parse', 'HEAD') }],
+          'vcs.repository.url.full' => [:to_s, -> { Utils.git('config', '--get', 'remote.origin.url') }],
+          'vcs.repository.name' => [
+            :to_s,
+            lambda {
+              url = Utils.git('config', '--get', 'remote.origin.url')
+              Utils.repository_name_from_url(url) if url
+            }
+          ]
+        }.freeze
+
+        def detect
+          return OpenTelemetry::SDK::Resources::Resource.create({}) if Utils.ci_provider.nil?
+
+          attributes = Utils.get_attributes(GIT_MAPPING)
+          OpenTelemetry::SDK::Resources::Resource.create(attributes)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'opentelemetry-sdk'
+require_relative '../utils'
+
+module Mergify
+  module RSpec
+    module Resources
+      # Detects OpenTelemetry Resource attributes for GitHub Actions.
+      module GitHubActions
+        module_function
+
+        def detect
+          return OpenTelemetry::SDK::Resources::Resource.create({}) if Utils.ci_provider != :github_actions
+
+          attributes = Utils.get_attributes(GHA_MAPPING)
+          OpenTelemetry::SDK::Resources::Resource.create(attributes)
+        end
+
+        GHA_MAPPING = {
+          'cicd.pipeline.name' => [:to_s, 'GITHUB_WORKFLOW'],
+          'cicd.pipeline.task.name' => [:to_s, 'GITHUB_JOB'],
+          'cicd.pipeline.run.id' => [:to_i, 'GITHUB_RUN_ID'],
+          'cicd.pipeline.run.attempt' => [:to_i, 'GITHUB_RUN_ATTEMPT'],
+          'cicd.pipeline.runner.name' => [:to_s, 'RUNNER_NAME'],
+          'vcs.ref.head.name' => [:to_s, -> { head_ref_name }],
+          'vcs.ref.head.type' => [:to_s, 'GITHUB_REF_TYPE'],
+          'vcs.ref.base.name' => [:to_s, 'GITHUB_BASE_REF'],
+          'vcs.repository.name' => [:to_s, 'GITHUB_REPOSITORY'],
+          'vcs.repository.id' => [:to_i, 'GITHUB_REPOSITORY_ID'],
+          'vcs.repository.url.full' => [:to_s, -> { repository_url }],
+          'vcs.ref.head.revision' => [:to_s, -> { head_sha }]
+        }.freeze
+
+        def head_ref_name
+          ref = ENV.fetch('GITHUB_HEAD_REF', '')
+          ref.empty? ? ENV.fetch('GITHUB_REF_NAME', nil) : ref
+        end
+
+        def repository_url
+          server = ENV.fetch('GITHUB_SERVER_URL', nil)
+          repo = ENV.fetch('GITHUB_REPOSITORY', nil)
+          "#{server}/#{repo}" if server && repo
+        end
+
+        def head_sha
+          if ENV.fetch('GITHUB_EVENT_NAME', nil) == 'pull_request'
+            event_path = ENV.fetch('GITHUB_EVENT_PATH', nil)
+            if event_path && File.file?(event_path)
+              event = JSON.parse(File.read(event_path))
+              return event.dig('pull_request', 'head', 'sha').to_s
+            end
+          end
+          ENV.fetch('GITHUB_SHA', nil)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'opentelemetry-sdk'
+require_relative '../utils'
+require_relative 'git'
+
+module Mergify
+  module RSpec
+    module Resources
+      # Detects OpenTelemetry Resource attributes for Jenkins.
+      module Jenkins
+        module_function
+
+        GIT_BRANCH_PREFIXES = %w[origin/ refs/heads/].freeze
+
+        JENKINS_MAPPING = {
+          'cicd.pipeline.name' => [:to_s, 'JOB_NAME'],
+          'cicd.pipeline.task.name' => [:to_s, 'JOB_NAME'],
+          'cicd.pipeline.run.id' => [:to_s, 'BUILD_ID'],
+          'cicd.pipeline.run.url' => [:to_s, 'BUILD_URL'],
+          'cicd.pipeline.runner.name' => [:to_s, 'NODE_NAME'],
+          'vcs.ref.head.name' => [:to_s, -> { branch }],
+          'vcs.ref.head.revision' => [:to_s, 'GIT_COMMIT'],
+          'vcs.repository.url.full' => [:to_s, 'GIT_URL'],
+          'vcs.repository.name' => [
+            :to_s,
+            lambda {
+              url = ENV.fetch('GIT_URL', nil)
+              Utils.repository_name_from_url(url) if url
+            }
+          ]
+        }.freeze
+
+        def detect
+          return OpenTelemetry::SDK::Resources::Resource.create({}) if Utils.ci_provider != :jenkins
+
+          git_attrs = Utils.get_attributes(Git::GIT_MAPPING)
+          jenkins_attrs = Utils.get_attributes(JENKINS_MAPPING)
+          merged = git_attrs.merge(jenkins_attrs)
+          OpenTelemetry::SDK::Resources::Resource.create(merged)
+        end
+
+        def branch
+          raw = ENV.fetch('GIT_BRANCH', nil)
+          return nil unless raw
+
+          GIT_BRANCH_PREFIXES.each do |prefix|
+            return raw[prefix.length..] if raw.start_with?(prefix)
+          end
+          raw
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'opentelemetry-sdk'
+require_relative '../utils'
+
+module Mergify
+  module RSpec
+    module Resources
+      # Detects OpenTelemetry Resource attributes for Mergify-specific fields.
+      module Mergify
+        module_function
+
+        MERGIFY_MAPPING = {
+          'mergify.test.job.name' => [:to_s, 'MERGIFY_TEST_JOB_NAME']
+        }.freeze
+
+        def detect
+          attributes = Utils.get_attributes(MERGIFY_MAPPING)
+          OpenTelemetry::SDK::Resources::Resource.create(attributes)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'opentelemetry-sdk'
+require 'rspec/core/version'
+
+module Mergify
+  module RSpec
+    module Resources
+      # Detects OpenTelemetry Resource attributes for RSpec.
+      module RSpec
+        module_function
+
+        def detect
+          OpenTelemetry::SDK::Resources::Resource.create(
+            'test.framework' => 'rspec',
+            'test.framework.version' => ::RSpec::Core::Version::STRING
+          )
+        end
+      end
+    end
+  end
+end

data/lib/mergify/rspec/synchronous_batch_span_processor.rb

@@ -0,0 +1,34 @@
+# 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