rails-profiler 0.24.0 → 0.26.0

data/lib/profiler/mcp/server.rb

@@ -71,6 +71,9 @@ module Profiler
         require_relative "tools/get_profile_http"
         require_relative "tools/query_jobs"
         require_relative "tools/query_mailers"
+        require_relative "tools/query_test_profiles"
+        require_relative "tools/get_test_profile_detail"
+        require_relative "tools/run_tests"
         require_relative "tools/clear_profiles"
         require_relative "tools/list_env_vars"
         require_relative "tools/set_env_var"
@@ -203,12 +206,64 @@ module Profiler
             },
             handler: Tools::QueryMailers
           ),
+          define_tool(
+            name: "query_test_profiles",
+            description: "Search and filter test profiles (RSpec/Minitest) by test name, status, or duration.",
+            input_schema: {
+              properties: {
+                test_name: { type: "string", description: "Filter by test name (partial match)" },
+                status: { type: "string", description: "Filter by status: 'passed', 'failed', or 'pending'" },
+                min_duration: { type: "number", description: "Minimum duration in milliseconds" },
+                limit: { type: "number", description: "Maximum number of results (default 20)" },
+                fields: { type: "array", items: { type: "string" }, description: "Columns to include. Valid values: time, test_name, status, duration, queries, n1, token. Omit for all." },
+                cursor: { type: "string", description: "Pagination cursor: ISO8601 timestamp of the last item seen." }
+              }
+            },
+            handler: Tools::QueryTestProfiles
+          ),
+          define_tool(
+            name: "get_test_profile",
+            description: "Get detailed data for a test profile: metadata, SQL queries, N+1 patterns, cache, exception. Use 'latest' as token for the most recent test.",
+            input_schema: {
+              properties: {
+                token: { type: "string", description: "Test profile token, or 'latest' for the most recent test profile (required)" }
+              },
+              required: ["token"]
+            },
+            handler: Tools::GetTestProfileDetail
+          ),
+          define_tool(
+            name: "run_tests",
+            description: "Run test files and wait for results. Returns output, status, duration, and tokens of test profiles created. Synchronous with configurable timeout (default 120s).",
+            input_schema: {
+              properties: {
+                files: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "Relative paths of test files to run (e.g. ['spec/models/user_spec.rb']). Omit to run all discovered tests."
+                },
+                framework: {
+                  type: "string",
+                  description: "Test framework: 'rspec' or 'minitest'. Auto-detected if omitted."
+                },
+                timeout_seconds: {
+                  type: "number",
+                  description: "Maximum seconds to wait for tests to finish (default: 120)."
+                },
+                max_output: {
+                  type: "number",
+                  description: "Maximum characters of output to return (tail). Default: 4000."
+                }
+              }
+            },
+            handler: Tools::RunTests
+          ),
           define_tool(
             name: "clear_profiles",
-            description: "Clear profiler history. Omit type to clear everything, or pass 'http'/'job' to clear only requests or jobs.",
+            description: "Clear profiler history. Omit type to clear everything, or pass 'http'/'job'/'test' to clear only that type.",
             input_schema: {
               properties: {
-                type: { type: "string", description: "Optional: 'http' to clear only requests, 'job' to clear only jobs" }
+                type: { type: "string", description: "Optional: 'http' to clear only requests, 'job' to clear only jobs, 'test' to clear only test profiles" }
               }
             },
             handler: Tools::ClearProfiles
@@ -279,12 +334,16 @@ module Profiler
         require_relative "resources/slow_queries"
         require_relative "resources/n1_patterns"
         require_relative "resources/recent_jobs"
+        require_relative "resources/slow_tests"
+        require_relative "resources/failing_tests"
 
         handlers = {
-          "profiler://recent" => Resources::RecentRequests,
-          "profiler://slow-queries" => Resources::SlowQueries,
-          "profiler://n1-patterns" => Resources::N1Patterns,
-          "profiler://recent-jobs" => Resources::RecentJobs
+          "profiler://recent"        => Resources::RecentRequests,
+          "profiler://slow-queries"  => Resources::SlowQueries,
+          "profiler://n1-patterns"   => Resources::N1Patterns,
+          "profiler://recent-jobs"   => Resources::RecentJobs,
+          "profiler://slow-tests"    => Resources::SlowTests,
+          "profiler://failing-tests" => Resources::FailingTests
         }
 
         resources = [
@@ -311,6 +370,18 @@ module Profiler
             name: "Recent Jobs",
             description: "List of recently profiled background jobs",
             mime_type: "application/json"
+          ),
+          ::MCP::Resource.new(
+            uri: "profiler://slow-tests",
+            name: "Slow Tests",
+            description: "Top 10 slowest test profiles with query counts and N+1 detection",
+            mime_type: "application/json"
+          ),
+          ::MCP::Resource.new(
+            uri: "profiler://failing-tests",
+            name: "Failing Tests",
+            description: "Recent test profiles with status 'failed', including exception messages",
+            mime_type: "application/json"
           )
         ]
 

