rails-profiler 0.24.0 → 0.26.0

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Api
+    class ConsoleController < 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)
+        console = all.select { |p| p.profile_type == "console" }
+        page   = console.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 == "console"
+          return render json: { error: "Console 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: "Console profile not found" }, status: :not_found unless profile&.profile_type == "console"
+
+        Profiler.storage.delete(params[:id])
+        head :no_content
+      end
+
+      def clear
+        Profiler.storage.clear(type: "console")
+        head :no_content
+      end
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ module Profiler
         limit  = (params[:limit]  || 50).to_i
         offset = (params[:offset] || 0).to_i
         all    = Profiler.storage.list(limit: 1000, offset: 0)
-        http   = all.reject { |p| p.profile_type == "job" }
+        http   = all.select { |p| p.profile_type == "http" }
         page   = http.drop(offset).first(limit + 1)
         render json: {
           profiles: page.first(limit).map(&:to_h),

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 }
@@ -29,6 +31,12 @@ Profiler::Engine.routes.draw do
     resources :jobs, only: [:index, :show, :destroy] do
       collection { delete :clear }
     end
+    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"
@@ -37,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/console_collector.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "base_collector"
+
+module Profiler
+  module Collectors
+    class ConsoleCollector < BaseCollector
+      def initialize(profile, expression:)
+        super(profile)
+        @expression = expression
+        @return_value = nil
+        @return_value_captured = false
+      end
+
+      def set_return_value(value)
+        @return_value = value.inspect.slice(0, 10_000)
+        @return_value_captured = true
+      rescue
+        @return_value = "(uninspectable)"
+        @return_value_captured = true
+      end
+
+      def icon
+        ">_"
+      end
+
+      def priority
+        5
+      end
+
+      def tab_config
+        {
+          key: "console",
+          label: "Console",
+          icon: icon,
+          priority: priority,
+          enabled: true,
+          default_active: true
+        }
+      end
+
+      def collect
+        data = { expression: @expression }
+        data[:return_value] = @return_value if @return_value_captured
+        store_data(data)
+      end
+
+      def has_data?
+        @expression.to_s.length > 0
+      end
+
+      def toolbar_summary
+        { text: @expression.to_s[0, 30], color: "blue" }
+      end
+    end
+  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,
@@ -11,6 +11,8 @@ module Profiler
                   :track_ajax, :ajax_skip_paths,
                   :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
 
@@ -42,6 +44,8 @@ module Profiler
       @slow_http_threshold = 500 # milliseconds
       @http_skip_hosts = []
       @track_jobs = true
+      @track_console = true
+      @track_tests = false
       @track_mailers = true
       @capture_mail_body = false
       @sanitize_mailer_recipients = false
@@ -70,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/console_profiler.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "models/profile"
+require_relative "current_context"
+require_relative "collectors/console_collector"
+require_relative "collectors/database_collector"
+require_relative "collectors/cache_collector"
+require_relative "collectors/http_collector"
+require_relative "collectors/dump_collector"
+require_relative "collectors/log_collector"
+require_relative "collectors/exception_collector"
+require_relative "collectors/env_collector"
+require_relative "collectors/flamegraph_collector"
+
+module Profiler
+  class ConsoleProfiler
+    CONSOLE_COLLECTOR_CLASSES = [
+      Collectors::DatabaseCollector,
+      Collectors::CacheCollector,
+      Collectors::HttpCollector,
+      Collectors::DumpCollector,
+      Collectors::LogCollector,
+      Collectors::ExceptionCollector,
+      Collectors::EnvCollector,
+      Collectors::FlameGraphCollector
+    ].freeze
+
+    def self.profile(expression:, &block)
+      return block.call unless Profiler.enabled? && Profiler.configuration.track_console
+
+      new(expression: expression).run(&block)
+    end
+
+    def initialize(expression:)
+      @expression = expression
+    end
+
+    def run(&block)
+      profile = Models::Profile.new
+      profile.profile_type = "console"
+      profile.gem_version = Profiler::VERSION
+      profile.path = @expression.length > 200 ? "#{@expression[0, 200]}..." : @expression
+      profile.method = "CONSOLE"
+
+      console_collector = Collectors::ConsoleCollector.new(profile, expression: @expression)
+      collectors = [console_collector] + CONSOLE_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
+
+      console_status = "completed"
+
+      previous_token = Profiler::CurrentContext.token
+      Profiler::CurrentContext.token = profile.token
+      result = nil
+      begin
+        result = block.call
+        console_collector.set_return_value(result)
+        result
+      rescue => e
+        console_status = "failed"
+        exception_collector&.capture(e)
+        raise
+      ensure
+        Profiler::CurrentContext.token = previous_token
+        if Profiler.configuration.track_memory
+          profile.memory = current_memory - memory_before
+        end
+
+        profile.finish(console_status == "completed" ? 200 : 500)
+
+        collectors.each do |collector|
+          begin
+            collector.collect if collector.respond_to?(:collect)
+            profile.add_collector_metadata(collector)
+          rescue => e
+            warn "Profiler ConsoleProfiler: 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/instrumentation/irb_instrumentation.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Instrumentation
+    module IrbInstrumentation
+      IRB_SKIP_COMMANDS = %w[exit quit exit! irb help].freeze
+
+      def evaluate(line, line_no, *args)
+        Profiler.env_override_store.apply!
+        stripped = line.to_s.strip
+        skip = !Profiler.enabled? ||
+               !Profiler.configuration.track_console ||
+               stripped.empty? ||
+               IRB_SKIP_COMMANDS.include?(stripped)
+        return super if skip
+
+        Profiler::ConsoleProfiler.profile(expression: stripped) { super }
+      end
+    end
+  end
+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