rails-profiler 0.24.0 → 0.26.0

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

data/lib/profiler/test_runner/run_store.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "concurrent"
+require "securerandom"
+
+module Profiler
+  module TestRunner
+    class RunStore
+      TTL = 3600 # 1 hour
+
+      Run = Struct.new(:id, :status, :pid, :started_at, :finished_at, :output_lines, :exit_code, :files, :framework, keyword_init: true) do
+        def to_h
+          super.merge(
+            started_at: started_at&.iso8601,
+            finished_at: finished_at&.iso8601,
+            output: output_lines.join,
+            duration: finished_at && started_at ? ((finished_at - started_at) * 1000).round(2) : nil
+          ).except(:output_lines)
+        end
+      end
+
+      TERMINAL_STATUSES = %w[passed failed killed error].freeze
+
+      def initialize
+        @runs  = Concurrent::Hash.new
+        @locks = Concurrent::Hash.new
+      end
+
+      def create(files:, framework:)
+        id  = SecureRandom.hex(8)
+        run = Run.new(
+          id: id,
+          status: "pending",
+          pid: nil,
+          started_at: Time.now,
+          finished_at: nil,
+          output_lines: Concurrent::Array.new,
+          exit_code: nil,
+          files: files,
+          framework: framework.to_s
+        )
+        @runs[id]  = run
+        @locks[id] = { mutex: Mutex.new, cond: ConditionVariable.new }
+        cleanup_old_runs
+        run
+      end
+
+      def find(id)
+        @runs[id]
+      end
+
+      def update(id, **attrs)
+        run = @runs[id]
+        return unless run
+
+        attrs.each { |k, v| run.send(:"#{k}=", v) }
+        signal(id)
+        run
+      end
+
+      def append_output(id, chunk)
+        run = @runs[id]
+        return unless run
+
+        run.output_lines.push(chunk)
+        signal(id)
+      end
+
+      # Block until new output is available at +position+ or the run terminates.
+      # Returns { chunks: [...], status: "...", position: N, finished: bool }.
+      def wait_for_output(id, position:, timeout: 10)
+        run = @runs[id]
+        return { chunks: [], status: "not_found", position: 0, finished: true } unless run
+
+        lock = @locks[id]
+        return snapshot(run, position) unless lock
+
+        lock[:mutex].synchronize do
+          current = run.output_lines.size
+          if current <= position && !TERMINAL_STATUSES.include?(run.status)
+            lock[:cond].wait(lock[:mutex], timeout)
+          end
+        end
+
+        snapshot(run, position)
+      end
+
+      def all
+        @runs.values.sort_by { |r| r.started_at || Time.at(0) }.reverse
+      end
+
+      private
+
+      def signal(id)
+        lock = @locks[id]
+        return unless lock
+        lock[:mutex].synchronize { lock[:cond].broadcast }
+      end
+
+      def snapshot(run, position)
+        lines = run.output_lines.dup
+        {
+          chunks: lines[position..] || [],
+          status: run.status,
+          position: lines.size,
+          finished: TERMINAL_STATUSES.include?(run.status)
+        }
+      end
+
+      def cleanup_old_runs
+        cutoff = Time.now - TTL
+        @runs.delete_if { |id, r| r.finished_at && r.finished_at < cutoff && @locks.delete(id) }
+      end
+    end
+
+    def self.run_store
+      @run_store ||= RunStore.new
+    end
+  end
+end