data/lib/profiler/mcp/tools/get_test_profile_detail.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Tools
+      class GetTestProfileDetail
+        def self.call(params)
+          token = params["token"]
+          unless token
+            return [{ type: "text", text: "Error: token parameter is required" }]
+          end
+
+          profile = if token == "latest"
+            profiles = Profiler.storage.list(limit: 200)
+            profiles.find { |p| p.profile_type == "test" }
+          else
+            Profiler.storage.load(token)
+          end
+
+          unless profile && profile.profile_type == "test"
+            return [{ type: "text", text: "Test profile not found: #{token}" }]
+          end
+
+          [{ type: "text", text: format_test_detail(profile) }]
+        end
+
+        private
+
+        def self.format_test_detail(profile)
+          test_data = profile.collector_data("test") || {}
+          db_data   = profile.collector_data("database") || {}
+          cache_data = profile.collector_data("cache") || {}
+          exc_data  = profile.collector_data("exception") || {}
+
+          queries  = db_data["queries"] || []
+          n1_count = count_n1_patterns(queries)
+
+          lines = []
+          lines << "# Test Profile Detail\n"
+
+          # Overview
+          lines << "## Overview"
+          lines << "| Field | Value |"
+          lines << "|-------|-------|"
+          lines << "| Token | `#{profile.token}` |"
+          lines << "| Test name | #{test_data["test_name"] || profile.path} |"
+          lines << "| Status | #{test_data["status"] || "unknown"} |"
+          lines << "| Framework | #{test_data["framework"]} |"
+          lines << "| File | #{test_data["test_file"]}:#{test_data["test_line"]} |"
+          lines << "| Duration | #{profile.duration&.round(2)}ms |"
+          lines << "| Assertions | #{test_data["assertions"] || "-"} |"
+          lines << "| Memory delta | #{profile.memory ? "#{(profile.memory.to_f / 1024 / 1024).round(2)} MB" : "-"} |"
+          lines << "| Time | #{profile.started_at&.strftime("%H:%M:%S")} |"
+
+          # Exception / skip
+          if test_data["exception_message"]
+            lines << "\n## Exception"
+            lines << "```\n#{test_data["exception_message"]}\n```"
+          elsif test_data["skip_reason"]
+            lines << "\n## Skip reason"
+            lines << test_data["skip_reason"].to_s
+          end
+
+          # Unhandled exception (ExceptionCollector)
+          if exc_data["exception_class"]
+            lines << "\n## Unhandled Exception"
+            lines << "**#{exc_data["exception_class"]}**: #{exc_data["exception_message"]}"
+            if (backtrace = exc_data["backtrace"]).is_a?(Array) && backtrace.any?
+              lines << "\n```"
+              backtrace.first(5).each { |l| lines << l }
+              lines << "```"
+            end
+          end
+
+          # Database
+          lines << "\n## Database (#{db_data["total_queries"].to_i} queries · #{db_data["total_duration"].to_f.round(2)}ms · #{n1_count} N+1 patterns)"
+          if queries.any?
+            slow_threshold = Profiler.configuration.slow_query_threshold
+            slow = queries.select { |q| q["duration"].to_f >= slow_threshold }
+            show = slow.any? ? slow.first(10) : queries.first(10)
+            caption = slow.any? ? "Slowest queries:" : "First queries:"
+            lines << caption
+            lines << "| # | Duration | SQL |"
+            lines << "|---|----------|-----|"
+            show.each_with_index do |q, i|
+              sql = q["sql"].to_s.gsub("|", "\\|").then { |s| s.length > 100 ? s[0, 97] + "..." : s }
+              lines << "| #{i + 1} | #{q["duration"].to_f.round(2)}ms | `#{sql}` |"
+            end
+
+            if n1_count > 0
+              lines << "\n### N+1 Patterns Detected"
+              queries.group_by { |q| normalize_sql(q["sql"].to_s) }
+                     .select { |_, qs| qs.size >= 3 }
+                     .each do |pattern, qs|
+                lines << "- `#{pattern[0, 120]}` (×#{qs.size})"
+              end
+            end
+          else
+            lines << "_No SQL queries recorded._"
+          end
+
+          # Cache
+          total_cache = cache_data["total_reads"].to_i + cache_data["total_writes"].to_i + cache_data["total_deletes"].to_i
+          if total_cache > 0
+            lines << "\n## Cache (#{total_cache} operations)"
+            lines << "- Reads: #{cache_data["total_reads"].to_i}"
+            lines << "- Writes: #{cache_data["total_writes"].to_i}"
+            lines << "- Deletes: #{cache_data["total_deletes"].to_i}"
+            lines << "- Misses: #{cache_data["total_misses"].to_i}"
+          end
+
+          lines.join("\n")
+        end
+
+        def self.count_n1_patterns(queries)
+          return 0 if queries.size < 3
+          queries.group_by { |q| normalize_sql(q["sql"].to_s) }.count { |_, qs| qs.size >= 3 }
+        end
+
+        def self.normalize_sql(sql)
+          sql.gsub(/\$\d+/, "?").gsub(/\b\d+\b/, "?").gsub(/'[^']*'/, "?").gsub(/"[^"]*"/, "?").strip
+        end
+      end
+    end
+  end
+end

data/lib/profiler/mcp/tools/query_test_profiles.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Tools
+      class QueryTestProfiles
+        ALL_FIELDS = %w[time test_name status duration queries n1 token].freeze
+
+        def self.call(params)
+          limit = params["limit"]&.to_i || 20
+          fetch_size = [limit * 5, 500].min
+          profiles = Profiler.storage.list(limit: fetch_size)
+
+          tests = profiles.select { |p| p.profile_type == "test" }
+
+          if params["test_name"]
+            term = params["test_name"].downcase
+            tests = tests.select do |p|
+              test_data = p.collector_data("test")
+              (test_data&.dig("test_name") || p.path).to_s.downcase.include?(term)
+            end
+          end
+
+          if params["status"]
+            tests = tests.select do |p|
+              test_data = p.collector_data("test")
+              test_data && test_data["status"] == params["status"]
+            end
+          end
+
+          if params["min_duration"]
+            min_ms = params["min_duration"].to_f
+            tests = tests.select { |p| p.duration >= min_ms }
+          end
+
+          if params["cursor"]
+            cutoff = Time.parse(params["cursor"]) rescue nil
+            tests = tests.select { |p| p.started_at < cutoff } if cutoff
+          end
+
+          tests = tests.first(limit)
+          fields = params["fields"]&.map(&:to_s)
+
+          [{ type: "text", text: format_tests_table(tests, fields, limit) }]
+        end
+
+        private
+
+        def self.format_tests_table(tests, fields, limit)
+          return "No test profiles found matching the criteria." if tests.empty?
+
+          fields ||= ALL_FIELDS
+          fields = fields & ALL_FIELDS
+
+          lines = []
+          lines << "# Test Profiles\n"
+          lines << "Found #{tests.size} tests:\n"
+
+          header = fields.map { |f| f.split("_").map(&:capitalize).join(" ") }.join(" | ")
+          separator = fields.map { "------" }.join("|")
+          lines << "| #{header} |"
+          lines << "|#{separator}|"
+
+          tests.each do |profile|
+            test_data = profile.collector_data("test") || {}
+            db_data   = profile.collector_data("database") || {}
+            queries   = db_data["queries"] || []
+            n1_count  = count_n1_patterns(queries)
+
+            row = fields.map do |f|
+              case f
+              when "time"      then profile.started_at.strftime("%H:%M:%S")
+              when "test_name" then (test_data["test_name"] || profile.path).to_s.then { |n| n.length > 60 ? n[0, 57] + "..." : n }
+              when "status"    then test_data["status"] || "-"
+              when "duration"  then "#{profile.duration.round(2)}ms"
+              when "queries"   then db_data["total_queries"].to_i.to_s
+              when "n1"        then n1_count > 0 ? "⚠ #{n1_count}" : "✓"
+              when "token"     then profile.token.to_s
+              end
+            end
+            lines << "| #{row.join(' | ')} |"
+          end
+
+          if tests.size == limit
+            lines << ""
+            lines << "*Next cursor: #{tests.last.started_at.iso8601}*"
+          end
+
+          lines.join("\n")
+        end
+
+        def self.count_n1_patterns(queries)
+          return 0 if queries.size < 3
+
+          queries.group_by { |q| normalize_sql(q["sql"].to_s) }
+                 .count { |_, qs| qs.size >= 3 }
+        end
+
+        def self.normalize_sql(sql)
+          sql.gsub(/\$\d+/, "?")
+             .gsub(/\b\d+\b/, "?")
+             .gsub(/'[^']*'/, "?")
+             .gsub(/"[^"]*"/, "?")
+             .strip
+        end
+      end
+    end
+  end
+end

