gitlab_quality-test_tooling 2.16.1 → 2.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d4287c990a56b7a1f4c008c603bbef7c18870eafcca90efce10f78283b1b00d
-  data.tar.gz: c21e64acec896cb30bfb58940a0b0f0970bea0c263abb26dfcaf9f4af5c05dcc
+  metadata.gz: 7db77718644f72fd0a096182fdf76ad10c912002f0770e245ac782a9b238b690
+  data.tar.gz: 7b67154f177663fdc2bd19882b128e5eaa3540f20c31c50fddcf73c6661590ff
 SHA512:
-  metadata.gz: fa9ab14084eed5ba92413f0d41e913c58cf768d880c173947145ec77f901c562ad1c2076572fd301dfe2e0c0748868537a52f2fd6c178eac6b4454a08c766cfa
-  data.tar.gz: d4bd76683ac1f52b433a48a897f58093ec3bae18ad849cca0f72fcebe2c6e386d2f6754a5205e2b9c4ae936bcc6a2089d37cbd864dfd956f04ccd7c57621fa3c
+  metadata.gz: 0776f0aef2a4076a7a0bfd71c902d57400eea5388982e62583d689038137ed7fe1166368dabfb006999069e32525fd47d752faf92afffa536b9cbe72303c207f
+  data.tar.gz: c3145f170b88abebe7e2a6875d94ccca55fccb370972f37c7679479257186a5e2d73eaedb6bb799139c72bfc32ade74f60e1e5cf07aebb5aa7e3bb8621c7a65d

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gitlab_quality-test_tooling (2.16.1)
+    gitlab_quality-test_tooling (2.18.0)
       activesupport (>= 7.0, < 7.3)
       amatch (~> 0.4.1)
       fog-google (~> 1.24, >= 1.24.1)

data/exe/relate-failure-issue

@@ -58,6 +58,10 @@ options = OptionParser.new do |opts|
     params[:dry_run] = true
   end
 
+  opts.on("--group-similar", "Enable grouping similar issues") do
+    params[:group_similar] = true
+  end
+
   opts.on_tail('-v', '--version', 'Show the version') do
     require_relative "../lib/gitlab_quality/test_tooling/version"
     puts "#{$PROGRAM_NAME} : #{GitlabQuality::TestTooling::VERSION}"
@@ -66,6 +70,7 @@ options = OptionParser.new do |opts|
 
   opts.on_tail('-h', '--help', 'Show the usage') do
     puts "Purpose: Relate test failures to failure issues from RSpec report files (JSON or JUnit XML)"
+    puts ""
     puts opts
     exit
   end

data/lib/gitlab_quality/test_tooling/gitlab_client/issues_dry_client.rb

@@ -4,7 +4,7 @@ module GitlabQuality
   module TestTooling
     module GitlabClient
       class IssuesDryClient < IssuesClient
-        def create_issue(title:, description:, labels:, issue_type: 'issue', _assignee_id: nil, _due_date: nil, confidential: false)
+        def create_issue(title:, description:, labels:, issue_type: 'issue', confidential: false)
           attrs = { description: description, labels: labels, confidential: confidential }
 
           puts "The following #{issue_type} would have been created:"

