rails-profiler 0.25.0 → 0.27.0

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

@@ -52,6 +52,7 @@ module Profiler
           lines += section_overview(profile)              if want.("overview")
           lines += section_exception(profile)             if want.("exception")
           lines += section_job(profile)                   if want.("job")
+          lines += section_console(profile)               if want.("console")
           lines += section_request(profile, params)       if want.("request")
           lines += section_response(profile, params)      if want.("response")
           lines += section_curl(profile)                  if want.("curl")
@@ -64,6 +65,9 @@ module Profiler
           lines += section_mailers(profile)               if want.("mailers")
           lines += section_routes(profile)                if want.("routes")
           lines += section_dumps(profile)                 if want.("dumps")
+          lines += section_logs(profile, params)          if want.("logs")
+          lines += section_env(profile, params)           if want.("env")
+          lines += section_i18n(profile)                  if want.("i18n")
           lines += section_related_jobs(profile)          if want.("related_jobs")
           lines.join("\n")
         end
@@ -71,7 +75,12 @@ module Profiler
         def self.section_overview(profile)
           lines = []
           lines << "# Profile Details: #{profile.token}\n"
-          lines << "**Type:** #{profile.profile_type == 'job' ? 'Job' : 'HTTP Request'}"
+          type_label = case profile.profile_type
+                       when "job"     then "Job"
+                       when "console" then "Console"
+                       else "HTTP Request"
+                       end
+          lines << "**Type:** #{type_label}"
           lines << "**Request:** #{profile.method} #{profile.path}"
           lines << "**Status:** #{profile.status}"
           lines << "**Duration:** #{profile.duration.round(2)} ms"
@@ -129,6 +138,26 @@ module Profiler
           lines
         end
 
+        def self.section_console(profile)
+          lines = []
+          console_data = profile.collector_data("console")
+          return lines unless console_data && console_data["expression"]
+
+          lines << "## Console"
+          lines << "**Expression:**"
+          lines << "```ruby"
+          lines << console_data["expression"].to_s
+          lines << "```"
+          if console_data.key?("return_value")
+            lines << "**Return Value:**"
+            lines << "```"
+            lines << console_data["return_value"].to_s
+            lines << "```"
+          end
+          lines << ""
+          lines
+        end
+
         def self.section_request(profile, params)
           lines = []
           req_data = profile.collector_data("request")
@@ -477,6 +506,99 @@ module Profiler
           lines
         end
 
+        def self.section_logs(profile, params = {})
+          lines = []
+          log_data = profile.collector_data("logs")
+          return lines unless log_data && log_data["count"].to_i > 0
+
+          logs = log_data["logs"] || []
+
+          min_level = params["log_min_level"]&.upcase
+          if min_level
+            severity_order = %w[DEBUG INFO WARN ERROR FATAL UNKNOWN]
+            min_idx = severity_order.index(min_level) || 0
+            logs = logs.select { |l| (severity_order.index(l["level"]) || 0) >= min_idx }
+          end
+
+          return lines if logs.empty?
+
+          lines << "## Logs (#{log_data['count']} total, #{log_data['errors']} errors, #{log_data['warnings']} warnings)\n"
+
+          logs.each do |entry|
+            level = entry["level"] || "INFO"
+            prefix = case level
+                     when "ERROR", "FATAL" then "❌"
+                     when "WARN"           then "⚠️"
+                     when "DEBUG"          then "🔍"
+                     else                       "ℹ️"
+                     end
+            lines << "- #{prefix} **#{level}** #{entry['message']}"
+          end
+          lines << ""
+          lines
+        end
+
+        def self.section_env(profile, params = {})
+          lines = []
+          env_data = profile.collector_data("env")
+          return lines unless env_data
+
+          filter = params["env_filter"]
+          unless filter && !filter.strip.empty?
+            lines << "## ENV Variables"
+            lines << "_Pass `env_filter` parameter to filter by key name (e.g. `RAILS`, `DATABASE`). #{env_data['total']} variables captured._"
+            lines << ""
+            return lines
+          end
+
+          variables = env_data["variables"] || {}
+          term = filter.downcase
+          matches = variables.select { |k, _| k.downcase.include?(term) }
+
+          lines << "## ENV Variables (filter: #{filter})\n"
+          if matches.empty?
+            lines << "_No variables matching '#{filter}'._"
+          else
+            matches.each { |k, v| lines << "- `#{k}` = `#{v}`" }
+          end
+          lines << ""
+          lines
+        end
+
+        def self.section_i18n(profile)
+          lines = []
+          i18n_data = profile.collector_data("i18n")
+          return lines unless i18n_data && i18n_data["total"].to_i > 0
+
+          lookups = i18n_data["lookups"] || []
+          missing = lookups.select { |l| l["missing"] }
+
+          lines << "## I18n"
+          lines << "- **Locale:** #{i18n_data['locale']}"
+          lines << "- **Total lookups:** #{i18n_data['total']}"
+          lines << "- **Missing translations:** #{i18n_data['missing_count']}"
+
+          if missing.any?
+            lines << ""
+            lines << "### Missing Translations"
+            missing.each { |l| lines << "- `#{l['key']}` (#{l['locale']})" }
+          end
+
+          top = lookups.group_by { |l| l["key"] }
+                       .map { |k, ls| [k, ls.size] }
+                       .sort_by { |_, c| -c }
+                       .first(10)
+
+          if top.any?
+            lines << ""
+            lines << "### Most Called Keys (top #{top.size})"
+            top.each { |key, count| lines << "- `#{key}`: #{count}×" }
+          end
+
+          lines << ""
+          lines
+        end
+
         def self.section_related_jobs(profile)
           lines = []
 

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Tools
+      class GetProfileMailers
+        SEVERITY_ICONS = { "deliver_now" => "✅", "deliver_later" => "📬", "queued" => "⏳" }.freeze
+
+        def self.call(params)
+          token = params["token"]
+          unless token
+            return [{ type: "text", text: "Error: token parameter is required" }]
+          end
+
+          profile = if token == "latest"
+            Profiler.storage.list(limit: 1).first
+          else
+            Profiler.storage.load(token)
+          end
+          unless profile
+            return [{ type: "text", text: "Profile not found: #{token}" }]
+          end
+
+          mailer_data = profile.collector_data("mailer")
+          unless mailer_data && mailer_data["total"].to_i + mailer_data["queued_count"].to_i > 0
+            return [{ type: "text", text: "No mailer activity found in this profile" }]
+          end
+
+          [{ type: "text", text: format_mailers(profile, mailer_data, params) }]
+        end
+
+        private
+
+        def self.format_mailers(profile, mailer_data, params)
+          mailer_filter = params["mailer_class"]&.downcase
+          action_filter = params["action"]&.downcase
+          mode_filter   = params["delivery_mode"]
+
+          emails  = filter_entries(mailer_data["emails"]  || [], mailer_filter, action_filter, mode_filter)
+          errors  = filter_entries(mailer_data["errors"]  || [], mailer_filter, action_filter, mode_filter)
+          queued  = filter_entries(mailer_data["queued"]  || [], mailer_filter, action_filter, mode_filter)
+
+          lines = []
+          lines << "# Mailer Activity: #{profile.token}\n"
+          lines << "**Request:** #{profile.method} #{profile.path}"
+          lines << "**Delivered:** #{mailer_data['total']} email(s)"
+          lines << "**Queued (deliver_later):** #{mailer_data['queued_count']} email(s)"
+          lines << "**Errors:** #{mailer_data['failed']}"
+          lines << "**Body captured:** #{mailer_data.dig('emails', 0, 'body_captured') ? 'yes' : 'no (set capture_mail_body: true)'}"
+
+          loop_warnings = mailer_data["loop_warnings"] || []
+          if loop_warnings.any?
+            lines << ""
+            lines << "⚠️ **Loop warnings:**"
+            loop_warnings.each { |w| lines << "  - #{w['message']}" }
+          end
+
+          append_email_section(lines, "Delivered Emails", emails, profile, params) if emails.any?
+          append_email_section(lines, "Errors", errors, profile, params) if errors.any?
+          append_queued_section(lines, queued) if queued.any?
+
+          lines.join("\n")
+        end
+
+        def self.filter_entries(entries, mailer_filter, action_filter, mode_filter)
+          entries = entries.select { |e| e["mailer_class"].to_s.downcase.include?(mailer_filter) } if mailer_filter
+          entries = entries.select { |e| e["action"].to_s.downcase.include?(action_filter) }       if action_filter
+          entries = entries.select { |e| e["delivery_mode"].to_s == mode_filter }                  if mode_filter
+          entries
+        end
+
+        def self.append_email_section(lines, title, emails, profile, params)
+          lines << ""
+          lines << "## #{title}\n"
+
+          emails.each_with_index do |email, i|
+            lines << "### Email #{i + 1}: #{email['mailer_class']}##{email['action']}"
+            lines << "- **Subject:** #{email['subject']}"
+            lines << "- **To:** #{Array(email['to']).join(', ')}"
+            lines << "- **From:** #{Array(email['from']).join(', ')}"
+            lines << "- **CC:** #{Array(email['cc']).join(', ')}"          unless Array(email['cc']).empty?
+            lines << "- **BCC:** #{Array(email['bcc']).join(', ')}"        unless Array(email['bcc']).empty?
+            lines << "- **Reply-To:** #{Array(email['reply_to']).join(', ')}" unless Array(email['reply_to']).empty?
+            lines << "- **Message-ID:** #{email['message_id']}"            if email['message_id']
+            lines << "- **Delivery method:** #{email['delivery_method']}"
+            lines << "- **Mode:** #{email['delivery_mode']}"
+            lines << "- **Render duration:** #{email['duration_ms']}ms"    if email['duration_ms']
+            lines << "- **Delivery duration:** #{email['delivery_ms']}ms"  if email['delivery_ms']
+            lines << "- **Error:** #{email['error']}"                      if email['error']
+
+            parts = Array(email['parts'])
+            lines << "- **Parts:** #{parts.join(', ')}" if parts.any?
+
+            attachments = Array(email['attachments'])
+            if attachments.any?
+              lines << "- **Attachments:**"
+              attachments.each { |a| lines << "  - #{a['filename']} (#{a['size']} bytes)" }
+            end
+
+            assigns = email['assigns'] || {}
+            if assigns.any?
+              lines << "- **Template assigns:**"
+              assigns.each { |k, v| lines << "  - `#{k}`: #{v}" }
+            end
+
+            if email['body_captured']
+              if email['body_html'] && !email['body_html'].empty?
+                lines << "- **HTML body:**"
+                formatted = BodyFormatter.format_body(
+                  profile.token, "mailer_#{i}_html", email['body_html'], nil, params
+                )
+                lines << formatted if formatted
+              end
+              if email['body_text'] && !email['body_text'].empty?
+                lines << "- **Text body:**"
+                formatted = BodyFormatter.format_body(
+                  profile.token, "mailer_#{i}_text", email['body_text'], nil, params
+                )
+                lines << formatted if formatted
+              end
+            else
+              lines << "- **Body:** not captured (enable `capture_mail_body: true` in initializer)"
+            end
+
+            lines << ""
+          end
+        end
+
+        def self.append_queued_section(lines, queued)
+          lines << ""
+          lines << "## Queued (deliver_later)\n"
+          queued.each_with_index do |email, i|
+            lines << "### Queued #{i + 1}: #{email['mailer_class']}##{email['action']}"
+            lines << "- **Delivery method:** #{email['delivery_method']}"
+            lines << "- **Render duration:** #{email['duration_ms']}ms" if email['duration_ms']
+            assigns = email['assigns'] || {}
+            if assigns.any?
+              lines << "- **Template assigns:**"
+              assigns.each { |k, v| lines << "  - `#{k}`: #{v}" }
+            end
+            lines << ""
+          end
+        end
+      end
+    end
+  end
+end

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_console_profiles.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Tools
+      class QueryConsoleProfiles
+        ALL_FIELDS = %w[time expression return_value status duration queries 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)
+
+          consoles = profiles.select { |p| p.profile_type == "console" }
+
+          if params["expression"]
+            term = params["expression"].downcase
+            consoles = consoles.select do |p|
+              console_data = p.collector_data("console")
+              console_data && console_data["expression"].to_s.downcase.include?(term)
+            end
+          end
+
+          if params["status"]
+            consoles = consoles.select do |p|
+              case params["status"]
+              when "completed" then p.status == 200
+              when "failed"    then p.status != 200
+              else false
+              end
+            end
+          end
+
+          if params["min_duration"]
+            min_ms = params["min_duration"].to_f
+            consoles = consoles.select { |p| p.duration >= min_ms }
+          end
+
+          if params["cursor"]
+            cutoff = Time.parse(params["cursor"]) rescue nil
+            consoles = consoles.select { |p| p.started_at < cutoff } if cutoff
+          end
+
+          consoles = consoles.first(limit)
+          fields = params["fields"]&.map(&:to_s)
+
+          [{ type: "text", text: format_console_table(consoles, fields, limit) }]
+        end
+
+        private
+
+        def self.format_console_table(consoles, fields, limit)
+          return "No console profiles found matching the criteria." if consoles.empty?
+
+          fields ||= ALL_FIELDS
+          fields = fields & ALL_FIELDS
+
+          lines = []
+          lines << "# Console Profiles\n"
+          lines << "Found #{consoles.size} console execution#{consoles.size > 1 ? "s" : ""}:\n"
+
+          header = fields.map { |f| f.split("_").map(&:capitalize).join(" ") }.join(" | ")
+          separator = fields.map { "------" }.join("|")
+          lines << "| #{header} |"
+          lines << "|#{separator}|"
+
+          consoles.each do |profile|
+            console_data = profile.collector_data("console") || {}
+            db_data = profile.collector_data("database") || {}
+
+            row = fields.map do |f|
+              case f
+              when "time"         then profile.started_at.strftime("%H:%M:%S")
+              when "expression"   then console_data["expression"].to_s.then { |e| e.length > 60 ? "#{e[0, 57]}..." : e }
+              when "return_value" then console_data["return_value"].to_s.then { |v| v.length > 80 ? "#{v[0, 77]}..." : v }
+              when "status"       then profile.status == 200 ? "completed" : "failed"
+              when "duration"     then "#{profile.duration.round(2)}ms"
+              when "queries"      then db_data["total_queries"].to_i.to_s
+              when "token"        then profile.token.to_s
+              end
+            end
+            lines << "| #{row.join(' | ')} |"
+          end
+
+          if consoles.size == limit
+            lines << ""
+            lines << "*Next cursor: #{consoles.last.started_at.iso8601}*"
+          end
+
+          lines.join("\n")
+        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