rails-profiler 0.25.0 → 0.26.0

data/app/controllers/profiler/api/test_runner_controller.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "profiler/test_runner/discovery"
+require "profiler/test_runner/runner"
+
+module Profiler
+  module Api
+    class TestRunnerController < ApplicationController
+      include ActionController::Live
+
+      skip_before_action :verify_authenticity_token
+
+      def files
+        framework = params[:framework]
+        tree = Profiler::TestRunner::Discovery.files(framework: framework)
+        frameworks = Profiler::TestRunner::Discovery.frameworks
+
+        render json: {
+          frameworks: frameworks,
+          tree: tree
+        }
+      end
+
+      def create
+        files     = Array(params[:files])
+        framework = params[:framework] || detect_framework
+
+        if files.empty?
+          return render json: { error: "No files selected" }, status: :unprocessable_entity
+        end
+
+        # Validate paths are within Rails root (prevent path traversal)
+        root = defined?(Rails) ? Rails.root.to_s : Dir.pwd
+        files.each do |f|
+          expanded = File.expand_path(File.join(root, f))
+          unless expanded.start_with?(root)
+            return render json: { error: "Invalid file path: #{f}" }, status: :unprocessable_entity
+          end
+        end
+
+        run = Profiler::TestRunner::Runner.start(files: files, framework: framework)
+        render json: run.to_h, status: :created
+      end
+
+      def show
+        run = Profiler::TestRunner.run_store.find(params[:id])
+        return render json: { error: "Run not found" }, status: :not_found unless run
+
+        render json: run.to_h
+      end
+
+      # SSE endpoint — streams output chunks as server-sent events.
+      # Replaces polling for live test output in the frontend.
+      def stream
+        run = Profiler::TestRunner.run_store.find(params[:id])
+        unless run
+          render json: { error: "Run not found" }, status: :not_found
+          return
+        end
+
+        response.headers["Content-Type"]  = "text/event-stream"
+        response.headers["Cache-Control"] = "no-cache"
+        response.headers["X-Accel-Buffering"] = "no"
+
+        sse = SSE.new(response.stream, retry: 1000, event: "output")
+        position = 0
+
+        begin
+          loop do
+            result = Profiler::TestRunner.run_store.wait_for_output(
+              params[:id], position: position, timeout: 15
+            )
+
+            result[:chunks].each do |chunk|
+              sse.write({ chunk: chunk })
+            end
+            position = result[:position]
+
+            if result[:finished]
+              current_run = Profiler::TestRunner.run_store.find(params[:id])
+              sse.write(
+                { status: result[:status], exit_code: current_run&.exit_code },
+                event: "done"
+              )
+              break
+            end
+          end
+        rescue ActionController::Live::ClientDisconnected, IOError
+          # Client navigated away — normal exit
+        ensure
+          sse.close
+        end
+      end
+
+      def destroy
+        killed = Profiler::TestRunner::Runner.kill(params[:id])
+        if killed
+          head :no_content
+        else
+          render json: { error: "Run not found or not running" }, status: :not_found
+        end
+      end
+
+      private
+
+      def detect_framework
+        if Profiler::TestRunner::Discovery.rspec_available?
+          "rspec"
+        else
+          "minitest"
+        end
+      end
+    end
+  end
+end

data/app/controllers/profiler/api/tests_controller.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Api
+    class TestsController < ApplicationController
+      skip_before_action :verify_authenticity_token
+
+      def index
+        limit  = (params[:limit]  || 50).to_i
+        offset = (params[:offset] || 0).to_i
+        all    = Profiler.storage.list(limit: 1000, offset: 0)
+        tests  = all.select { |p| p.profile_type == "test" }
+        page   = tests.drop(offset).first(limit + 1)
+        render json: {
+          profiles: page.first(limit).map(&:to_h),
+          limit:    limit,
+          offset:   offset,
+          has_more: page.size > limit
+        }
+      end
+
+      def show
+        profile = Profiler.storage.load(params[:id])
+
+        unless profile && profile.profile_type == "test"
+          return render json: { error: "Test profile not found" }, status: :not_found
+        end
+
+        render json: profile.to_h
+      end
+
+      def destroy
+        profile = Profiler.storage.load(params[:id])
+        return render json: { error: "Test profile not found" }, status: :not_found unless profile&.profile_type == "test"
+
+        Profiler.storage.delete(params[:id])
+        head :no_content
+      end
+
+      def clear
+        Profiler.storage.clear(type: "test")
+        head :no_content
+      end
+    end
+  end
+end

