rails-profiler 0.25.0 → 0.26.0

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
 

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

data/lib/profiler/test_helpers/rspec_support.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../test_profiler"
+require_relative "reporter"
+
+module Profiler
+  module TestHelpers
+    # RSpec integration for the profiler.
+    #
+    # Usage in spec_helper.rb:
+    #
+    #   require 'profiler/test_helpers/rspec_support'
+    #   RSpec.configure do |config|
+    #     Profiler::TestHelpers::RSpecSupport.install(config)
+    #   end
+    module RSpecSupport
+      def self.install(config)
+        config.around(:each) do |example|
+          Profiler::TestProfiler.profile(
+            test_name: example.full_description,
+            test_file:  example.file_path,
+            test_line:  example.line_number,
+            framework:  :rspec
+          ) { example.run }
+        end
+
+        config.after(:suite) do
+          Profiler::TestHelpers::Reporter.print
+        end
+      end
+    end
+  end
+end

data/lib/profiler/test_profiler.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative "models/profile"
+require_relative "current_context"
+require_relative "collectors/test_collector"
+require_relative "collectors/database_collector"
+require_relative "collectors/cache_collector"
+require_relative "collectors/exception_collector"
+require_relative "collectors/env_collector"
+require_relative "collectors/flamegraph_collector"
+
+module Profiler
+  class TestProfiler
+    TEST_COLLECTOR_CLASSES = [
+      Collectors::DatabaseCollector,
+      Collectors::CacheCollector,
+      Collectors::ExceptionCollector,
+      Collectors::EnvCollector,
+      Collectors::FlameGraphCollector
+    ].freeze
+
+    def self.profile(test_name:, test_file:, test_line:, framework:, &block)
+      return block.call unless Profiler.enabled?
+
+      new(
+        test_name: test_name,
+        test_file: test_file,
+        test_line: test_line,
+        framework: framework
+      ).run(&block)
+    end
+
+    def initialize(test_name:, test_file:, test_line:, framework:)
+      @test_name = test_name
+      @test_file = test_file
+      @test_line = test_line
+      @framework = framework
+    end
+
+    def run(&block)
+      profile = Models::Profile.new
+      profile.profile_type = "test"
+      profile.path = @test_file
+      profile.method = "TEST"
+
+      test_collector = Collectors::TestCollector.new(
+        profile,
+        test_name: @test_name,
+        test_file: @test_file,
+        test_line: @test_line,
+        framework: @framework
+      )
+
+      collectors = [test_collector] + TEST_COLLECTOR_CLASSES.map { |klass| klass.new(profile) }
+      collectors.each { |c| c.subscribe if c.respond_to?(:subscribe) }
+
+      exception_collector = collectors.find { |c| c.is_a?(Collectors::ExceptionCollector) }
+
+      memory_before = current_memory if Profiler.configuration.track_memory
+
+      test_status = "passed"
+      error_message = nil
+
+      previous_token = Profiler::CurrentContext.token
+      Profiler::CurrentContext.token = profile.token
+
+      begin
+        result = block.call
+
+        # Minitest: Test#run catches assertion errors internally and returns self.
+        # Failures don't propagate — detect them from the result object.
+        if result.respond_to?(:passed?)
+          unless result.passed?
+            test_status = result.skipped? ? "pending" : "failed"
+            msg = result.failure&.message.to_s
+            error_message = msg.empty? ? nil : msg
+          end
+          test_collector.update_extra(
+            assertions: result.respond_to?(:assertions) ? result.assertions : nil,
+            skip_reason: (result.skipped? && result.failure) ? result.failure.message : nil
+          )
+        end
+
+        # RSpec: example.run catches errors internally and stores them in execution_result.
+        if result.respond_to?(:execution_result)
+          er = result.execution_result
+          rspec_status = er.status&.to_s
+          if rspec_status && rspec_status != "passed" && test_status == "passed"
+            test_status = rspec_status
+            msg = er.exception&.message.to_s
+            error_message = msg.empty? ? nil : msg
+          end
+        end
+
+        result
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        # Capture all exceptions (including test failures which may subclass Exception)
+        test_status = "failed"
+        error_message = "#{e.class}: #{e.message}"
+        exception_collector&.capture(e) if e.is_a?(StandardError)
+        raise
+      ensure
+        Profiler::CurrentContext.token = previous_token
+
+        if Profiler.configuration.track_memory
+          profile.memory = current_memory - memory_before
+        end
+
+        test_collector.update_status(test_status, error_message)
+        profile.finish(test_status == "passed" ? 200 : 500)
+
+        collectors.each do |collector|
+          begin
+            collector.collect if collector.respond_to?(:collect)
+            profile.add_collector_metadata(collector)
+          rescue => e
+            warn "Profiler TestProfiler: Collector #{collector.class} failed: #{e.message}"
+          end
+        end
+
+        Profiler.storage.save(profile.token, profile)
+      end
+    end
+
+    private
+
+    def current_memory
+      return 0 unless defined?(GC.stat)
+
+      stats = GC.stat
+      if stats.key?(:total_allocated_size)
+        stats[:total_allocated_size]
+      elsif stats.key?(:total_allocated_objects)
+        stats[:total_allocated_objects] * 40
+      else
+        0
+      end
+    end
+  end
+end

data/lib/profiler/test_runner/discovery.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Profiler
+  module TestRunner
+    class Discovery
+      SPEC_GLOB  = "spec/**/*_spec.rb"
+      TEST_GLOB  = "test/**/*_test.rb"
+
+      def self.frameworks
+        frameworks = []
+        frameworks << :rspec    if rspec_available?
+        frameworks << :minitest if minitest_available?
+        frameworks
+      end
+
+      def self.files(framework: nil)
+        root = defined?(Rails) ? Rails.root.to_s : Dir.pwd
+        result = {}
+
+        globs = case framework&.to_sym
+                when :rspec    then [SPEC_GLOB]
+                when :minitest then [TEST_GLOB]
+                else [SPEC_GLOB, TEST_GLOB]
+                end
+
+        globs.each do |glob|
+          Dir.glob(File.join(root, glob)).each do |path|
+            relative = path.sub("#{root}/", "")
+            parts = relative.split("/")
+            dir   = parts[0..-2].join("/")
+            result[dir] ||= []
+            result[dir] << { path: relative, name: parts.last }
+          end
+        end
+
+        result.map do |dir, files|
+          {
+            directory: dir,
+            files: files.sort_by { |f| f[:name] }
+          }
+        end.sort_by { |d| d[:directory] }
+      end
+
+      def self.rspec_available?
+        defined?(RSpec) || Gem.loaded_specs.key?("rspec-core")
+      rescue
+        false
+      end
+
+      def self.minitest_available?
+        defined?(Minitest) || Gem.loaded_specs.key?("minitest")
+      rescue
+        false
+      end
+    end
+  end
+end