data/lib/gitlab_quality/test_tooling/report/group_issues/error_message_normalizer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'openssl'
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      module GroupIssues
+        class ErrorMessageNormalizer
+          NORMALIZATION_PATTERNS = [
+            { pattern: /\d{4}-\d{2}-\d{2}T?[ ]?\d{2}:\d{2}:\d{2}(\.\d+)?Z?/, replacement: "<TIMESTAMP>" },
+            { pattern: /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i, replacement: "<UUID>" },
+            { pattern: /Correlation Id: [\w]+/, replacement: "Correlation Id: <UUID>" },
+            { pattern: /Fabrication of QA::Resource::[A-Za-z:]+/, replacement: "Fabrication of QA::Resource::<RESOURCE>" },
+            { pattern: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(:\d+)?\b/, replacement: "<IP>" },
+            { pattern: /user\d+/, replacement: "<USER>" },
+            { pattern: /group\d+/, replacement: "<GROUP>" },
+            { pattern: /project\d+/, replacement: "<PROJECT>" },
+            { pattern: %r{https?://[^/\s]+/[^\s]*}, replacement: "<URL>" },
+            { pattern: %r{/tmp/[^\s]+}, replacement: "<TMPFILE>" },
+            { pattern: %r{/var/[^\s]+}, replacement: "<VARFILE>" },
+            { pattern: /token=[^\s&]+/, replacement: "token=<TOKEN>" },
+            { pattern: /after \d+ seconds/, replacement: "after <N> seconds" },
+            { pattern: /waited \d+ seconds/, replacement: "waited <N> seconds" },
+            { pattern: /\d+ attempts?/, replacement: "<N> attempts" },
+            { pattern: /\s+/, replacement: " " }
+          ].freeze
+
+          def normalize(message)
+            return "" if message.nil? || message.empty?
+
+            result = message.dup.strip
+
+            NORMALIZATION_PATTERNS.each do |pattern_rule|
+              result.gsub!(pattern_rule[:pattern], pattern_rule[:replacement])
+            end
+
+            result.strip
+          end
+
+          def create_fingerprint(normalized_message)
+            OpenSSL::Digest::SHA256.hexdigest(normalized_message.downcase)[0..15]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/report/group_issues/error_pattern_matcher.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      module GroupIssues
+        class ErrorPatternMatcher
+          ENVIRONMENT_ERROR_PATTERNS = [
+            { name: "http_500_api_fabrication", pattern: /Fabrication of .+ using the API failed \(500\)/i },
+            { name: "http_500_internal_server", pattern: /(500 Internal Server Error|request returned \(500\)|Expected \(200\), request returned \(500\))/i },
+            { name: "http_400_backend_failing", pattern: /failed \(400\) with.+connections to all backends failing/i },
+            { name: "http_503_service_unavailable", pattern: /Unexpected status code 503/i },
+            { name: "pipeline_creation_timeout", pattern: /Wait for pipeline to be created failed after \d+ seconds/i },
+            { name: "event_timeout", pattern: /(Timed out waiting for event|EventNotFoundError: Timed out waiting)/i },
+            { name: "git_rpc_failure", pattern: /error: RPC failed; HTTP 500/i },
+            { name: "repository_fabricate_error", pattern: /Repository fabricate/i }
+          ].freeze
+
+          def match(error_message)
+            return nil if error_message.nil? || error_message.empty?
+
+            ENVIRONMENT_ERROR_PATTERNS.find { |pattern_def| error_message.match?(pattern_def[:pattern]) }
+          end
+
+          def environment_error?(error_message)
+            !match(error_message).nil?
+          end
+
+          def pattern_name(error_message)
+            match(error_message)&.dig(:name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/report/group_issues/failure_processor.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      module GroupIssues
+        class FailureProcessor
+          DEFAULT_MIN_FAILURES = 2
+
+          def initialize(options = {})
+            @options = options
+            @pattern_matcher = options[:pattern_matcher] || ErrorPatternMatcher.new
+            @normalizer = options[:normalizer] || ErrorMessageNormalizer.new
+            @config = options[:config] || {}
+          end
+
+          def process_failures(failures, &)
+            Runtime::Logger.info "Processing #{failures.size} failures for grouping..."
+            grouped_failures = {}
+
+            failures.each do |failure|
+              process_single_failure(failure, grouped_failures)
+            end
+
+            Runtime::Logger.info "Found #{grouped_failures.size} groups before filtering"
+            grouped_failures.each_value(&)
+          end
+
+          def filter_groups_by_threshold(grouped_failures)
+            min_failures = @config.dig(:thresholds, :min_failures_to_group) || DEFAULT_MIN_FAILURES
+
+            grouped_failures.select! do |_fingerprint, grouped_failure|
+              grouped_failure[:failures].size >= min_failures
+            end
+
+            Runtime::Logger.info "Found #{grouped_failures.size} groups after filtering"
+          end
+
+          private
+
+          def process_single_failure(failure, grouped_failures)
+            error_message = failure.dig(:exception, 'message') || failure.dig(:exceptions, 0, 'message')
+            Runtime::Logger.info "Processing failure: #{failure[:description]}"
+            Runtime::Logger.info "Error message: #{error_message[0..100]}..." if error_message
+
+            return unless error_message && @pattern_matcher.environment_error?(error_message)
+
+            Runtime::Logger.info "Identified as environment error"
+            group_environment_failure(failure, error_message, grouped_failures)
+          end
+
+          def group_environment_failure(failure, error_message, grouped_failures)
+            normalized_message = @normalizer.normalize(error_message)
+            fingerprint = @normalizer.create_fingerprint(normalized_message)
+            pattern_name = @pattern_matcher.pattern_name(error_message)
+
+            grouped_failures[fingerprint] ||= build_grouped_failure(fingerprint, pattern_name, normalized_message)
+            grouped_failures[fingerprint][:failures] << failure
+          end
+
+          def build_grouped_failure(fingerprint, pattern_name, normalized_message)
+            {
+              fingerprint: fingerprint,
+              pattern_name: pattern_name,
+              normalized_message: normalized_message,
+              failures: []
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/report/group_issues/group_results_in_issues.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'gitlab'
+require 'time'
+require_relative 'error_pattern_matcher'
+require_relative 'error_message_normalizer'
+require_relative 'incident_checker'
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      module GroupIssues
+        class GroupResultsInIssues
+          attr_reader :grouped_failures
+
+          def initialize(options = {})
+            @options = options
+            @failure_processor = FailureProcessor.new(options)
+            @issue_manager = IssueManager.new(options)
+            @grouped_failures = {}
+          end
+
+          def process_failures(failures)
+            @failure_processor.process_failures(failures) do |grouped_failure|
+              fingerprint = grouped_failure[:fingerprint]
+              @grouped_failures[fingerprint] = grouped_failure
+            end
+
+            @failure_processor.filter_groups_by_threshold(@grouped_failures)
+          end
+
+          def process_issues
+            @grouped_failures.each_value do |grouped_failure|
+              @issue_manager.create_or_update_issue(grouped_failure)
+            end
+          end
+
+          def summary
+            {
+              grouped_issues: @grouped_failures.size,
+              total_grouped_failures: @grouped_failures.values.sum { |group| group[:failures].size }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/report/group_issues/incident_checker.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'gitlab'
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      module GroupIssues
+        class IncidentChecker
+          GITLAB_PRODUCTION_PROJECT_ID = '7444821' # gitlab-com/gl-infra/production
+
+          def self.get_active_incidents(token: nil, gitlab_url: 'https://gitlab.com')
+            return [] unless token
+
+            begin
+              client = GitlabClient::IssuesClient.new(token: token, endpoint: "#{gitlab_url}/api/v4", project: GITLAB_PRODUCTION_PROJECT_ID)
+
+              issues = client.find_issues(options: {
+                labels: 'Incident::Active',
+                state: 'opened',
+                per_page: 10,
+                order_by: 'created_at',
+                sort: 'desc'
+              })
+
+              issues.map do |issue|
+                {
+                  title: issue.title,
+                  url: issue.web_url
+                }
+              end
+
+            rescue Gitlab::Error::Error => e
+              Runtime::Logger.error "GitLab API error fetching incidents: #{e.message}"
+              []
+            rescue StandardError => e
+              Runtime::Logger.error "Warning: Could not fetch active incidents: #{e.message}"
+              []
+            end
+          end
+
+          def self.format_incidents_for_issue(incidents)
+            return "" if incidents.empty?
+
+            incident_list = incidents.map { |inc| "- [#{inc[:title]}](#{inc[:url]})" }.join("\n")
+
+            <<~MARKDOWN
+
+        ### Related GitLab Incidents
+        The following active incidents may be related to these test failures:
+
+        #{incident_list}
+
+        Check the [GitLab Production Issues](https://gitlab.com/gitlab-com/gl-infra/production/-/issues/?label_name%5B%5D=Incident%3A%3AActive) for updates.
+            MARKDOWN
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/report/group_issues/issue_base.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      module GroupIssues
+        class IssueBase
+          def initialize(client, options = {})
+            @client = client
+            @options = options
+            @gitlab_url = ENV.fetch('CI_SERVER_URL', 'https://gitlab.com')
+            @project_id = options[:target_project] || ENV['RESULTS_ISSUE_PROJECT'] || ENV.fetch('CI_PROJECT_ID', nil)
+            @token = options[:token]
+          end
+
+          private
+
+          def handle_gitlab_api_error(operation, context = nil)
+            yield
+          rescue Gitlab::Error::Error => e
+            log_gitlab_error(operation, context, e)
+            nil
+          rescue StandardError => e
+            log_standard_error(operation, context, e)
+            nil
+          end
+
+          def log_gitlab_error(operation, context, error)
+            context_info = context ? " #{context}" : ""
+            Runtime::Logger.error "GitLab API error #{operation}#{context_info}: #{error.message}"
+          end
+
+          def log_standard_error(operation, context, error)
+            context_info = context ? " #{context}" : ""
+            Runtime::Logger.error "Error #{operation}#{context_info}: #{error.message}"
+          end
+
+          def display_description_preview(description, title = "Description preview:")
+            Runtime::Logger.info title
+            lines = description.split("\n")
+            Runtime::Logger.info lines.first(15).join("\n")
+            Runtime::Logger.info "..." if lines.length > 15
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/report/group_issues/issue_creator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      module GroupIssues
+        class IssueCreator < IssueBase
+          GROUPED_ISSUE_LABELS = Set.new(%w[test failure::test-environment automation:bot-authored type::maintenance]).freeze
+
+          def initialize(client, options = {})
+            super
+            @formatter = IssueFormatter.new
+          end
+
+          def create_new_issue(grouped_failure)
+            title = @formatter.generate_issue_title(grouped_failure)
+            description = @formatter.generate_issue_description(grouped_failure, @options)
+            labels = GROUPED_ISSUE_LABELS
+
+            Runtime::Logger.info "Creating new grouped issue: #{title} (#{grouped_failure[:failures].size} failures)"
+
+            create_issue(
+              title: title,
+              description: description,
+              labels: labels,
+              failures: grouped_failure[:failures]
+            )
+          end
+
+          private
+
+          def create_issue(title:, description:, labels:, failures:)
+            Runtime::Logger.info "Creating issue: #{title} with #{failures.size} failures"
+
+            handle_gitlab_api_error("creating issue") do
+              issue = @client.create_issue(title: title, description: description, labels: labels.join(','))
+              Runtime::Logger.info "Issue created successfully: #{issue.web_url}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/report/group_issues/issue_finder.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      module GroupIssues
+        class IssueFinder
+          DEFAULT_MAX_AGE_HOURS = 24
+          ISSUES_PER_PAGE = 50
+
+          def initialize(client, options = {})
+            @client = client
+            @options = options
+            @token = options[:token]
+            @project_id = options[:target_project] || ENV['RESULTS_ISSUE_PROJECT'] || ENV.fetch('CI_PROJECT_ID', nil)
+          end
+
+          def find_existing_issue(grouped_failure)
+            find_related_issue_by_fingerprint(
+              fingerprint: grouped_failure[:fingerprint],
+              max_age_hours: DEFAULT_MAX_AGE_HOURS
+            )
+          end
+
+          private
+
+          def find_related_issue_by_fingerprint(fingerprint:, max_age_hours:)
+            Runtime::Logger.info "Searching for existing issue with fingerprint: #{fingerprint}"
+
+            begin
+              issues = fetch_recent_open_issues(max_age_hours)
+              matching_issue = find_issue_with_fingerprint(issues, fingerprint)
+              if matching_issue
+                Runtime::Logger.info "Found existing issue: ##{matching_issue.iid} - #{matching_issue.title}"
+                convert_to_struct(matching_issue)
+              end
+            rescue Gitlab::Error::Error => e
+              Runtime::Logger.error "GitLab API error searching for issues: #{e.message}"
+              nil
+            rescue StandardError => e
+              Runtime::Logger.error "Error searching for existing issues: #{e.message}"
+              nil
+            end
+          end
+
+          def fetch_recent_open_issues(max_age_hours)
+            cutoff_time = Time.now - (max_age_hours * 3600)
+
+            @client.find_issues(options: {
+              state: 'opened',
+              created_after: cutoff_time.utc.iso8601,
+              per_page: ISSUES_PER_PAGE,
+              order_by: 'created_at',
+              sort: 'desc'
+            })
+          end
+
+          def find_issue_with_fingerprint(issues, fingerprint)
+            fingerprint_tag = "grouped-failure-fingerprint:#{fingerprint}"
+            issues.find { |issue| issue.description&.include?(fingerprint_tag) }
+          end
+
+          def convert_to_struct(obj)
+            return obj unless obj.is_a?(Hash)
+
+            struct_class = Struct.new(*obj.keys.map(&:to_sym))
+            struct = struct_class.new
+
+            obj.each do |key, value|
+              struct[key.to_sym] = value.is_a?(Hash) ? convert_to_struct(value) : value
+            end
+
+            struct
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/report/group_issues/issue_formatter.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      module GroupIssues
+        class IssueFormatter
+          def generate_issue_title(grouped_failure)
+            case grouped_failure[:pattern_name]
+            when /http_500/ then "Environment Issue: HTTP 500 Internal Server Errors"
+            when /http_400/ then "Environment Issue: Backend Connection Failures"
+            when /http_503/ then "Environment Issue: Service Unavailable (503)"
+            when /timeout/ then "Environment Issue: Timeout Failures"
+            when /git_rpc|repository/ then "Environment Issue: Repository/Git Operation Failures"
+            else "Environment Issue: Multiple Similar Failures"
+            end
+          end
+
+          def generate_issue_description(grouped_failure, options = {})
+            active_incidents = IncidentChecker.get_active_incidents(token: options[:token])
+            incident_section = IncidentChecker.format_incidents_for_issue(active_incidents)
+
+            <<~MARKDOWN
+            ## Environment Issue: #{grouped_failure[:pattern_name]}
+
+            Multiple tests have failed with similar error patterns, indicating an environment-related issue affecting multiple test cases.
+
+            ### Error Pattern
+            ```
+            #{grouped_failure[:normalized_message]}
+            ```
+
+            ### Affected Tests (#{grouped_failure[:failures].size} failures)
+            #{format_affected_tests(grouped_failure[:failures])}
+
+            ### Pipeline Information
+            #{format_pipeline_info(grouped_failure[:failures].first)}
+
+            ### Recommended Actions
+            #{generate_recommended_actions(grouped_failure)}
+
+            #{incident_section}
+            ---
+            <!-- grouped-failure-fingerprint:#{grouped_failure[:fingerprint]} -->
+            MARKDOWN
+          end
+
+          def format_affected_tests(failures)
+            failures.map do |failure|
+              job_name = failure[:ci_job_url] || failure.dig(:ci_job, :name) || 'unknown_job'
+              spec_file = failure[:file_path] || failure[:file] || 'unknown_spec'
+              line_number = failure[:line_number] || failure[:line]
+              test_name = failure[:description] || failure[:test_name] || 'Unknown test'
+
+              spec_with_line = line_number.to_s.empty? ? spec_file : "#{spec_file}:#{line_number}"
+              "- **#{test_name}** (Job: `#{job_name}`, Spec: `#{spec_with_line}`)"
+            end.join("\n")
+          end
+
+          def format_pipeline_info(failure)
+            pipeline_url = ENV['CI_PIPELINE_URL'] || "Pipeline #{ENV.fetch('CI_PIPELINE_ID', 'unknown')}"
+            job_url = failure[:ci_job_url] || 'Unknown job'
+
+            "- **Pipeline**: #{pipeline_url}\n- **Job**: #{job_url}"
+          end
+
+          def generate_recommended_actions(grouped_failure)
+            case grouped_failure[:pattern_name]
+            when /http_500/
+              "1. Check GitLab instance status and logs\n2. Verify database connectivity\n3. Review application server health"
+            when /timeout/
+              "1. Check network connectivity\n2. Review timeout configurations\n3. Monitor system resources"
+            when /git_rpc|repository/
+              "1. Verify Git repository accessibility\n2. Check Gitaly service status\n3. Review storage capacity"
+            else
+              "1. Check if there are ongoing incidents affecting the GitLab instance\n2. Verify API endpoints are responding correctly\n3. Review system logs for related errors"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/report/group_issues/issue_manager.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      module GroupIssues
+        class IssueManager
+          DEFAULT_MAX_AGE_HOURS = 24
+          ISSUES_PER_PAGE = 50
+          GROUPED_ISSUE_LABELS = Set.new(%w[test failure::test-environment automation:bot-authored type::maintenance]).freeze
+
+          def initialize(options = {})
+            @options = options
+            @client = options[:gitlab]
+            @issue_finder = IssueFinder.new(@client, @options)
+            @issue_updater = IssueUpdater.new(@client, @options)
+            @issue_creator = IssueCreator.new(@client, @options)
+          end
+
+          def create_or_update_issue(grouped_failure)
+            existing_issue = @issue_finder.find_existing_issue(grouped_failure)
+
+            if existing_issue
+              @issue_updater.update_existing_issue(existing_issue, grouped_failure)
+            else
+              @issue_creator.create_new_issue(grouped_failure)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/report/group_issues/issue_updater.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      module GroupIssues
+        class IssueUpdater < IssueBase
+          def update_existing_issue(issue, grouped_failure)
+            log_issue_update(issue, grouped_failure)
+            append_failures_to_issue(issue, grouped_failure[:failures])
+            add_update_comment(issue, grouped_failure[:failures].size)
+          end
+
+          private
+
+          def append_failures_to_issue(issue, failures)
+            current_issue = @client.find_issues(iid: issue.iid).first
+            return unless current_issue
+
+            existing_description = current_issue.description
+            affected_tests_match = existing_description.match(/### Affected Tests \((\d+) failures?\)/)
+            return unless affected_tests_match
+
+            updated_description = build_updated_description(existing_description, affected_tests_match, failures)
+            update_issue_description(issue, updated_description, failures.size)
+          end
+
+          def update_issue_description(issue, updated_description, failure_count)
+            handle_gitlab_api_error("updating issue", "##{issue.web_url}") do
+              @client.edit_issue(iid: issue.iid, options: { description: updated_description })
+              Runtime::Logger.info "Successfully appended #{failure_count} failures to issue #{issue.web_url}"
+              true
+            end
+          end
+
+          def build_updated_description(existing_description, affected_tests_match, failures)
+            current_count = affected_tests_match[1].to_i
+            new_count = current_count + failures.size
+
+            updated_description = existing_description.gsub(
+              /### Affected Tests \(\d+ failures?\)/,
+              "### Affected Tests (#{new_count} failures)"
+            )
+            insert_new_failures(updated_description, failures)
+          end
+
+          def insert_new_failures(description, failures)
+            formatter = IssueFormatter.new
+            new_failure_entries = formatter.format_affected_tests(failures)
+
+            test_section_end = description.index('### Pipeline Information')
+            return description unless test_section_end
+
+            insertion_point = description.rindex("\n", test_section_end - 1)
+            return description unless insertion_point
+
+            "#{description[0..insertion_point]}#{new_failure_entries}\n#{description[insertion_point + 1..]}"
+          end
+
+          def add_update_comment(issue, failure_count)
+            pipeline_url = ENV['CI_PIPELINE_URL'] || "Pipeline #{ENV.fetch('CI_PIPELINE_ID', nil)}"
+            comment = build_update_comment(pipeline_url, failure_count)
+            add_comment_to_issue(issue, comment)
+          end
+
+          def build_update_comment(pipeline_url, failure_count)
+            "🔄 **New failures added from #{pipeline_url}**\n\n" \
+              "Added #{failure_count} additional test failures with the same error pattern."
+          end
+
+          def add_comment_to_issue(issue, comment)
+            handle_gitlab_api_error("adding comment to issue", issue.web_url) do
+              @client.create_issue_note(iid: issue.iid, note: comment)
+              Runtime::Logger.info "Comment added successfully to issue #{issue.web_url}"
+              true
+            end
+          end
+
+          def log_issue_update(issue, grouped_failure)
+            pipeline_id = ENV.fetch('CI_PIPELINE_ID', nil)
+            Runtime::Logger.info "Updating existing issue ##{issue.iid} with #{grouped_failure[:failures].size} new failures from pipeline #{pipeline_id}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/report/relate_failure_issue.rb

@@ -3,6 +3,10 @@
 require 'nokogiri'
 require 'rubygems/text'
 
+require_relative 'group_issues/error_pattern_matcher'
+require_relative 'group_issues/error_message_normalizer'
+require_relative 'group_issues/group_results_in_issues'
+
 module GitlabQuality
   module TestTooling
     module Report
@@ -12,6 +16,7 @@ module GitlabQuality
       # - Takes a project where failure issues should be created
       # - Find issue by title (with test description or test file), then further filter by stack trace, then pick the better-matching one
       # - Add the failed job to the issue description, and update labels
+      # - Can group similar failures together when group_similar option is enabled
       class RelateFailureIssue < ReportAsIssue
         include TestTooling::Concerns::FindSetDri
         include Concerns::GroupAndCategoryLabels
@@ -63,6 +68,7 @@ module GitlabQuality
           base_issue_labels: nil,
           exclude_labels_for_search: nil,
           metrics_files: [],
+          group_similar: false,
           **kwargs)
           super
           @max_diff_ratio = max_diff_ratio.to_f
@@ -72,19 +78,106 @@ module GitlabQuality
           @issue_type = 'issue'
           @commented_issue_list = Set.new
           @metrics_files = Array(metrics_files)
+          @group_similar = group_similar
         end
 
         private
 
-        attr_reader :max_diff_ratio, :system_logs, :base_issue_labels, :exclude_labels_for_search, :metrics_files, :ops_gitlab_client
+        attr_reader :max_diff_ratio, :system_logs, :base_issue_labels, :exclude_labels_for_search, :metrics_files, :ops_gitlab_client, :group_similar
 
         def run!
           puts "Reporting test failures in `#{files.join(',')}` as issues in project `#{project}` via the API at `#{Runtime::Env.gitlab_api_base}`."
 
+          if group_similar
+            run_with_grouping!
+          else
+            TestResults::Builder.new(token: token, project: project, file_glob: files).test_results_per_file do |test_results|
+              puts "=> Reporting #{test_results.count} tests in #{test_results.path}"
+              process_test_results(test_results)
+            end
+          end
+        end
+
+        def grouper
+          @grouper ||= GitlabQuality::TestTooling::Report::GroupIssues::GroupResultsInIssues.new(
+            gitlab: gitlab,
+            config: grouper_config
+          )
+        end
+
+        def run_with_grouping!
+          Runtime::Logger.info "=> Grouping similar failures where possible"
+
+          all_test_results = collect_all_test_results
+          return if all_test_results.empty?
+
+          Runtime::Logger.info "=> Processing #{all_test_results.count} failures with GroupResultsInIssues"
+
+          failure_data = convert_test_results_to_failure_data(all_test_results)
+
+          grouper.process_failures(failure_data)
+          grouper.process_issues
+        end
+
+        def collect_all_test_results
+          all_test_results = []
+
           TestResults::Builder.new(token: token, project: project, file_glob: files).test_results_per_file do |test_results|
-            puts "=> Reporting #{test_results.count} tests in #{test_results.path}"
-            process_test_results(test_results)
+            Runtime::Logger.info "=> Collecting #{test_results.count} tests from #{test_results.path}"
+            all_test_results.concat(test_results.select(&:failures?))
           end
+
+          all_test_results
+        end
+
+        def convert_test_results_to_failure_data(test_results)
+          test_results.map do |test|
+            {
+              description: test.name,
+              full_description: test.name,
+              file_path: test.relative_file,
+              line_number: extract_line_number(test),
+              exception: extract_exception_data(test),
+              ci_job_url: test.ci_job_url,
+              testcase: extract_test_id_or_name(test),
+              product_group: extract_product_group(test),
+              level: extract_level(test)
+            }
+          end
+        end
+
+        def extract_line_number(test)
+          test.respond_to?(:line_number) ? test.line_number : nil
+        end
+
+        def extract_exception_data(test)
+          {
+            'message' => test.failures.first&.dig('message') || test.full_stacktrace || 'Unknown error'
+          }
+        end
+
+        def extract_product_group(test)
+          test.respond_to?(:product_group) ? test.product_group : nil
+        end
+
+        def extract_level(test)
+          test.respond_to?(:level) ? test.level : nil
+        end
+
+        def grouper_config
+          {
+            thresholds: {
+              min_failures_to_group: 2
+            }
+          }
+        end
+
+        def extract_test_id_or_name(test)
+          return test.example_id if test.respond_to?(:example_id)
+          return test.id if test.respond_to?(:id)
+          return test.name if test.respond_to?(:name)
+
+          "#{test.relative_file}:#{test.respond_to?(:line_number) ? test.line_number : 'unknown'}"
         end
 
         def new_issue_labels(test)
@@ -469,10 +562,40 @@ module GitlabQuality
         end
 
         def new_issue_assignee_id(test)
-          return unless test.product_group?
+          assignee_id = try_feature_category_assignment(test)
+          return assignee_id if assignee_id
+
+          try_product_group_assignment(test)
+        end
+
+        def try_feature_category_assignment(test)
+          unless test.respond_to?(:feature_category) && test.feature_category?
+            Runtime::Logger.info("No feature_category found for DRI assignment")
+            return
+          end
+
+          labels_inference = GitlabQuality::TestTooling::LabelsInference.new
+          product_group = labels_inference.product_group_from_feature_category(test.feature_category)
+
+          unless product_group
+            Runtime::Logger.warn("Could not map feature_category '#{test.feature_category}' to product_group")
+            return
+          end
+
+          dri = test_dri(product_group, test.stage, test.section)
+          Runtime::Logger.info("Assigning #{dri} as DRI for the issue (via feature_category).")
+
+          gitlab.find_user_id(username: dri)
+        end
+
+        def try_product_group_assignment(test)
+          unless test.respond_to?(:product_group) && test.product_group?
+            Runtime::Logger.info("No product_group found for DRI assignment")
+            return
+          end
 
           dri = test_dri(test.product_group, test.stage, test.section)
-          puts "  => Assigning #{dri} as DRI for the issue."
+          Runtime::Logger.info("Assigning #{dri} as DRI for the issue (via product_group).")
 
           gitlab.find_user_id(username: dri)
         end

data/lib/gitlab_quality/test_tooling/test_meta/test_meta_updater.rb

@@ -8,7 +8,7 @@ module GitlabQuality
       class TestMetaUpdater
         include TestTooling::Concerns::FindSetDri
 
-        attr_reader :project, :ref, :report_issue, :processed_commits
+        attr_reader :project, :ref, :report_issue, :processed_commits, :token, :specs_file, :dry_run, :processor
 
         TEST_PLATFORM_MAINTAINERS_SLACK_CHANNEL_ID = 'C0437FV9KBN' # test-platform-maintainers
 
@@ -269,12 +269,15 @@ module GitlabQuality
         # Fetch the id for the dri of the product group and stage
         # The first item returned is the id of the assignee and the second item is the handle
         #
-        # @param [String] product_group
+        # @param [Hash] test object
         # @param [String] devops_stage
+        # @param [String] section
         # @return [Array<Integer, String>]
-        def fetch_dri_id(product_group, devops_stage, section)
-          assignee_handle = ENV.fetch('QA_TEST_DRI_HANDLE', nil) || test_dri(product_group, devops_stage, section)
+        def fetch_dri_id(test, devops_stage, section)
+          product_group = determine_product_group(test)
+          return unless product_group
 
+          assignee_handle = ENV.fetch('QA_TEST_DRI_HANDLE', nil) || test_dri(product_group, devops_stage, section)
           [user_id_for_username(assignee_handle), assignee_handle]
         end
 
@@ -335,6 +338,16 @@ module GitlabQuality
           label ? %(/label ~"#{label}") : ''
         end
 
+        # Infers the group label from the provided feature category
+        #
+        # @param [String] feature_category feature category
+        # @return [String]
+        def label_from_feature_category(feature_category)
+          labels = labels_inference.infer_labels_from_feature_category(feature_category)
+          group_label = labels.find { |label| label.start_with?('group::') }
+          group_label ? %(/label ~"#{group_label}") : ''
+        end
+
         # Returns the link to the Grafana dashboard for single spec metrics
         #
         # @param [String] example_name the full example name
@@ -344,10 +357,6 @@ module GitlabQuality
           base_url + CGI.escape(example_name)
         end
 
-        private
-
-        attr_reader :token, :specs_file, :dry_run, :processor
-
         # Returns any test description string within single or double quotes
         #
         # @param [String] line the line to check for any quoted string
@@ -380,6 +389,27 @@ module GitlabQuality
         def labels_inference
           @labels_inference ||= GitlabQuality::TestTooling::LabelsInference.new
         end
+
+        private
+
+        def determine_product_group(test)
+          return map_feature_category_to_product_group(test) if has_feature_category?(test)
+          return test.product_group if has_product_group?(test)
+
+          nil
+        end
+
+        def has_feature_category?(test)
+          test.respond_to?(:feature_category) && test.feature_category?
+        end
+
+        def has_product_group?(test)
+          test.respond_to?(:product_group) && test.product_group?
+        end
+
+        def map_feature_category_to_product_group(test)
+          labels_inference.product_group_from_feature_category(test.feature_category)
+        end
       end
     end
   end

data/lib/gitlab_quality/test_tooling/test_result/base_test_result.rb

@@ -73,6 +73,10 @@ module GitlabQuality
           product_group != ''
         end
 
+        def feature_category?
+          feature_category && !feature_category.empty?
+        end
+
         def failure_issue
           report['failure_issue']
         end

data/lib/gitlab_quality/test_tooling/version.rb

@@ -2,6 +2,6 @@
 
 module GitlabQuality
   module TestTooling
-    VERSION = "2.16.1"
+    VERSION = "2.18.0"
   end
 end

data/lib/gitlab_quality/test_tooling.rb

@@ -7,6 +7,8 @@ module GitlabQuality
   module TestTooling
     Error = Class.new(StandardError)
     loader = Zeitwerk::Loader.new
+    loader.push_dir(__dir__.to_s, namespace: GitlabQuality)
+    loader.ignore("#{__dir__}/test_tooling.rb")
     loader.push_dir("#{__dir__}/test_tooling", namespace: GitlabQuality::TestTooling)
     loader.ignore("#{__dir__}/test_tooling/version.rb")
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab_quality-test_tooling
 version: !ruby/object:Gem::Version
-  version: 2.16.1
+  version: 2.18.0
 platform: ruby
 authors:
 - GitLab Quality
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-24 00:00:00.000000000 Z
+date: 2025-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: climate_control
@@ -522,6 +522,17 @@ files:
 - lib/gitlab_quality/test_tooling/report/feature_readiness/report_on_epic.rb
 - lib/gitlab_quality/test_tooling/report/flaky_test_issue.rb
 - lib/gitlab_quality/test_tooling/report/generate_test_session.rb
+- lib/gitlab_quality/test_tooling/report/group_issues/error_message_normalizer.rb
+- lib/gitlab_quality/test_tooling/report/group_issues/error_pattern_matcher.rb
+- lib/gitlab_quality/test_tooling/report/group_issues/failure_processor.rb
+- lib/gitlab_quality/test_tooling/report/group_issues/group_results_in_issues.rb
+- lib/gitlab_quality/test_tooling/report/group_issues/incident_checker.rb
+- lib/gitlab_quality/test_tooling/report/group_issues/issue_base.rb
+- lib/gitlab_quality/test_tooling/report/group_issues/issue_creator.rb
+- lib/gitlab_quality/test_tooling/report/group_issues/issue_finder.rb
+- lib/gitlab_quality/test_tooling/report/group_issues/issue_formatter.rb
+- lib/gitlab_quality/test_tooling/report/group_issues/issue_manager.rb
+- lib/gitlab_quality/test_tooling/report/group_issues/issue_updater.rb
 - lib/gitlab_quality/test_tooling/report/health_problem_reporter.rb
 - lib/gitlab_quality/test_tooling/report/issue_logger.rb
 - lib/gitlab_quality/test_tooling/report/knapsack_report_issue.rb