data/lib/profiler/mcp/tools/run_tests.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "../../test_runner/discovery"
+require_relative "../../test_runner/run_store"
+require_relative "../../test_runner/runner"
+
+module Profiler
+  module MCP
+    module Tools
+      class RunTests
+        DEFAULT_TIMEOUT    = 120
+        DEFAULT_MAX_OUTPUT = 4000
+        POLL_TIMEOUT       = 10 # seconds per wait_for_output call
+
+        def self.call(params)
+          files          = Array(params["files"])
+          framework      = params["framework"]&.to_s
+          timeout_secs   = (params["timeout_seconds"] || DEFAULT_TIMEOUT).to_i
+          max_output     = (params["max_output"] || DEFAULT_MAX_OUTPUT).to_i
+
+          # Auto-detect framework if not provided
+          framework ||= begin
+            available = Profiler::TestRunner::Discovery.frameworks.map(&:to_s)
+            available.first || "rspec"
+          end
+
+          # If no files specified, discover all for the given framework
+          if files.empty?
+            tree = Profiler::TestRunner::Discovery.files(framework: framework.to_sym)
+            files = tree.flat_map { |dir| dir[:files].map { |f| f[:path] } }
+          end
+
+          if files.empty?
+            return [{ type: "text", text: "No test files found for framework '#{framework}'." }]
+          end
+
+          run_started_at = Time.now
+          run = Profiler::TestRunner::Runner.start(files: files, framework: framework)
+
+          output_pos = 0
+          deadline   = Time.now + timeout_secs
+          timed_out  = false
+
+          until Profiler::TestRunner::RunStore::TERMINAL_STATUSES.include?(run.status)
+            remaining = (deadline - Time.now).to_i
+            if remaining <= 0
+              timed_out = true
+              break
+            end
+
+            wait = [POLL_TIMEOUT, remaining].min
+            result = Profiler::TestRunner.run_store.wait_for_output(run.id, position: output_pos, timeout: wait)
+            output_pos = result[:position]
+            break if result[:finished]
+          end
+
+          full_output = run.output_lines.join
+          tail_output = full_output.length > max_output ? "…(truncated)\n" + full_output[-(max_output)..] : full_output
+
+          # Collect test profiles created during this run
+          profile_tokens = collect_run_profiles(run_started_at)
+
+          [{ type: "text", text: format_result(run, tail_output, timed_out, profile_tokens, files, framework) }]
+        end
+
+        private
+
+        def self.collect_run_profiles(since)
+          Profiler.storage.list(limit: 500).select do |p|
+            p.profile_type == "test" && p.started_at && p.started_at >= since
+          end.map(&:token)
+        rescue
+          []
+        end
+
+        def self.format_result(run, output, timed_out, profile_tokens, files, framework)
+          lines = []
+          lines << "# Test Run #{timed_out ? "(timed out)" : ""}\n"
+
+          lines << "## Summary"
+          lines << "| Field | Value |"
+          lines << "|-------|-------|"
+          lines << "| Run ID | `#{run.id}` |"
+          lines << "| Framework | #{framework} |"
+          lines << "| Files | #{files.size} |"
+          lines << "| Status | **#{run.status}** |"
+          lines << "| Exit code | #{run.exit_code.inspect} |"
+          lines << "| Duration | #{run.to_h[:duration]&.round(0)}ms |"
+
+          if timed_out
+            lines << ""
+            lines << "> ⚠ Timed out — run is still in progress. Use run ID `#{run.id}` to check later."
+          end
+
+          lines << "\n## Output (last #{output.length} chars)"
+          lines << "```"
+          lines << output.strip
+          lines << "```"
+
+          if profile_tokens.any?
+            lines << "\n## Test Profiles Created (#{profile_tokens.size})"
+            lines << "Use `get_test_profile` with any of these tokens for detailed SQL/cache/exception data:"
+            profile_tokens.first(10).each { |t| lines << "- `#{t}`" }
+            lines << "- _(#{profile_tokens.size - 10} more…)_" if profile_tokens.size > 10
+          end
+
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/profiler/railtie.rb

