gitlab_quality-test_tooling 2.16.0 → 2.25.1

data/lib/gitlab_quality/test_tooling/code_coverage/test_map.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module GitlabQuality
+  module TestTooling
+    module CodeCoverage
+      class TestMap
+        SEPARATOR = '/'
+        MARKER = 1
+
+        # @param [Hash] compact_map A nested hash structure where keys are
+        #   source files and values are tree structures with test file paths
+        # @example Example of compact_map for a file tested by 3 spec files
+        #   {
+        #     "app/models/user.rb" => {
+        #       "spec" => {
+        #         "models" => {
+        #           "user_spec.rb" => 1  # MARKER (1) indicates a leaf node
+        #         }
+        #       },
+        #       "ee" => {
+        #         "spec" => {
+        #           "lib" => {
+        #              "ee" => {
+        #                "gitlab" => {
+        #                  "background_migration" => {
+        #                    "delete_invalid_epic_issues_spec.rb"=>1,
+        #                    "backfill_security_policies_spec.rb"=>1
+        #                  }
+        #                }
+        #              }
+        #           }
+        #         }
+        #       }
+        #     }
+        #   }
+        def initialize(compact_map)
+          @compact_map = compact_map
+        end
+
+        # @return [Hash<String, Array<String>>] Source files mapped to all test
+        #   files testing them
+        # @example Return value
+        #   {
+        #     "path/to/file1.rb" => [
+        #       "spec/path/to/file1_spec.rb",
+        #       "spec/path/to/another/file1_spec.rb"
+        #     ],
+        #     ...
+        #   }
+        def source_to_tests
+          @source_to_tests ||= @compact_map.transform_values { |tree| traverse(tree).to_a.uniq }
+        end
+
+        # @return [Hash<String, Array<String>>] Test files mapped to all source
+        #   files tested by them
+        # @example Return value
+        #   {
+        #     "spec/path/to/file1_spec.rb" => [
+        #       "path/to/file1.rb",
+        #       "path/to/file2.rb"
+        #     ],
+        #     ...
+        #   }
+        def test_to_sources
+          @test_to_sources ||= begin
+            test_to_sources = Hash.new { |hash, key| hash[key] = [] }
+
+            @compact_map.each do |source_file, tree|
+              traverse(tree).to_a.each do |test_file|
+                test_to_sources[test_file] << source_file
+              end
+            end
+
+            test_to_sources
+          end
+        end
+
+        private
+
+        def traverse(tree, segments = [], &block)
+          return to_enum(__method__, tree, segments) unless block
+          return yield segments.join(SEPARATOR) if tree == MARKER && !segments.empty?
+
+          tree.each do |key, value|
+            traverse(value, segments + [key], &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/code_coverage/utils.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'yaml'
+
+module GitlabQuality
+  module TestTooling
+    module CodeCoverage
+      module Utils
+        def exponential_delay_with_jitter(attempt)
+          exponential_delay = (2**(attempt - 1))
+          jitter = rand # 0-1 seconds
+          exponential_delay + jitter
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/feature_readiness/concerns/issue_concern.rb

@@ -21,7 +21,7 @@ module GitlabQuality
           end
 
           def has_operational_readiness_issue_linked?(linked_issue_iids, issue_client)
-            linked_issues(linked_issue_iids, issue_client).any? { |issue| (issue.labels & [OPERATIONAL_READINESS_CHECKLIST_LABEL]).any? }
+            linked_issues(linked_issue_iids, issue_client).any? { |issue| issue.labels.intersect?([OPERATIONAL_READINESS_CHECKLIST_LABEL]) }
           end
 
           def linked_issues(linked_issue_iids, issue_client)

data/lib/gitlab_quality/test_tooling/feature_readiness/concerns/work_item_concern.rb

@@ -118,6 +118,17 @@ module GitlabQuality
             labels.first.id
           end
 
+          def ids_for_group_labels(labels, group_labels_client)
+            labels.filter_map { |label| get_id_for_group_label(label, group_labels_client) }
+          end
+
+          def get_id_for_group_label(label_name, group_labels_client)
+            labels = group_labels_client.group_labels(options: { search: label_name })
+            return nil if labels.empty?
+
+            labels.first.id
+          end
+
           def extract_id_from_gid(gid)
             gid.to_s.split('/').last.to_i
           end

data/lib/gitlab_quality/test_tooling/feature_readiness/epic_readiness_notifier.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module GitlabQuality
+  module TestTooling
+    module FeatureReadiness
+      class EpicReadinessNotifier
+        include Concerns::WorkItemConcern
+
+        FEATURE_READINESS_NOTIFICATION_ID = '<!-- FEATURE READINESS NOTIFICATION -->'
+        FEATURE_READINESS_CANDIDATE_LABEL = 'feature readiness candidate'
+
+        def initialize(token:, epic_urls: nil, epic_urls_file: nil, message: nil, dry_run: false)
+          @token = token
+          @epic_urls = epic_urls
+          @epic_urls_file = epic_urls_file
+          @custom_message = message
+          @dry_run = dry_run
+          @results = []
+        end
+
+        def invoke!
+          urls = collect_epic_urls
+          print_header(urls.size)
+          process_all_urls(urls)
+          print_summary
+        end
+
+        private
+
+        attr_reader :token, :epic_urls, :epic_urls_file, :custom_message, :dry_run, :results
+
+        def print_header(url_count)
+          puts "Processing #{url_count} epic URL(s)..."
+          puts "Dry run mode: #{dry_run ? 'enabled' : 'disabled'}"
+          puts
+        end
+
+        def process_all_urls(urls)
+          urls.each_with_index do |url, index|
+            puts "[#{index + 1}/#{urls.size}] Processing: #{url}"
+            process_single_url(url)
+            puts
+          end
+        end
+
+        def process_single_url(url)
+          result = process_epic_url(url)
+          @results << result
+          print_result(result)
+        rescue StandardError => e
+          error_result = { url: url, success: false, error: e.message }
+          @results << error_result
+          puts "  ❌ Error: #{e.message}"
+        end
+
+        def print_result(result)
+          if result[:success]
+            author_info = result[:author] ? (result[:author]).to_s : "epic (no author assigned)"
+            puts "  ✅ Successfully notified #{author_info} and added label '#{FEATURE_READINESS_CANDIDATE_LABEL}' to epic: #{result[:title]}"
+          else
+            puts "  ❌ Failed: #{result[:error]}"
+          end
+        end
+
+        def collect_epic_urls
+          urls = []
+          urls.concat(epic_urls) if epic_urls
+          urls.concat(collect_urls_from_file) if epic_urls_file
+          validate_urls_present(urls)
+          urls.uniq
+        end
+
+        def collect_urls_from_file
+          validate_file_exists
+          File.readlines(epic_urls_file, chomp: true)
+              .map(&:strip)
+              .reject(&:empty?)
+              .reject { |line| line.start_with?('#') }
+        end
+
+        def validate_file_exists
+          return if File.exist?(epic_urls_file)
+
+          raise ArgumentError, "Epic URLs file not found: #{epic_urls_file}"
+        end
+
+        def validate_urls_present(urls)
+          return unless urls.empty?
+
+          raise ArgumentError, "No epic URLs provided"
+        end
+
+        def process_epic_url(url)
+          epic_info = parse_epic_url(url)
+          client = work_items_client_for_group(epic_info[:group])
+          epic = fetch_and_validate_epic(epic_info, client, url)
+
+          return epic if epic.key?(:error)
+
+          existing_note = existing_note_containing_text(FEATURE_READINESS_NOTIFICATION_ID, epic_info[:epic_iid], client)
+          return build_existing_notification_result(url, epic) if existing_note
+
+          post_notification_and_label(epic, epic_info, client) unless dry_run
+          build_success_result(url, epic, epic_info)
+        end
+
+        def fetch_and_validate_epic(epic_info, client, url)
+          epic = fetch_work_item(epic_info[:epic_iid], client, [:notes])
+          return { url: url, success: false, error: "Epic not found or not accessible" } unless epic
+          return { url: url, success: false, error: "Work item is not an epic (type: #{epic[:workItemType][:name]})" } unless epic[:workItemType][:name] == "Epic"
+
+          epic
+        end
+
+        def build_existing_notification_result(url, epic)
+          {
+            url: url,
+            success: false,
+            error: "Notification already exists",
+            title: epic[:title],
+            author: epic[:author] ? epic[:author][:username] : nil
+          }
+        end
+
+        def post_notification_and_label(epic, epic_info, client)
+          message = build_notification_message(epic)
+
+          # Create the discussion/comment
+          client.post(
+            <<~GQL
+              mutation CreateDiscussion {
+                  createDiscussion(input: {noteableId: "#{epic[:id]}", body: #{message.inspect}}) {
+                      clientMutationId
+                      errors
+                      note {
+                          id
+                          body
+                      }
+                  }
+              }
+            GQL
+          )
+
+          # Apply group label if it exists
+          apply_group_label_if_exists(epic, epic_info, client)
+        end
+
+        def build_success_result(url, epic, epic_info)
+          {
+            url: url,
+            success: true,
+            title: epic[:title],
+            author: epic[:author] ? epic[:author][:username] : nil,
+            group: epic_info[:group],
+            epic_iid: epic_info[:epic_iid]
+          }
+        end
+
+        def parse_epic_url(url)
+          uri = URI.parse(url)
+          path_parts = uri.path.split('/')
+          groups_index, epics_index = find_url_indices(path_parts, url)
+          group_path, epic_iid = extract_group_and_epic_id(path_parts, groups_index, epics_index, url)
+
+          {
+            host: "#{uri.scheme}://#{uri.host}",
+            group: group_path,
+            epic_iid: epic_iid,
+            url: url
+          }
+        end
+
+        def find_url_indices(path_parts, url)
+          groups_index = path_parts.index('groups')
+          epics_index = path_parts.index('epics')
+
+          raise ArgumentError, "Invalid epic URL format: #{url}" unless groups_index && epics_index && epics_index > groups_index
+
+          [groups_index, epics_index]
+        end
+
+        def extract_group_and_epic_id(path_parts, groups_index, epics_index, url)
+          group_parts = path_parts[(groups_index + 1)...(epics_index - 1)]
+          group_path = group_parts.join('/')
+          epic_iid = path_parts[epics_index + 1]
+
+          validate_extracted_parts(group_path, epic_iid, url)
+          [group_path, epic_iid]
+        end
+
+        def validate_extracted_parts(group_path, epic_iid, url)
+          return if group_path && epic_iid&.match?(/^\d+$/)
+
+          raise ArgumentError, "Could not extract group and epic IID from URL: #{url}"
+        end
+
+        def work_items_client_for_group(group)
+          client_class = dry_run ? GitlabClient::WorkItemsDryClient : GitlabClient::WorkItemsClient
+          client_class.new(token: token, project: nil, group: group)
+        end
+
+        def group_labels_client_for_group(group)
+          GitlabClient::GroupLabelsClient.new(token: token, group: group)
+        end
+
+        def apply_group_label_if_exists(epic, epic_info, client)
+          group_labels_client = group_labels_client_for_group(epic_info[:group])
+          label_ids = ids_for_group_labels([FEATURE_READINESS_CANDIDATE_LABEL], group_labels_client)
+
+          if label_ids.empty?
+            puts "Warning: Group label '#{FEATURE_READINESS_CANDIDATE_LABEL}' not found in group #{epic_info[:group]}. Skipping label application."
+            return
+          end
+
+          puts "Applying group label '#{FEATURE_READINESS_CANDIDATE_LABEL}' to epic..." unless dry_run
+          add_labels(label_ids, epic[:id], client) unless dry_run
+        rescue StandardError => e
+          puts "Warning: Could not apply group label '#{FEATURE_READINESS_CANDIDATE_LABEL}': #{e.message}"
+        end
+
+        def build_notification_message(epic)
+          author_mention = build_author_mention(epic)
+
+          message = custom_message || default_message_template
+
+          # Replace placeholders in the message
+          message = message.gsub('{author}', author_mention)
+                          .gsub('{epic_title}', epic[:title])
+                          .gsub('{epic_url}', epic[:webUrl])
+
+          # Add the notification ID for tracking
+          "#{FEATURE_READINESS_NOTIFICATION_ID}\n#{message}"
+        end
+
+        def build_author_mention(epic)
+          return '' unless epic[:author] && epic[:author][:username]
+
+          "@#{epic[:author][:username]}"
+        end
+
+        def default_message_template
+          <<~MESSAGE
+            ### Platform Readiness Enablement Process (PREP) Potentially Required
+
+            {author} The feature **"{epic_title}"** has been selected as a potential candidate for Platform Readiness Enablement Process.
+
+            ### What is PREP?
+            The **Platform Readiness Enablement Process** (PREP) is a comprehensive process
+            that guides product teams through evaluating GitLab features for readiness
+            across GitLab.com, GitLab Dedicated, and GitLab Self-Managed deployment platforms.
+
+            Please note that a completed and approved PREP is **mandatory** for qualified features to reach GA status.
+
+            ## Next Steps:
+             1. Review the [handbook](https://internal.gitlab.com/handbook/product/platforms/feature-readiness-assessment/#when-prep-is-required) to confirm if you feature qualifies for PREP.
+             2. If it does, start the assessment by following the guidelines in the [documentation](https://gitlab.com/gitlab-org/architecture/readiness).
+             3. Reach out to the Feature Readiness team on Slack at `#g_feature_readiness` if you have questions.
+
+            Please react with ✅ if this classification is relevant or ❌ if not relevant to help improve our system.
+
+          MESSAGE
+        end
+
+        def print_summary
+          successful, failed = calculate_summary_counts
+          print_summary_header
+          print_summary_stats(successful, failed)
+          print_failed_urls(failed) if failed.positive?
+          print_completion_message
+        end
+
+        def calculate_summary_counts
+          successful = results.count { |r| r[:success] }
+          failed = results.count { |r| !r[:success] }
+          [successful, failed]
+        end
+
+        def print_summary_header
+          puts "=" * 50
+          puts "SUMMARY"
+          puts "=" * 50
+        end
+
+        def print_summary_stats(successful, failed)
+          puts "Total processed: #{results.size}"
+          puts "Successful: #{successful}"
+          puts "Failed: #{failed}"
+        end
+
+        def print_failed_urls(_failed)
+          puts
+          puts "Failed URLs:"
+          results.select { |r| !r[:success] }.each do |result|
+            puts "  - #{result[:url]}: #{result[:error]}"
+          end
+        end
+
+        def print_completion_message
+          puts
+          message = dry_run ? "Dry run completed - no notifications were sent or labels added." : "Notification process completed."
+          puts message
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/gcs_tools.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'fog/google'
+
+module GitlabQuality
+  module TestTooling
+    module GcsTools
+      class GCSMockClient
+        def initialize(*_args, **_kwargs); end
+
+        def put_object(gcs_bucket, filename, data, **_kwargs)
+          Runtime::Logger.info "The #{filename} file would have been pushed to the #{gcs_bucket} bucket, with this content:"
+          Runtime::Logger.info data
+        end
+      end
+
+      class << self
+        # GCS Client
+        #
+        # @param project_id [String]
+        # @param credentials [String]
+        # @return [Fog::Storage::Google]
+        def gcs_client(project_id:, credentials:, dry_run: false)
+          if dry_run
+            GCSMockClient.new
+          else
+            Fog::Storage::Google.new(
+              google_project: project_id || raise("Missing Google project_id"),
+              **gcs_creds(credentials)
+            )
+          end
+        end
+
+        private
+
+        # GCS Credentials
+        #
+        # @param credentials [String]
+        # @return [Hash]
+        def gcs_creds(credentials)
+          json_key = credentials || raise('Missing Google credentials')
+          return { google_json_key_location: json_key } if File.exist?(json_key)
+
+          { google_json_key_string: json_key }
+        end
+      end
+    end
+  end
+end

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

@@ -43,14 +43,7 @@ module GitlabQuality
           return unless ENV['CI_SLACK_WEBHOOK_URL']
 
           pipeline = Runtime::Env.pipeline_from_project_name
-          channel = case pipeline
-                    when "canary"
-                      "e2e-run-production"
-                    when "staging", "staging-canary"
-                      "e2e-run-staging"
-                    else
-                      "e2e-run-#{pipeline}"
-                    end
+          channel = Runtime::Env.slack_alerts_channel
 
           slack_options = {
             slack_webhook_url: ENV.fetch('CI_SLACK_WEBHOOK_URL', nil),
@@ -58,7 +51,7 @@ module GitlabQuality
             username: "GitLab Quality Test Tooling",
             icon_emoji: ':ci_failing:',
             message: <<~MSG
-              An unexpected error occurred while reporting test results in issues.
+              Env: #{pipeline}. An unexpected error occurred while reporting test results in issues.
               The error occurred in job: #{Runtime::Env.ci_job_url}
               `#{error.class.name} #{error.message}`
             MSG

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module GitlabClient
+      class GroupLabelsClient < GitlabClient
+        def initialize(token:, group:, endpoint: nil, **_kwargs)
+          @token = token
+          @group = group
+          @endpoint = endpoint
+        end
+
+        def group_labels(options: {})
+          client.group_labels(group, options)
+        end
+
+        def create_group_label(name:, color: '#428BCA', description: nil)
+          client.create_group_label(group, name, color, description: description)
+        end
+
+        private
+
+        attr_reader :group, :token, :endpoint
+
+        def client
+          @client ||= Gitlab.client(
+            endpoint: endpoint || ENV['GITLAB_API_BASE'] || Runtime::Env.gitlab_api_base,
+            private_token: token
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -68,7 +68,7 @@ module GitlabQuality
 
         def find_issue_notes(iid:)
           handle_gitlab_client_exceptions do
-            client.issue_notes(project, iid, order_by: 'created_at', sort: 'asc').auto_paginate
+            client.issue_notes(project, iid, order_by: 'created_at', sort: 'asc', activity_filter: 'only_comments').auto_paginate
           end
         end
 

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

@@ -4,8 +4,8 @@ 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)
-          attrs = { description: description, labels: labels, confidential: confidential }
+        def create_issue(title:, description:, labels:, assignee_id: 'unknown', issue_type: 'issue', confidential: false)
+          attrs = { description: description, labels: labels, confidential: confidential, assignee_id: assignee_id }
 
           puts "The following #{issue_type} would have been created:"
           puts "project: #{project}, title: #{title}, attrs: #{attrs}"

data/lib/gitlab_quality/test_tooling/report/concerns/results_reporter.rb

@@ -36,7 +36,7 @@ module GitlabQuality
           end
 
           def new_issue_labels(_test)
-            %w[E2E status::automated]
+            %w[E2E status::automated suppress-contributor-links]
           end
 
           def up_to_date_labels(test:, issue: nil, new_labels: Set.new)

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

@@ -12,7 +12,7 @@ module GitlabQuality
       #   - Add a failure report in the "Failure reports" note
       class FailedTestIssue < HealthProblemReporter
         IDENTITY_LABELS       = ['test', 'test-health:failures', 'automation:bot-authored'].freeze
-        NEW_ISSUE_LABELS      = Set.new(['type::maintenance', 'failure::new', 'priority::3', 'severity::3', *IDENTITY_LABELS]).freeze
+        NEW_ISSUE_LABELS      = Set.new(['type::maintenance', 'failure::new', 'priority::3', 'severity::3', 'suppress-contributor-links', *IDENTITY_LABELS]).freeze
         REPORT_SECTION_HEADER = '#### Failure reports'
 
         FAILURE_STACKTRACE_REGEX = %r{(?:(?:.*Failure/Error:(?<stacktrace>.+))|(?<stacktrace>.+))}m

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

@@ -13,10 +13,10 @@ module GitlabQuality
       #   - Add a flakiness report in the "Flakiness reports" note
       class FlakyTestIssue < HealthProblemReporter
         IDENTITY_LABELS       = ['test', 'failure::flaky-test', 'test-health:pass-after-retry', 'automation:bot-authored'].freeze
-        NEW_ISSUE_LABELS      = Set.new(['type::maintenance', 'priority::3', 'severity::3', *IDENTITY_LABELS]).freeze
+        NEW_ISSUE_LABELS      = Set.new(['type::maintenance', 'priority::3', 'severity::3', 'suppress-contributor-links', *IDENTITY_LABELS]).freeze
         REPORT_SECTION_HEADER = '### Flakiness reports'
         REPORTS_DOCUMENTATION = <<~DOC
-          Flaky tests were detected. Please refer to the [Flaky tests reproducibility instructions](https://docs.gitlab.com/ee/development/testing_guide/flaky_tests.html#how-to-reproduce-a-flaky-test-locally)
+          Flaky tests were detected. Please refer to the [Flaky tests reproducibility instructions](https://docs.gitlab.com/development/testing_guide/unhealthy_tests/#how-to-reproduce-a-flaky-test-locally)
           to learn more about how to reproduce them.
         DOC
 

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

@@ -31,9 +31,9 @@ module GitlabQuality
           tests = tests.select { |test| pipeline_stages.include? test.report["stage"] } unless pipeline_stages.empty?
 
           issue = gitlab.create_issue(
-            title: "#{Time.now.strftime('%Y-%m-%d')} Test session report | #{Runtime::Env.qa_run_type}",
+            title: "#{Time.now.to_date.iso8601} Test session report | #{Runtime::Env.qa_run_type}",
             description: generate_description(tests),
-            labels: ['automation:bot-authored', 'E2E', 'triage report', pipeline_name_label],
+            labels: ['automation:bot-authored', 'E2E', 'triage report', pipeline_name_label, 'suppress-contributor-links'],
             confidential: confidential
           )
 

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