rails-profiler 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cc5830bdf15d65e477e4d7acc5df46262d83737e76962dc4df5af36f6f113f8
-  data.tar.gz: 81abb0423f31141e915776ebcc77819b2d50e48aa13ec44c4ea11a906ad07ccf
+  metadata.gz: 8a0b42cc0bcdfe940609dbb07f9ee29a23cd00495c738711950749b22e58d664
+  data.tar.gz: b61678855bf48c082f4776773ce1754328c4e6b6d1672ea2542a836f79d9602a
 SHA512:
-  metadata.gz: 1be16066652bfa11550b5d277d3370eec2457d08dfbb0ceab46ebafe12a484cc342c61892133b030ab4b6d7d1506bcbe53ff8118eaa9ee4ee759c36012a0058e
-  data.tar.gz: a72957818f9d2a7dbdd914f57167ffd0bcfb6eef7df3dfb721a7a651f3acd89536d11cec4dbfa7c47f72f3331862b3279eb0312a7c66a0fbb47bb36e35c1640c
+  metadata.gz: bde96bed30d2bc7fda19f62a10a2a1b9d55e1e73b83bc91ae0bba63ae7fb58a0d66ca692cb3db7ca66d17c29cfc69d190123095d6cc8f428e33e4d3030733b70
+  data.tar.gz: 310c1ddfc31ab16fddd783db87e24bbe10a5c48058f678215f389f66056ede8af928438f7a350fd4f9ab8828f49f6daf4cdffd4f41634c76b3f9d1f0a0840f0f

data/lib/profiler/mcp/body_formatter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module BodyFormatter
+      # Formats a body string for MCP output.
+      #
+      # params keys used:
+      #   "save_bodies"   (boolean) — save to /tmp/rails-profiler/{token}/{name} and return path
+      #   "max_body_size" (number)  — truncate inline body at N chars
+      #   "json_path"     (string)  — JSONPath to extract from body when save_bodies is true
+      #   "xml_path"      (string)  — XPath to extract from body when save_bodies is true
+      #
+      # Returns a formatted string ready to embed in markdown, or nil if body is blank.
+      def self.format_body(token, name, body, encoding, params)
+        return "  *(binary, base64 encoded)*" if encoding == "base64"
+        return nil if body.nil? || body.empty?
+
+        if params["save_bodies"]
+          path = FileCache.save(token, name, body)
+          if path
+            result = "  *(saved → `#{path}`)*"
+            if params["json_path"]
+              extracted = PathExtractor.extract_json(body, params["json_path"])
+              result += "\n  `#{params['json_path']}` → `#{extracted}`"
+            elsif params["xml_path"]
+              extracted = PathExtractor.extract_xml(body, params["xml_path"])
+              result += "\n  `#{params['xml_path']}` → `#{extracted}`"
+            end
+            result
+          else
+            truncate_body(body, params["max_body_size"])
+          end
+        else
+          truncate_body(body, params["max_body_size"])
+        end
+      end
+
+      def self.truncate_body(body, max_size)
+        max = max_size&.to_i
+        content = if max && body.length > max
+          "#{body[0, max]}\n... [truncated, #{body.length} chars total]"
+        else
+          body
+        end
+        "```\n#{content}\n```"
+      end
+    end
+  end
+end

data/lib/profiler/mcp/file_cache.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Profiler
+  module MCP
+    class FileCache
+      BASE_DIR = "/tmp/rails-profiler"
+
+      def self.save(token, name, content)
+        cleanup if rand < 0.05
+
+        dir = File.join(BASE_DIR, token)
+        FileUtils.mkdir_p(dir)
+        path = File.join(dir, name)
+        File.write(path, content)
+        path
+      rescue Errno::EACCES, Errno::EROFS
+        nil
+      end
+
+      def self.cleanup(max_age: 3600)
+        return unless Dir.exist?(BASE_DIR)
+
+        Dir.glob(File.join(BASE_DIR, "*")).each do |dir|
+          FileUtils.rm_rf(dir) if File.directory?(dir) && (Time.now - File.mtime(dir)) > max_age
+        end
+      end
+    end
+  end
+end

data/lib/profiler/mcp/path_extractor.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Profiler
+  module MCP
+    module PathExtractor
+      # Supports dot-notation JSONPath: $.key, $.key.sub, $.array[0].key
+      def self.extract_json(content, path)
+        data = JSON.parse(content)
+        segments = path.sub(/\A\$\.?/, "").split(".").flat_map do |seg|
+          seg =~ /\A(.+)\[(\d+)\]\z/ ? [$1, $2.to_i] : [seg]
+        end
+        result = segments.reduce(data) do |obj, seg|
+          obj.is_a?(Array) ? obj[seg.to_i] : obj[seg]
+        end
+        JSON.generate(result)
+      rescue => e
+        "JSONPath error: #{e.message}"
+      end
+
+      def self.extract_xml(content, xpath)
+        require "nokogiri"
+        Nokogiri::XML(content).xpath(xpath).to_s
+      rescue => e
+        "XPath error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/profiler/mcp/server.rb

@@ -59,6 +59,9 @@ module Profiler
       private
 
       def build_tools
+        require_relative "file_cache"
+        require_relative "path_extractor"
+        require_relative "body_formatter"
         require_relative "tools/query_profiles"
         require_relative "tools/get_profile_detail"
         require_relative "tools/analyze_queries"
@@ -78,7 +81,9 @@ module Profiler
                 method: { type: "string", description: "Filter by HTTP method (GET, POST, etc.)" },
                 min_duration: { type: "number", description: "Minimum duration in milliseconds" },
                 profile_type: { type: "string", description: "Filter by type: 'http' or 'job'" },