data/app/controllers/profiler/test_runner_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Profiler
+  class TestRunnerController < ApplicationController
+    layout "profiler/application"
+
+    def index
+      redirect_to profiler.root_path(section: "runner"), allow_other_host: false
+    end
+  end
+end

data/app/views/profiler/test_runner/index.html.erb

@@ -0,0 +1 @@
+<div id="profiler-test-runner"></div>

data/config/routes.rb

@@ -22,6 +22,8 @@ Profiler::Engine.routes.draw do
   get "assets/profiler.js", to: "assets#main_js"
   get "assets/profiler.css", to: "assets#main_css"
 
+  get "test_runner", to: "test_runner#index"
+
   namespace :api do
     resources :profiles, only: [:index, :show, :destroy] do
       collection { delete :clear }
@@ -32,6 +34,9 @@ Profiler::Engine.routes.draw do
     resources :console, only: [:index, :show, :destroy] do
       collection { delete :clear }
     end
+    resources :tests, only: [:index, :show, :destroy] do
+      collection { delete :clear }
+    end
     resources :outbound_http, only: [:index]
     get "toolbar/:token", to: "toolbar#show"
     post "ajax/link", to: "ajax#link"
@@ -40,5 +45,10 @@ Profiler::Engine.routes.draw do
     resource :env_vars, only: [:show, :update], controller: "env_vars"
     delete "env_vars/reset", to: "env_vars#reset_override"
     delete "env_vars/reset_all", to: "env_vars#reset_all"
+    get    "test_runner/files",           to: "test_runner#files"
+    post   "test_runner/runs",            to: "test_runner#create"
+    get    "test_runner/runs/:id",        to: "test_runner#show",   as: :test_runner_run
+    get    "test_runner/runs/:id/stream", to: "test_runner#stream", as: :test_runner_run_stream
+    delete "test_runner/runs/:id",        to: "test_runner#destroy"
   end
 end

data/lib/profiler/collectors/database_collector.rb

@@ -39,7 +39,7 @@ module Profiler
 
           # Skip schema queries and internal Rails queries
           next if payload[:name] == "SCHEMA"