data/lib/profiler/test_runner/runner.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "run_store"
+require_relative "discovery"
+
+module Profiler
+  module TestRunner
+    class Runner
+      def self.start(files:, framework:)
+        run = Profiler::TestRunner.run_store.create(files: files, framework: framework)
+        spawn_async(run)
+        run
+      end
+
+      def self.kill(run_id)
+        run = Profiler::TestRunner.run_store.find(run_id)
+        return false unless run && run.pid && run.status == "running"
+
+        begin
+          Process.kill("TERM", run.pid)
+          Profiler::TestRunner.run_store.update(run_id, status: "killed", finished_at: Time.now)
+          true
+        rescue Errno::ESRCH
+          # Process already exited
+          false
+        end
+      end
+
+      private
+
+      def self.spawn_async(run)
+        Thread.new do
+          run_process(run)
+        rescue => e
+          Profiler::TestRunner.run_store.update(
+            run.id,
+            status: "error",
+            finished_at: Time.now
+          )
+          Profiler::TestRunner.run_store.append_output(run.id, "\n[Profiler] Error: #{e.message}\n")
+        end
+      end
+
+      def self.run_process(run)
+        cmd = build_command(run.files, run.framework)
+        env = build_env
+
+        Profiler::TestRunner.run_store.update(run.id, status: "running", started_at: Time.now)
+
+        IO.popen([env, *cmd, err: [:child, :out]], "r") do |io|
+          Profiler::TestRunner.run_store.update(run.id, pid: io.pid)
+
+          while (chunk = io.read(256))
+            break if chunk.empty?
+
+            Profiler::TestRunner.run_store.append_output(run.id, chunk)
+          end
+        end
+
+        exit_code = $?.exitstatus || 0
+        status = exit_code == 0 ? "passed" : "failed"
+
+        Profiler::TestRunner.run_store.update(
+          run.id,
+          status: status,
+          finished_at: Time.now,
+          exit_code: exit_code
+        )
+      end
+
+      def self.build_command(files, framework)
+        root = defined?(Rails) ? Rails.root.to_s : Dir.pwd
+        absolute_files = files.map { |f| File.join(root, f) }
+
+        case framework.to_sym
+        when :rspec
+          ["bundle", "exec", "rspec", "--format", "progress", "--color", *absolute_files]
+        when :minitest
+          ["bundle", "exec", "rails", "test", *absolute_files]
+        else
+          ["bundle", "exec", "rspec", "--format", "progress", "--color", *absolute_files]
+        end
+      end
+
+      BLOCKED_ENV_KEYS = %w[RAILS_ENV RACK_ENV DATABASE_URL SECRET_KEY_BASE].freeze
+
+      def self.build_env
+        base = ENV.to_h
+
+        # Inject env var overrides configured in the profiler — skip blocked keys
+        overrides = Profiler.env_override_store.all_overrides
+        overrides.each do |key, entry|
+          next if BLOCKED_ENV_KEYS.include?(key.upcase)
+          value = entry.is_a?(Hash) ? entry["value"] : entry
+          base[key] = value
+        end
+
+        # Ensure test environment regardless of overrides
+        base["RAILS_ENV"] = "test"
+        base["RACK_ENV"]  = "test"
+
+        base
+      end
+    end
+  end
+end

data/lib/profiler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Profiler
-  VERSION = "0.24.0"
+  VERSION = "0.26.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-profiler
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.26.0
 platform: ruby
 authors:
 - Sébastien Duplessy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-01 00:00:00.000000000 Z
+date: 2026-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -107,26 +107,32 @@ files:
 - app/assets/builds/profiler.css
 - app/assets/builds/profiler.js
 - app/controllers/profiler/api/ajax_controller.rb
+- app/controllers/profiler/api/console_controller.rb
 - app/controllers/profiler/api/env_vars_controller.rb
 - app/controllers/profiler/api/explain_controller.rb
 - app/controllers/profiler/api/function_profiling_controller.rb
 - app/controllers/profiler/api/jobs_controller.rb
 - app/controllers/profiler/api/outbound_http_controller.rb
 - app/controllers/profiler/api/profiles_controller.rb
+- app/controllers/profiler/api/test_runner_controller.rb
+- app/controllers/profiler/api/tests_controller.rb
 - app/controllers/profiler/api/toolbar_controller.rb
 - app/controllers/profiler/application_controller.rb
 - app/controllers/profiler/assets_controller.rb
 - app/controllers/profiler/profiles_controller.rb
+- app/controllers/profiler/test_runner_controller.rb
 - app/views/layouts/profiler/application.html.erb
 - app/views/layouts/profiler/embedded.html.erb
 - app/views/profiler/profiles/index.html.erb
 - app/views/profiler/profiles/show.html.erb