-                limit: { type: "number", description: "Maximum number of results" }
+                limit: { type: "number", description: "Maximum number of results (default 20)" },
+                fields: { type: "array", items: { type: "string" }, description: "Columns to include. Valid values: time, type, method, path, duration, queries, status, token. Omit for all." },
+                cursor: { type: "string", description: "Pagination cursor: ISO8601 timestamp of the last item seen. Returns profiles older than this." }
               }
             },
             handler: Tools::QueryProfiles
@@ -88,7 +93,12 @@ module Profiler
             description: "Get detailed profile data by token. Use 'latest' as token to get the most recent profile.",
             input_schema: {
               properties: {
-                token: { type: "string", description: "Profile token, or 'latest' for the most recent profile (required)" }
+                token: { type: "string", description: "Profile token, or 'latest' for the most recent profile (required)" },
+                sections: { type: "array", items: { type: "string" }, description: "Sections to include. Valid values: overview, exception, job, request, response, curl, database, performance, views, cache, ajax, http, routes, dumps. Omit for all." },
+                save_bodies: { type: "boolean", description: "Save request/response bodies to temp files and return paths instead of inlining content." },
+                max_body_size: { type: "number", description: "Truncate inlined body content at N characters. Ignored when save_bodies is true." },
+                json_path: { type: "string", description: "JSONPath expression to extract from response body (e.g. '$.data.items[0]'). Only applied when save_bodies is true." },
+                xml_path: { type: "string", description: "XPath expression to extract from response body (e.g. '//items/item[1]/name'). Only applied when save_bodies is true." }
               },
               required: ["token"]
             },
@@ -99,7 +109,8 @@ module Profiler
             description: "Analyze SQL queries for N+1 problems, duplicates, and slow queries. Use 'latest' as token to analyze the most recent profile.",
             input_schema: {
               properties: {
-                token: { type: "string", description: "Profile token, or 'latest' for the most recent profile (required)" }
+                token: { type: "string", description: "Profile token, or 'latest' for the most recent profile (required)" },
+                summary_only: { type: "boolean", description: "Return only the summary statistics section, skipping slow query and N+1 details." }
               },
               required: ["token"]
             },
@@ -133,7 +144,11 @@ module Profiler
             input_schema: {
               properties: {
                 token: { type: "string", description: "Profile token, or 'latest' for the most recent profile (required)" },
-                domain: { type: "string", description: "Filter outbound requests by domain (partial match on host)" }
+                domain: { type: "string", description: "Filter outbound requests by domain (partial match on host)" },
+                save_bodies: { type: "boolean", description: "Save request/response bodies to temp files and return paths instead of inlining content." },
+                max_body_size: { type: "number", description: "Truncate inlined body content at N characters. Ignored when save_bodies is true." },
+                json_path: { type: "string", description: "JSONPath expression to extract from response bodies (e.g. '$.data.items[0]'). Only applied when save_bodies is true." },
+                xml_path: { type: "string", description: "XPath expression to extract from response bodies (e.g. '//items/item[1]/name'). Only applied when save_bodies is true." }
               },
               required: ["token"]
             },
@@ -146,7 +161,9 @@ module Profiler
               properties: {
                 queue: { type: "string", description: "Filter by queue name" },
                 status: { type: "string", description: "Filter by status (completed, failed)" },
-                limit: { type: "number", description: "Maximum number of results" }
+                limit: { type: "number", description: "Maximum number of results (default 20)" },
+                fields: { type: "array", items: { type: "string" }, description: "Columns to include. Valid values: time, job_class, queue, status, duration, token. Omit for all." },
+                cursor: { type: "string", description: "Pagination cursor: ISO8601 timestamp of the last item seen. Returns jobs older than this." }
               }
             },
             handler: Tools::QueryJobs

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

@@ -39,7 +39,8 @@ module Profiler
             ]
           end
 