-          next if payload[:sql] =~ /^(BEGIN|COMMIT|ROLLBACK|SAVEPOINT)/i
+          next if payload[:sql] =~ /^(BEGIN|COMMIT|ROLLBACK|SAVEPOINT|RELEASE)/i
 
           query = Models::SqlQuery.new(
             sql: payload[:sql],

data/lib/profiler/collectors/test_collector.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "base_collector"
+
+module Profiler
+  module Collectors
+    class TestCollector < BaseCollector
+      def initialize(profile, test_name:, test_file:, test_line:, framework:)
+        super(profile)
+        @test_name = test_name
+        @test_file = test_file
+        @test_line = test_line
+        @framework = framework
+        @status = "running"
+        @exception_message = nil
+      end
+
+      def icon
+        "🧪"
+      end
+
+      def priority
+        5
+      end
+
+      def tab_config
+        {
+          key: "test",
+          label: "Test",
+          icon: icon,
+          priority: priority,
+          enabled: true,
+          default_active: true
+        }
+      end
+
+      def update_status(status, exception_message = nil)
+        @status = status
+        @exception_message = exception_message
+      end
+
+      def update_extra(assertions: nil, skip_reason: nil)
+        @assertions = assertions
+        @skip_reason = skip_reason
+      end
+
+      def collect
+        store_data({
+          test_name: @test_name,
+          test_file: @test_file,
+          test_line: @test_line,
+          framework: @framework.to_s,
+          status: @status,
+          exception_message: @exception_message,
+          assertions: @assertions,
+          skip_reason: @skip_reason
+        })
+      end
+
+      def has_data?
+        true
+      end
+
+      def toolbar_summary
+        color = case @status
+                when "passed"  then "green"
+                when "failed"  then "red"
+                when "pending" then "orange"
+                else "gray"
+                end
+        { text: @status, color: color }
+      end
+    end
+  end
+end

data/lib/profiler/configuration.rb

@@ -2,7 +2,7 @@
 
 module Profiler
   class Configuration
-    attr_accessor :enabled, :storage, :storage_options, :collectors,
+    attr_accessor :enabled, :storage_options, :collectors,
                   :skip_paths, :slow_query_threshold, :max_queries_warning,
                   :track_memory, :memory_warning_threshold,
                   :mcp_enabled, :mcp_transport, :mcp_port,
@@ -12,6 +12,7 @@ module Profiler
                   :track_http, :slow_http_threshold, :http_skip_hosts,
                   :track_jobs,
                   :track_console,
+                  :track_tests,
                   :track_mailers, :capture_mail_body, :sanitize_mailer_recipients, :mailer_skip_actions,
                   :compress_bodies, :compress_body_threshold
 
@@ -44,6 +45,7 @@ module Profiler
       @http_skip_hosts = []
       @track_jobs = true
       @track_console = true
+      @track_tests = false
       @track_mailers = true
       @capture_mail_body = false
       @sanitize_mailer_recipients = false
@@ -72,6 +74,15 @@ module Profiler
       end
     end
 
+    def storage
+      @storage
+    end
+
+    def storage=(value)
+      @storage = value
+      @storage_backend = nil
+    end
+
     def storage_backend
       @storage_backend ||= build_storage_backend
     end

data/lib/profiler/mcp/resources/failing_tests.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Resources
+      class FailingTests
+        def self.call
+          profiles = Profiler.storage.list(limit: 500)
+          failing = profiles.select do |p|
+            next false unless p.profile_type == "test"
+            test_data = p.collector_data("test") || {}
+            test_data["status"] == "failed"
+          end.first(20)
+
+          data = failing.map do |profile|
+            test_data = profile.collector_data("test") || {}
+            db_data   = profile.collector_data("database") || {}
+
+            {
+              token: profile.token,
+              test_name: test_data["test_name"] || profile.path,
+              framework: test_data["framework"],
+              file: "#{test_data["test_file"]}:#{test_data["test_line"]}",
+              exception: test_data["exception_message"],
+              duration_ms: profile.duration&.round(2),
+              query_count: db_data["total_queries"].to_i,
+              timestamp: profile.started_at&.iso8601
+            }
+          end
+
+          {
+            uri: "profiler://failing-tests",
+            mimeType: "application/json",
+            text: JSON.pretty_generate({ total: data.size, failing_tests: data })
+          }
+        end
+      end
+    end
+  end
+end

data/lib/profiler/mcp/resources/slow_tests.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Resources
+      class SlowTests
+        def self.call
+          profiles = Profiler.storage.list(limit: 500)
+          tests = profiles.select { |p| p.profile_type == "test" }
+                          .sort_by { |p| -p.duration }
+                          .first(10)
+
+          data = tests.map do |profile|
+            test_data = profile.collector_data("test") || {}
+            db_data   = profile.collector_data("database") || {}
+            queries   = db_data["queries"] || []
+            n1 = queries.group_by { |q| normalize_sql(q["sql"].to_s) }.any? { |_, qs| qs.size >= 3 }
+
+            {
+              token: profile.token,
+              test_name: test_data["test_name"] || profile.path,
+              status: test_data["status"],
+              framework: test_data["framework"],
+              file: test_data["test_file"],
+              duration_ms: profile.duration&.round(2),
+              query_count: db_data["total_queries"].to_i,
+              n1_detected: n1,
+              timestamp: profile.started_at&.iso8601
+            }
+          end
+
+          {
+            uri: "profiler://slow-tests",
+            mimeType: "application/json",
+            text: JSON.pretty_generate({ total: data.size, slow_tests: data })
+          }
+        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/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