@@ -14,8 +14,9 @@ module Profiler
       # Set default configuration for Rails environment
       Profiler.configure do |config|
         config.enabled = Rails.env.development? || Rails.env.test?
-        config.storage = Rails.env.development? ? :file : :memory
+        config.storage = (Rails.env.development? || Rails.env.test?) ? :file : :memory
         config.tmp_path = Rails.root.join("tmp", "rails-profiler")
+        config.track_tests = Rails.env.test?
       end
     end
 
@@ -56,6 +57,17 @@ module Profiler
       end
     end
 
+    initializer "profiler.setup_test_profiler" do
+      next unless Profiler.configuration.enabled && Profiler.configuration.track_tests
+
+      require_relative "test_profiler"
+      require_relative "test_helpers/rspec_support"
+      require_relative "test_helpers/minitest_support"
+      require_relative "test_runner/discovery"
+      require_relative "test_runner/run_store"
+      require_relative "test_runner/runner"
+    end
+
     initializer "profiler.setup_job_instrumentation" do
       next unless Profiler.configuration.enabled && Profiler.configuration.track_jobs
 
@@ -81,6 +93,14 @@ module Profiler
       end
     end
 
+    console do
+      next unless Profiler.configuration.enabled && Profiler.configuration.track_console
+
+      require_relative "console_profiler"
+      require_relative "instrumentation/irb_instrumentation"
+      IRB::Context.prepend(Profiler::Instrumentation::IrbInstrumentation)
+    end
+
     rake_tasks do
       load "profiler/tasks/profiler.rake"
     end

data/lib/profiler/test_helpers/minitest_support.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../test_profiler"
+require_relative "reporter"
+
+module Profiler
+  module TestHelpers
+    # Minitest integration for the profiler.
+    #
+    # Usage in test_helper.rb:
+    #
+    #   require 'profiler/test_helpers/minitest_support'
+    #   Profiler::TestHelpers::MinitestSupport.install
+    module MinitestSupport
+      def self.install
+        require "minitest"
+
+        Minitest::Test.prepend(RunWrapper)
+
+        Minitest.after_run do
+          Profiler::TestHelpers::Reporter.print
+        end
+      end
+
+      module RunWrapper
+        def run
+          Profiler::TestProfiler.profile(
+            test_name: "#{self.class.name}##{name}",
+            test_file:  self.class.instance_method(name).source_location&.first || "",
+            test_line:  self.class.instance_method(name).source_location&.last || 0,
+            framework:  :minitest
+          ) { super }
+        rescue NameError
+          super
+        end
+      end
+    end
+  end
+end

data/lib/profiler/test_helpers/reporter.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Profiler
+  module TestHelpers
+    module Reporter
+      WIDTH = 68
+
+      def self.print
+        return unless Profiler.enabled?
+
+        profiles = Profiler.storage.list(limit: 1000).select { |p| p.profile_type == "test" }
+        return if profiles.empty?
+
+        passed  = profiles.count { |p| test_status(p) == "passed" }
+        failed  = profiles.count { |p| test_status(p) == "failed" }
+        pending = profiles.count { |p| test_status(p) == "pending" }
+
+        total_queries = profiles.sum { |p| (p.collector_data("database") || {})["total_queries"].to_i }
+        n1_profiles   = profiles.select { |p| has_n1?(p) }
+        total_ms      = profiles.sum(&:duration).round(0).to_i
+
+        lines = []
+        lines << ""
+        lines << cyan("┌─ Profiler Test Report " + "─" * (WIDTH - 23) + "┐")
+        lines << cyan("│") + " #{profiles.size} tests · #{passed} passed · #{failed} failed · #{pending} pending" +
+                 pad_to(WIDTH - 1, "#{profiles.size} tests · #{passed} passed · #{failed} failed · #{pending} pending") +
+                 cyan("│")
+        lines << cyan("│") + " Total: #{total_ms}ms · #{total_queries} queries · #{n1_profiles.size} N+1 detected" +
+                 pad_to(WIDTH - 1, "Total: #{total_ms}ms · #{total_queries} queries · #{n1_profiles.size} N+1 detected") +
+                 cyan("│")
+
+        # Slowest tests
+        slowest = profiles.sort_by { |p| -p.duration }.first(5)
+        lines << cyan("├─ Slowest tests " + "─" * (WIDTH - 17) + "┤")
+        slowest.each_with_index do |p, i|
+          test_data = p.collector_data("test") || {}
+          db_data   = p.collector_data("database") || {}
+          name      = truncate(test_data["test_name"] || p.path, 44)
+          queries   = db_data["total_queries"].to_i
+          n1_flag   = has_n1?(p) ? " #{red("⚠ N+1")}" : ""
+          stats_raw = "#{p.duration.round(0).to_i}ms  #{queries}q"
+          pad       = [0, WIDTH - 6 - name.length - stats_raw.length].max
+          lines << cyan("│") + "  #{i + 1}. #{name}#{" " * pad}#{stats_raw}#{n1_flag}"
+        end
+
+        # N+1 patterns
+        if n1_profiles.any?
+          lines << cyan("├─ N+1 patterns " + "─" * (WIDTH - 16) + "┤")
+          n1_profiles.first(3).each do |p|
+            test_data = p.collector_data("test") || {}
+            db_data   = p.collector_data("database") || {}
+            queries   = db_data["queries"] || []
+            pattern   = top_n1_pattern(queries)
+            name      = truncate(test_data["test_name"] || p.path, WIDTH - 4)
+            lines << cyan("│") + "  #{yellow("▸")} #{yellow(truncate(pattern.to_s, WIDTH - 6))}"
+            lines << cyan("│") + "    → #{name}"
+          end
+        end
+
+        # Failed tests
+        failed_profiles = profiles.select { |p| test_status(p) == "failed" }
+        if failed_profiles.any?
+          lines << cyan("├─ Failed tests " + "─" * (WIDTH - 15) + "┤")
+          failed_profiles.first(5).each do |p|
+            test_data = p.collector_data("test") || {}
+            name      = test_data["test_name"] || p.path
+            exception = test_data["exception_message"]
+            lines << cyan("│") + "  #{red("✗")} #{truncate(name, WIDTH - 5)}"
+            lines << cyan("│") + "    #{truncate(exception.to_s, WIDTH - 6)}" if exception
+          end
+        end
+
+        lines << cyan("└" + "─" * WIDTH + "┘")
+        lines << ""
+
+        $stdout.puts lines.join("\n")
+      rescue => e
+        warn "Profiler Reporter: failed to generate report: #{e.message}"
+      end
+
+      def self.has_n1?(profile)
+        db_data = profile.collector_data("database") || {}
+        queries = db_data["queries"] || []
+        return false if queries.size < 3
+
+        queries.group_by { |q| normalize_sql(q["sql"].to_s) }.any? { |_, qs| qs.size >= 3 }
+      end
+
+      def self.test_status(profile)
+        (profile.collector_data("test") || {})["status"] || "passed"
+      end
+
+      def self.top_n1_pattern(queries)
+        return "" if queries.size < 3
+
+        queries.group_by { |q| normalize_sql(q["sql"].to_s) }
+               .select { |_, qs| qs.size >= 3 }
+               .max_by { |_, qs| qs.size }
+               &.first || ""
+      end
+
+      def self.normalize_sql(sql)
+        sql.gsub(/\$\d+/, "?").gsub(/\b\d+\b/, "?").gsub(/'[^']*'/, "?").gsub(/"[^"]*"/, "?").strip
+      end
+
+      def self.truncate(str, max)
+        str = str.to_s
+        str.length > max ? str[0, max - 3] + "..." : str
+      end
+
+      def self.pad_to(width, str)
+        visible = str.gsub(/\e\[[0-9;]*m/, "")
+        " " * [0, width - visible.length - 1].max
+      end
+
+      def self.cyan(str)    = "\e[36m#{str}\e[0m"
+      def self.yellow(str)  = "\e[33m#{str}\e[0m"
+      def self.red(str)     = "\e[31m#{str}\e[0m"
+    end
+  end
+end