-          text = analyze_and_format(db_data["queries"])
+          summary_only = params["summary_only"] == true || params["summary_only"] == "true"
+          text = analyze_and_format(db_data["queries"], summary_only: summary_only)
 
           [
             {
@@ -51,58 +52,55 @@ module Profiler
 
         private
 
-        def self.analyze_and_format(queries)
+        def self.analyze_and_format(queries, summary_only: false)
           lines = []
           lines << "# SQL Query Analysis\n"
 
-          # Detect slow queries
           slow_threshold = Profiler.configuration.slow_query_threshold
           slow_queries = queries.select { |q| q["duration"] > slow_threshold }
-
-          if slow_queries.any?
-            lines << "## ⚠️ Slow Queries (> #{slow_threshold}ms)"
-            lines << "Found #{slow_queries.size} slow queries:\n"
-
-            slow_queries.first(5).each_with_index do |query, index|
-              lines << "### Query #{index + 1} - #{query['duration'].round(2)}ms"
-              lines << "```sql"
-              lines << query['sql']
-              lines << "```\n"
-            end
-
-            if slow_queries.size > 5
-              lines << "_... and #{slow_queries.size - 5} more slow queries_\n"
-            end
-          else
-            lines << "## ✅ No Slow Queries"
-            lines << "All queries executed in less than #{slow_threshold}ms\n"
-          end
-
-          # Detect duplicate queries (potential N+1)
           query_counts = queries.group_by { |q| normalize_sql(q["sql"]) }
                                .transform_values(&:count)
                                .select { |_, count| count > 1 }
 
-          if query_counts.any?
-            lines << "## ⚠️ Duplicate Queries (Potential N+1)"
-            lines << "Found #{query_counts.size} duplicate query patterns:\n"
-
-            query_counts.sort_by { |_, count| -count }.first(5).each do |sql, count|
-              lines << "### Executed #{count} times:"
-              lines << "```sql"
-              lines << sql
-              lines << "```\n"
+          unless summary_only
+            # Detect slow queries
+            if slow_queries.any?
+              lines << "## ⚠️ Slow Queries (> #{slow_threshold}ms)"
+              lines << "Found #{slow_queries.size} slow queries:\n"
+
+              slow_queries.first(5).each_with_index do |query, index|
+                lines << "### Query #{index + 1} - #{query['duration'].round(2)}ms"
+                lines << "```sql"
+                lines << query["sql"]
+                lines << "```\n"
+              end
+
+              lines << "_... and #{slow_queries.size - 5} more slow queries_\n" if slow_queries.size > 5
+            else
+              lines << "## ✅ No Slow Queries"
+              lines << "All queries executed in less than #{slow_threshold}ms\n"
             end
 
-            if query_counts.size > 5
-              lines << "_... and #{query_counts.size - 5} more duplicate patterns_\n"
+            # Detect duplicate queries (potential N+1)
+            if query_counts.any?
+              lines << "## ⚠️ Duplicate Queries (Potential N+1)"
+              lines << "Found #{query_counts.size} duplicate query patterns:\n"
+
+              query_counts.sort_by { |_, count| -count }.first(5).each do |sql, count|
+                lines << "### Executed #{count} times:"
+                lines << "```sql"
+                lines << sql
+                lines << "```\n"
+              end
+
+              lines << "_... and #{query_counts.size - 5} more duplicate patterns_\n" if query_counts.size > 5
+            else
+              lines << "## ✅ No Duplicate Queries"
+              lines << "No potential N+1 query problems detected\n"
             end
-          else
-            lines << "## ✅ No Duplicate Queries"
-            lines << "No potential N+1 query problems detected\n"
           end
 
-          # Overall statistics
+          # Summary statistics always included
           lines << "## Summary Statistics"
           lines << "- **Total Queries:** #{queries.size}"
           lines << "- **Total Duration:** #{queries.sum { |q| q['duration'] }.round(2)}ms"
@@ -115,11 +113,10 @@ module Profiler
         end
 
         def self.normalize_sql(sql)
-          # Normalize SQL by removing bind values for comparison
-          sql.gsub(/\$\d+/, '?')
-             .gsub(/\b\d+\b/, '?')
-             .gsub(/'[^']*'/, '?')
-             .gsub(/"[^"]*"/, '?')
+          sql.gsub(/\$\d+/, "?")
+             .gsub(/\b\d+\b/, "?")
+             .gsub(/'[^']*'/, "?")
+             .gsub(/"[^"]*"/, "?")
              .strip
         end
       end

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

@@ -32,7 +32,7 @@ module Profiler
             ]
           end
 
-          text = format_profile_detail(profile)
+          text = format_profile_detail(profile, params)
 
           [
             {
@@ -44,7 +44,29 @@ module Profiler
 
         private
 
-        def self.format_profile_detail(profile)
+        def self.format_profile_detail(profile, params = {})
+          requested = params["sections"]&.map(&:to_s)
+          want = ->(name) { requested.nil? || requested.include?(name) }
+
+          lines = []
+          lines += section_overview(profile)              if want.("overview")
+          lines += section_exception(profile)             if want.("exception")
+          lines += section_job(profile)                   if want.("job")
+          lines += section_request(profile, params)       if want.("request")
+          lines += section_response(profile, params)      if want.("response")
+          lines += section_curl(profile)                  if want.("curl")
+          lines += section_database(profile)              if want.("database")
+          lines += section_performance(profile)           if want.("performance")
+          lines += section_views(profile)                 if want.("views")
+          lines += section_cache(profile)                 if want.("cache")
+          lines += section_ajax(profile)                  if want.("ajax")
+          lines += section_http(profile)                  if want.("http")
+          lines += section_routes(profile)                if want.("routes")
+          lines += section_dumps(profile)                 if want.("dumps")
+          lines.join("\n")
+        end
+
+        def self.section_overview(profile)
           lines = []
           lines << "# Profile Details: #{profile.token}\n"
           lines << "**Request:** #{profile.method} #{profile.path}"
@@ -52,278 +74,316 @@ module Profiler
           lines << "**Duration:** #{profile.duration.round(2)} ms"
           lines << "**Memory:** #{(profile.memory / 1024.0 / 1024.0).round(2)} MB" if profile.memory
           lines << "**Time:** #{profile.started_at}\n"
+          lines
+        end
 
-          # Exception section
+        def self.section_exception(profile)
+          lines = []
           exception_data = profile.collector_data("exception")
-          if exception_data && exception_data["exception_class"]
-            lines << "## Exception"
-            lines << "**Class:** #{exception_data['exception_class']}"
-            lines << "**Message:** #{exception_data['message']}\n"
-
-            backtrace = exception_data["backtrace"]
-            if backtrace && !backtrace.empty?
-              lines << "### Backtrace"
-              backtrace.first(20).each do |frame|
-                marker = frame["app_frame"] ? "★ " : "  "
-                lines << "#{marker}#{frame['location']}"
-              end
-              lines << ""
+          return lines unless exception_data && exception_data["exception_class"]
+
+          lines << "## Exception"
+          lines << "**Class:** #{exception_data['exception_class']}"
+          lines << "**Message:** #{exception_data['message']}\n"
+
+          backtrace = exception_data["backtrace"]
+          if backtrace && !backtrace.empty?
+            lines << "### Backtrace"
+            backtrace.first(20).each do |frame|
+              marker = frame["app_frame"] ? "★ " : "  "
+              lines << "#{marker}#{frame['location']}"
             end
+            lines << ""
           end
+          lines
+        end
 
-          # Job section
+        def self.section_job(profile)
+          lines = []
           job_data = profile.collector_data("job")
-          if job_data && job_data["job_class"]
-            lines << "## Job"
-            lines << "- Class: #{job_data['job_class']}"
-            lines << "- Job ID: #{job_data['job_id']}"
-            lines << "- Queue: #{job_data['queue']}"
-            lines << "- Executions: #{job_data['executions']}"
-            lines << "- Status: #{job_data['status']}"
-            lines << "- Error: #{job_data['error']}" if job_data['error']
-            if job_data['arguments'] && !job_data['arguments'].empty?
-              lines << "- Arguments: #{job_data['arguments'].map(&:to_s).join(', ')}"
-            end
-            lines << ""
+          return lines unless job_data && job_data["job_class"]
+
+          lines << "## Job"
+          lines << "- Class: #{job_data['job_class']}"
+          lines << "- Job ID: #{job_data['job_id']}"
+          lines << "- Queue: #{job_data['queue']}"
+          lines << "- Executions: #{job_data['executions']}"
+          lines << "- Status: #{job_data['status']}"
+          lines << "- Error: #{job_data['error']}" if job_data["error"]
+          if job_data["arguments"] && !job_data["arguments"].empty?
+            lines << "- Arguments: #{job_data['arguments'].map(&:to_s).join(', ')}"
           end
+          lines << ""
+          lines
+        end
 
-          # Request section
+        def self.section_request(profile, params)
+          lines = []
           req_data = profile.collector_data("request")
-          if req_data
-            params = req_data["params"]
-            headers = req_data["headers"]
-
-            if params && !params.empty?
-              lines << "## Request Params"
-              params.each { |k, v| lines << "- **#{k}**: #{v}" }
-              lines << ""
-            end
+          return lines unless req_data
 
-            if headers && !headers.empty?
-              lines << "## Request Headers"
-              headers.each { |k, v| lines << "- **#{k}**: #{v}" }
-              lines << ""
-            end
+          request_params = req_data["params"]
+          headers = req_data["headers"]
 
-            req_body = req_data["request_body"]
-            if req_body && !req_body.empty?
-              enc = req_data["request_body_encoding"]
-              lines << "## Request Body"
-              if enc == "base64"
-                lines << "_[binary, base64-encoded]_"
-              else
-                lines << "```"
-                lines << req_body
-                lines << "```"
-              end
-              lines << ""
-            end
+          if request_params && !request_params.empty?
+            lines << "## Request Params"
+            request_params.each { |k, v| lines << "- **#{k}**: #{v}" }
+            lines << ""
+          end
+
+          if headers && !headers.empty?
+            lines << "## Request Headers"
+            headers.each { |k, v| lines << "- **#{k}**: #{v}" }
+            lines << ""
+          end
+
+          req_body = req_data["request_body"]
+          if req_body && !req_body.empty?
+            lines << "## Request Body"
+            formatted = BodyFormatter.format_body(
+              profile.token,
+              "request_body",
+              req_body,
+              req_data["request_body_encoding"],
+              params
+            )
+            lines << formatted if formatted
+            lines << ""
           end
+          lines
+        end
+
+        def self.section_response(profile, params)
+          lines = []
 
-          # Response Headers section
           if profile.response_headers&.any?
             lines << "## Response Headers"
             profile.response_headers.each { |k, v| lines << "- **#{k}**: #{v}" }
             lines << ""
           end
 
-          # Response Body section
           resp_body = profile.response_body
           if resp_body && !resp_body.empty?
-            enc = profile.response_body_encoding
             lines << "## Response Body"
-            if enc == "base64"
-              lines << "_[binary, base64-encoded]_"
-            else
-              lines << "```"
-              lines << resp_body
-              lines << "```"
-            end
+            formatted = BodyFormatter.format_body(
+              profile.token,
+              "response_body",
+              resp_body,
+              profile.response_body_encoding,
+              params
+            )
+            lines << formatted if formatted
             lines << ""
           end
+          lines
+        end
 
-          # Curl command
-          req_data_for_curl = profile.collector_data("request")
+        def self.section_curl(profile)
+          req_data = profile.collector_data("request")
+          lines = []
           lines << "## Curl Command"
           lines << "```bash"
-          lines << generate_curl(profile, req_data_for_curl)
+          lines << generate_curl(profile, req_data)
           lines << "```"
           lines << ""
+          lines
+        end
 
-          # Database section
+        def self.section_database(profile)
+          lines = []
           db_data = profile.collector_data("database")
-          if db_data && db_data["total_queries"]
-            lines << "## Database"
-            lines << "- Total Queries: #{db_data['total_queries']}"
-            lines << "- Total Duration: #{db_data['total_duration'].round(2)} ms"
-            lines << "- Slow Queries: #{db_data['slow_queries']}"
-            lines << "- Cached Queries: #{db_data['cached_queries']}\n"
-
-            if db_data["queries"] && !db_data["queries"].empty?
-              lines << "### Query Details"
-              db_data["queries"].each_with_index do |query, index|
-                lines << "\n**Query #{index + 1}** (#{query['duration'].round(2)}ms):"
-                lines << "```sql"
-                lines << query['sql']
-                lines << "```"
-                if query['backtrace'] && !query['backtrace'].empty?
-                  lines << "_Backtrace:_"
-                  query['backtrace'].first(3).each { |frame| lines << "  #{frame}" }
-                end
+          return lines unless db_data && db_data["total_queries"]
+
+          lines << "## Database"
+          lines << "- Total Queries: #{db_data['total_queries']}"
+          lines << "- Total Duration: #{db_data['total_duration'].round(2)} ms"
+          lines << "- Slow Queries: #{db_data['slow_queries']}"
+          lines << "- Cached Queries: #{db_data['cached_queries']}\n"
+
+          if db_data["queries"] && !db_data["queries"].empty?
+            lines << "### Query Details"
+            db_data["queries"].each_with_index do |query, index|
+              lines << "\n**Query #{index + 1}** (#{query['duration'].round(2)}ms):"
+              lines << "```sql"
+              lines << query["sql"]
+              lines << "```"
+              if query["backtrace"] && !query["backtrace"].empty?
+                lines << "_Backtrace:_"
+                query["backtrace"].first(3).each { |frame| lines << "  #{frame}" }
               end
             end
-            lines << ""
           end
+          lines << ""
+          lines
+        end
 
-          # Performance section
+        def self.section_performance(profile)
+          lines = []
           perf_data = profile.collector_data("performance")
-          if perf_data && perf_data["total_events"]
-            lines << "## Performance Timeline"
-            lines << "- Total Events: #{perf_data['total_events']}"
-            lines << "- Total Duration: #{perf_data['total_duration'].round(2)} ms\n"
-
-            if perf_data["events"] && !perf_data["events"].empty?
-              lines << "### Events"
-              perf_data["events"].each do |event|
-                lines << "- **#{event['name']}**: #{event['duration'].round(2)} ms"
-              end
+          return lines unless perf_data && perf_data["total_events"]
+
+          lines << "## Performance Timeline"
+          lines << "- Total Events: #{perf_data['total_events']}"
+          lines << "- Total Duration: #{perf_data['total_duration'].round(2)} ms\n"
+
+          if perf_data["events"] && !perf_data["events"].empty?
+            lines << "### Events"
+            perf_data["events"].each do |event|
+              lines << "- **#{event['name']}**: #{event['duration'].round(2)} ms"
             end
-            lines << ""
           end
+          lines << ""
+          lines
+        end
 
-          # Views section
+        def self.section_views(profile)
+          lines = []
           view_data = profile.collector_data("view")
-          if view_data && (view_data["total_views"] || view_data["total_partials"])
-            lines << "## View Rendering"
-            lines << "- Templates: #{view_data['total_views']}"
-            lines << "- Partials: #{view_data['total_partials']}"
-            lines << "- Total Duration: #{view_data['total_duration'].round(2)} ms\n"
-
-            if view_data["views"] && !view_data["views"].empty?
-              lines << "### Templates"
-              view_data["views"].each do |view|
-                lines << "- `#{view['identifier']}` — #{view['duration'].round(2)} ms"
-              end
-              lines << ""
+          return lines unless view_data && (view_data["total_views"] || view_data["total_partials"])
+
+          lines << "## View Rendering"
+          lines << "- Templates: #{view_data['total_views']}"
+          lines << "- Partials: #{view_data['total_partials']}"
+          lines << "- Total Duration: #{view_data['total_duration'].round(2)} ms\n"
+
+          if view_data["views"] && !view_data["views"].empty?
+            lines << "### Templates"
+            view_data["views"].each do |view|
+              lines << "- `#{view['identifier']}` — #{view['duration'].round(2)} ms"
             end
+            lines << ""
+          end
 
-            if view_data["partials"] && !view_data["partials"].empty?
-              lines << "### Partials"
-              view_data["partials"].each do |partial|
-                lines << "- `#{partial['identifier']}` — #{partial['duration'].round(2)} ms"
-              end
-              lines << ""
+          if view_data["partials"] && !view_data["partials"].empty?
+            lines << "### Partials"
+            view_data["partials"].each do |partial|
+              lines << "- `#{partial['identifier']}` — #{partial['duration'].round(2)} ms"
             end
+            lines << ""
           end
+          lines
+        end
 
-          # Cache section
+        def self.section_cache(profile)
+          lines = []
           cache_data = profile.collector_data("cache")
-          if cache_data && cache_data["total_reads"]
-            lines << "## Cache"
-            lines << "- Reads: #{cache_data['total_reads']}"
-            lines << "- Writes: #{cache_data['total_writes']}"
-            lines << "- Deletes: #{cache_data['total_deletes']}"
-            lines << "- Hit Rate: #{cache_data['hit_rate']}%\n"
-
-            if cache_data["reads"] && !cache_data["reads"].empty?
-              lines << "### Cache Reads"
-              cache_data["reads"].each do |op|
-                hit_label = op['hit'] ? "HIT" : "MISS"
-                lines << "- [#{hit_label}] `#{op['key']}` — #{op['duration'].round(2)} ms"
-              end
-              lines << ""
+          return lines unless cache_data && cache_data["total_reads"]
+
+          lines << "## Cache"
+          lines << "- Reads: #{cache_data['total_reads']}"
+          lines << "- Writes: #{cache_data['total_writes']}"
+          lines << "- Deletes: #{cache_data['total_deletes']}"
+          lines << "- Hit Rate: #{cache_data['hit_rate']}%\n"
+
+          if cache_data["reads"] && !cache_data["reads"].empty?
+            lines << "### Cache Reads"
+            cache_data["reads"].each do |op|
+              hit_label = op["hit"] ? "HIT" : "MISS"
+              lines << "- [#{hit_label}] `#{op['key']}` — #{op['duration'].round(2)} ms"
             end
+            lines << ""
+          end
 
-            if cache_data["writes"] && !cache_data["writes"].empty?
-              lines << "### Cache Writes"
-              cache_data["writes"].each do |op|
-                lines << "- `#{op['key']}` — #{op['duration'].round(2)} ms"
-              end
-              lines << ""
+          if cache_data["writes"] && !cache_data["writes"].empty?
+            lines << "### Cache Writes"
+            cache_data["writes"].each do |op|
+              lines << "- `#{op['key']}` — #{op['duration'].round(2)} ms"
             end
+            lines << ""
+          end
 
-            if cache_data["deletes"] && !cache_data["deletes"].empty?
-              lines << "### Cache Deletes"
-              cache_data["deletes"].each do |op|
-                lines << "- `#{op['key']}` — #{op['duration'].round(2)} ms"
-              end
-              lines << ""
+          if cache_data["deletes"] && !cache_data["deletes"].empty?
+            lines << "### Cache Deletes"
+            cache_data["deletes"].each do |op|
+              lines << "- `#{op['key']}` — #{op['duration'].round(2)} ms"
             end
+            lines << ""
           end
+          lines
+        end
 
-          # Ajax section
+        def self.section_ajax(profile)
+          lines = []
           ajax_data = profile.collector_data("ajax")
-          if ajax_data && ajax_data["total_requests"].to_i > 0
-            lines << "## AJAX Requests"
-            lines << "- Total: #{ajax_data['total_requests']}"
-            lines << "- Total Duration: #{ajax_data['total_duration'].round(2)} ms\n"
-
-            if ajax_data["requests"] && !ajax_data["requests"].empty?
-              lines << "### Request List"
-              ajax_data["requests"].each do |req|
-                lines << "- **#{req['method']} #{req['path']}** — #{req['status']} — #{req['duration'].round(2)} ms (token: #{req['token']})"
-              end
-              lines << ""
+          return lines unless ajax_data && ajax_data["total_requests"].to_i > 0
+
+          lines << "## AJAX Requests"
+          lines << "- Total: #{ajax_data['total_requests']}"
+          lines << "- Total Duration: #{ajax_data['total_duration'].round(2)} ms\n"
+
+          if ajax_data["requests"] && !ajax_data["requests"].empty?
+            lines << "### Request List"
+            ajax_data["requests"].each do |req|
+              lines << "- **#{req['method']} #{req['path']}** — #{req['status']} — #{req['duration'].round(2)} ms (token: #{req['token']})"
             end
+            lines << ""
           end
+          lines
+        end
 
-          # HTTP section
+        def self.section_http(profile)
+          lines = []
           http_data = profile.collector_data("http")
-          if http_data && http_data["total_requests"].to_i > 0
-            threshold = Profiler.configuration.slow_http_threshold
-            lines << "## Outbound HTTP"
-            lines << "- Total: #{http_data['total_requests']}"
-            lines << "- Total Duration: #{http_data['total_duration'].round(2)} ms"
-            lines << "- Slow (>#{threshold}ms): #{http_data['slow_requests']}"
-            lines << "- Errors: #{http_data['error_requests']}\n"
-
-            if http_data["requests"] && !http_data["requests"].empty?
-              lines << "### Request List"
-              http_data["requests"].each do |req|
-                flag = req["duration"] >= threshold ? " [SLOW]" : ""
-                err = req["status"] >= 400 || req["status"] == 0 ? " [ERROR]" : ""
-                lines << "- **#{req['method']} #{req['url']}** — #{req['status'] == 0 ? 'error' : req['status']} — #{req['duration'].round(2)} ms#{flag}#{err}"
-              end
-              lines << ""
+          return lines unless http_data && http_data["total_requests"].to_i > 0
+
+          threshold = Profiler.configuration.slow_http_threshold
+          lines << "## Outbound HTTP"
+          lines << "- Total: #{http_data['total_requests']}"
+          lines << "- Total Duration: #{http_data['total_duration'].round(2)} ms"
+          lines << "- Slow (>#{threshold}ms): #{http_data['slow_requests']}"
+          lines << "- Errors: #{http_data['error_requests']}\n"
+
+          if http_data["requests"] && !http_data["requests"].empty?
+            lines << "### Request List"
+            http_data["requests"].each do |req|
+              flag = req["duration"] >= threshold ? " [SLOW]" : ""
+              err = req["status"] >= 400 || req["status"] == 0 ? " [ERROR]" : ""
+              lines << "- **#{req['method']} #{req['url']}** — #{req['status'] == 0 ? 'error' : req['status']} — #{req['duration'].round(2)} ms#{flag}#{err}"
             end
+            lines << ""
           end
+          lines
+        end
 
-          # Routes section
+        def self.section_routes(profile)
+          lines = []
           routes_data = profile.collector_data("routes")
-          if routes_data && routes_data["total"].to_i > 0
-            lines << "## Routes"
-            lines << "- Total routes: #{routes_data['total']}"
-
-            matched = routes_data["matched"]
-            if matched
-              lines << "- **Matched:** `#{matched['verb']} #{matched['pattern']}`"
-              lines << "  - Route name: #{matched['name']}_path" if matched["name"]
-              lines << "  - Controller#Action: #{matched['controller_action']}" if matched["controller_action"]
-            else
-              lines << "- No route matched"
-            end
-            lines << ""
+          return lines unless routes_data && routes_data["total"].to_i > 0
+
+          lines << "## Routes"
+          lines << "- Total routes: #{routes_data['total']}"
+
+          matched = routes_data["matched"]
+          if matched
+            lines << "- **Matched:** `#{matched['verb']} #{matched['pattern']}`"
+            lines << "  - Route name: #{matched['name']}_path" if matched["name"]
+            lines << "  - Controller#Action: #{matched['controller_action']}" if matched["controller_action"]
+          else
+            lines << "- No route matched"
           end
+          lines << ""
+          lines
+        end
 
-          # Dumps section
+        def self.section_dumps(profile)
+          lines = []
           dump_data = profile.collector_data("dump")
-          if dump_data && dump_data["count"].to_i > 0
-            lines << "## Variable Dumps"
-            lines << "- Count: #{dump_data['count']}\n"
-
-            dump_data["dumps"]&.each_with_index do |dump, index|
-              label = dump['label'] || "Dump #{index + 1}"
-              location = [dump['file'], dump['line']].compact.join(':')
-              lines << "### #{label}"
-              lines << "_Source: #{location}_" unless location.empty?
-              lines << "```"
-              lines << (dump['formatted'] || dump['value'].inspect)
-              lines << "```"
-            end
-            lines << ""
+          return lines unless dump_data && dump_data["count"].to_i > 0
+
+          lines << "## Variable Dumps"
+          lines << "- Count: #{dump_data['count']}\n"
+
+          dump_data["dumps"]&.each_with_index do |dump, index|
+            label = dump["label"] || "Dump #{index + 1}"
+            location = [dump["file"], dump["line"]].compact.join(":")
+            lines << "### #{label}"
+            lines << "_Source: #{location}_" unless location.empty?
+            lines << "```"
+            lines << (dump["formatted"] || dump["value"].inspect)
+            lines << "```"
           end
-
-          lines.join("\n")
+          lines << ""
+          lines
         end
 
         def self.generate_curl(profile, req_data)

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

@@ -28,12 +28,12 @@ module Profiler
           end
 
           domain_filter = params["domain"]
-          [{ type: "text", text: format_http(profile, http_data, domain_filter) }]
+          [{ type: "text", text: format_http(profile, http_data, domain_filter, params) }]
         end
 
         private
 
-        def self.format_http(profile, http_data, domain_filter)
+        def self.format_http(profile, http_data, domain_filter, params)
           threshold = Profiler.configuration.slow_http_threshold
           requests = http_data["requests"] || []
 
@@ -85,34 +85,41 @@ module Profiler
               lines << "- **Request Size:** #{req['request_size']} bytes"
               lines << "- **Response Size:** #{req['response_size']} bytes"
               lines << "- **Error:** #{req['error']}" if req["error"]
+
               if req["request_headers"] && !req["request_headers"].empty?
                 lines << "- **Request Headers:**"
                 req["request_headers"].each { |k, v| lines << "  - `#{k}`: #{v}" }
               end
+
               if req["request_body"] && !req["request_body"].empty?
                 lines << "- **Request Body:**"
-                if req["request_body_encoding"] == "base64"
-                  lines << "  *(binary content, base64 encoded — #{req['request_body'].bytesize} chars)*"
-                else
-                  lines << "  ```"
-                  lines << "  #{req['request_body'].lines.first(5).join('  ')}"
-                  lines << "  ```"
-                end
+                formatted = BodyFormatter.format_body(
+                  profile.token,
+                  "http_#{i}_request_body",
+                  req["request_body"],
+                  req["request_body_encoding"],
+                  params
+                )
+                lines << formatted if formatted
               end
+
               if req["response_headers"] && !req["response_headers"].empty?
                 lines << "- **Response Headers:**"
                 req["response_headers"].each { |k, v| lines << "  - `#{k}`: #{v}" }
               end
+
               if req["response_body"] && !req["response_body"].empty?
                 lines << "- **Response Body:**"
-                if req["response_body_encoding"] == "base64"
-                  lines << "  *(binary content, base64 encoded — #{req['response_body'].bytesize} chars)*"
-                else
-                  lines << "  ```"
-                  lines << "  #{req['response_body'].lines.first(10).join('  ')}"
-                  lines << "  ```"
-                end
+                formatted = BodyFormatter.format_body(
+                  profile.token,
+                  "http_#{i}_response_body",
+                  req["response_body"],
+                  req["response_body_encoding"],
+                  params
+                )
+                lines << formatted if formatted
               end
+
               if req["backtrace"] && !req["backtrace"].empty?
                 lines << "- **Called from:**"
                 req["backtrace"].first(3).each { |frame| lines << "  - #{frame}" }

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

@@ -4,9 +4,12 @@ module Profiler
   module MCP
     module Tools
       class QueryJobs
+        ALL_FIELDS = %w[time job_class queue status duration token].freeze
+
         def self.call(params)
           limit = params["limit"]&.to_i || 20
-          profiles = Profiler.storage.list(limit: [limit * 5, 200].min)
+          fetch_size = [limit * 5, 500].min
+          profiles = Profiler.storage.list(limit: fetch_size)
 
           jobs = profiles.select { |p| p.profile_type == "job" }
 
@@ -24,32 +27,52 @@ module Profiler
             end
           end
 
-          jobs = jobs.first(limit)
+          if params["cursor"]
+            cutoff = Time.parse(params["cursor"]) rescue nil
+            jobs = jobs.select { |p| p.started_at < cutoff } if cutoff
+          end
 
-          text = format_jobs_table(jobs)
+          jobs = jobs.first(limit)
+          fields = params["fields"]&.map(&:to_s)
 
-          [{ type: "text", text: text }]
+          [{ type: "text", text: format_jobs_table(jobs, fields, limit) }]
         end
 
         private
 
-        def self.format_jobs_table(jobs)
-          if jobs.empty?
-            return "No job profiles found matching the criteria."
-          end
+        def self.format_jobs_table(jobs, fields, limit)
+          return "No job profiles found matching the criteria." if jobs.empty?
+
+          fields ||= ALL_FIELDS
+          fields = fields & ALL_FIELDS
 
           lines = []
           lines << "# Background Job Profiles\n"
           lines << "Found #{jobs.size} jobs:\n"
-          lines << "| Time | Job Class | Queue | Status | Duration | Token |"
-          lines << "|------|-----------|-------|--------|----------|-------|"
+
+          header = fields.map { |f| f.split("_").map(&:capitalize).join(" ") }.join(" | ")
+          separator = fields.map { |_| "------" }.join("|")
+          lines << "| #{header} |"
+          lines << "|#{separator}|"
 
           jobs.each do |profile|
             job_data = profile.collector_data("job") || {}
-            job_class = job_data["job_class"] || profile.path
-            queue = job_data["queue"] || "-"
-            status = job_data["status"] || "-"
-            lines << "| #{profile.started_at.strftime('%Y-%m-%d %H:%M:%S')} | #{job_class} | #{queue} | #{status} | #{profile.duration.round(2)}ms | #{profile.token} |"
+            row = fields.map do |f|
+              case f
+              when "time"      then profile.started_at.strftime("%H:%M:%S")
+              when "job_class" then job_data["job_class"] || profile.path
+              when "queue"     then job_data["queue"] || "-"
+              when "status"    then job_data["status"] || "-"
+              when "duration"  then "#{profile.duration.round(2)}ms"
+              when "token"     then profile.token.to_s
+              end
+            end
+            lines << "| #{row.join(' | ')} |"
+          end
+
+          if jobs.size == limit
+            lines << ""
+            lines << "*Next cursor: #{jobs.last.started_at.iso8601}*"
           end
 
           lines.join("\n")

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

@@ -4,58 +4,73 @@ module Profiler
   module MCP
     module Tools
       class QueryProfiles
+        ALL_FIELDS = %w[time type method path duration queries status token].freeze
+
         def self.call(params)
           limit = params["limit"]&.to_i || 20
-          profiles = Profiler.storage.list(limit: limit)
-
-          # Apply filters
-          if params["path"]
-            profiles = profiles.select { |p| p.path&.include?(params["path"]) }
-          end
-
-          if params["method"]
-            profiles = profiles.select { |p| p.method == params["method"]&.upcase }
-          end
+          fetch_size = [limit * 5, 500].min
+          profiles = Profiler.storage.list(limit: fetch_size)
 
+          profiles = profiles.select { |p| p.path&.include?(params["path"]) } if params["path"]
+          profiles = profiles.select { |p| p.method == params["method"]&.upcase } if params["method"]
           if params["min_duration"]
             min_dur = params["min_duration"].to_f
             profiles = profiles.select { |p| p.duration && p.duration >= min_dur }
           end
+          profiles = profiles.select { |p| p.profile_type == params["profile_type"] } if params["profile_type"]
 
-          if params["profile_type"]
-            profiles = profiles.select { |p| p.profile_type == params["profile_type"] }
+          if params["cursor"]
+            cutoff = Time.parse(params["cursor"]) rescue nil
+            profiles = profiles.select { |p| p.started_at < cutoff } if cutoff
           end
 
-          # Format as markdown table
-          text = format_profiles_table(profiles)
+          profiles = profiles.first(limit)
+          fields = params["fields"]&.map(&:to_s)
 
-          [
-            {
-              type: "text",
-              text: text
-            }
-          ]
+          text = format_profiles_table(profiles, fields, limit)
+          [{ type: "text", text: text }]
         end
 
         private
 
-        def self.format_profiles_table(profiles)
-          if profiles.empty?
-            return "No profiles found matching the criteria."
-          end
+        def self.format_profiles_table(profiles, fields, limit)
+          return "No profiles found matching the criteria." if profiles.empty?
+
+          fields ||= ALL_FIELDS
+          fields = fields & ALL_FIELDS  # only allow valid fields
 
           lines = []
           lines << "# Profiled Requests\n"
           lines << "Found #{profiles.size} profiles:\n"
-          lines << "| Time | Type | Method | Path | Duration | Queries | Status | Token |"
-          lines << "|------|------|--------|------|----------|---------|--------|-------|"
+
+          header = fields.map { |f| f.capitalize }.join(" | ")
+          separator = fields.map { |_| "------" }.join("|")
+          lines << "| #{header} |"
+          lines << "|#{separator}|"
 
           profiles.each do |profile|
             db_data = profile.collector_data("database")
             query_count = db_data ? db_data["total_queries"] : 0
             type = profile.profile_type || "http"
 
-            lines << "| #{profile.started_at.strftime('%Y-%m-%d %H:%M:%S')} | #{type} | #{profile.method} | #{profile.path} | #{profile.duration.round(2)}ms | #{query_count} | #{profile.status} | #{profile.token} |"
+            row = fields.map do |f|
+              case f
+              when "time"     then profile.started_at.strftime("%Y-%m-%d %H:%M:%S")
+              when "type"     then type
+              when "method"   then profile.method.to_s
+              when "path"     then profile.path.to_s
+              when "duration" then "#{profile.duration.round(2)}ms"
+              when "queries"  then query_count.to_s
+              when "status"   then profile.status.to_s
+              when "token"    then profile.token.to_s
+              end
+            end
+            lines << "| #{row.join(' | ')} |"
+          end
+
+          if profiles.size == limit
+            lines << ""
+            lines << "*Next cursor: #{profiles.last.started_at.iso8601}*"
           end
 
           lines.join("\n")

data/lib/profiler/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-profiler
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Sébastien Duplessy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-04 00:00:00.000000000 Z
+date: 2026-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -142,6 +142,9 @@ files:
 - lib/profiler/instrumentation/net_http_instrumentation.rb
 - lib/profiler/instrumentation/sidekiq_middleware.rb
 - lib/profiler/job_profiler.rb
+- lib/profiler/mcp/body_formatter.rb
+- lib/profiler/mcp/file_cache.rb
+- lib/profiler/mcp/path_extractor.rb
 - lib/profiler/mcp/resources/n1_patterns.rb
 - lib/profiler/mcp/resources/recent_jobs.rb
 - lib/profiler/mcp/resources/recent_requests.rb