+- app/views/profiler/test_runner/index.html.erb
 - config/routes.rb
 - exe/profiler-mcp
 - lib/profiler.rb
 - lib/profiler/collectors/ajax_collector.rb
 - lib/profiler/collectors/base_collector.rb
 - lib/profiler/collectors/cache_collector.rb
+- lib/profiler/collectors/console_collector.rb
 - lib/profiler/collectors/database_collector.rb
 - lib/profiler/collectors/dump_collector.rb
 - lib/profiler/collectors/env_collector.rb
@@ -140,13 +146,16 @@ files:
 - lib/profiler/collectors/mailer_collector.rb
 - lib/profiler/collectors/request_collector.rb
 - lib/profiler/collectors/routes_collector.rb
+- lib/profiler/collectors/test_collector.rb
 - lib/profiler/collectors/view_collector.rb
 - lib/profiler/configuration.rb
+- lib/profiler/console_profiler.rb
 - lib/profiler/current_context.rb
 - lib/profiler/engine.rb
 - lib/profiler/env_override_store.rb
 - lib/profiler/explain_runner.rb
 - lib/profiler/instrumentation/active_job_instrumentation.rb
+- lib/profiler/instrumentation/irb_instrumentation.rb
 - lib/profiler/instrumentation/net_http_instrumentation.rb
 - lib/profiler/instrumentation/sidekiq_middleware.rb
 - lib/profiler/instrumentation/thread_context_propagation.rb
@@ -154,10 +163,12 @@ files:
 - lib/profiler/mcp/body_formatter.rb
 - lib/profiler/mcp/file_cache.rb
 - lib/profiler/mcp/path_extractor.rb
+- lib/profiler/mcp/resources/failing_tests.rb
 - lib/profiler/mcp/resources/n1_patterns.rb
 - lib/profiler/mcp/resources/recent_jobs.rb
 - lib/profiler/mcp/resources/recent_requests.rb
 - lib/profiler/mcp/resources/slow_queries.rb
+- lib/profiler/mcp/resources/slow_tests.rb
 - lib/profiler/mcp/server.rb
 - lib/profiler/mcp/tools/analyze_queries.rb
 - lib/profiler/mcp/tools/clear_profiles.rb
@@ -167,12 +178,15 @@ files:
 - lib/profiler/mcp/tools/get_profile_detail.rb
 - lib/profiler/mcp/tools/get_profile_dumps.rb
 - lib/profiler/mcp/tools/get_profile_http.rb
+- lib/profiler/mcp/tools/get_test_profile_detail.rb
 - lib/profiler/mcp/tools/list_env_vars.rb
 - lib/profiler/mcp/tools/query_jobs.rb
 - lib/profiler/mcp/tools/query_mailers.rb
 - lib/profiler/mcp/tools/query_profiles.rb
+- lib/profiler/mcp/tools/query_test_profiles.rb
 - lib/profiler/mcp/tools/reset_all_env_vars.rb
 - lib/profiler/mcp/tools/reset_env_var.rb
+- lib/profiler/mcp/tools/run_tests.rb
 - lib/profiler/mcp/tools/set_env_var.rb
 - lib/profiler/middleware/cors_middleware.rb
 - lib/profiler/middleware/profiler_middleware.rb
@@ -188,6 +202,13 @@ files:
 - lib/profiler/storage/redis_store.rb
 - lib/profiler/storage/sqlite_store.rb
 - lib/profiler/tasks/profiler.rake
+- lib/profiler/test_helpers/minitest_support.rb
+- lib/profiler/test_helpers/reporter.rb
+- lib/profiler/test_helpers/rspec_support.rb
+- lib/profiler/test_profiler.rb
+- lib/profiler/test_runner/discovery.rb
+- lib/profiler/test_runner/run_store.rb
+- lib/profiler/test_runner/runner.rb
 - lib/profiler/version.rb
 homepage: https://git.duplessy.eu/sebastien/rails-profiler-gem
 licenses: