rails-profiler 0.4.0 → 0.6.0

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "shellwords"
+require "uri"
+
 module Profiler
   module MCP
     module Tools
@@ -10,7 +13,11 @@ module Profiler
             return [{ type: "text", text: "Error: token parameter is required" }]
           end
 
-          profile = Profiler.storage.load(token)
+          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
@@ -20,39 +27,57 @@ module Profiler
             return [{ type: "text", text: "No outbound HTTP requests found in this profile" }]
           end
 
-          [{ type: "text", text: format_http(profile, http_data) }]
+          domain_filter = params["domain"]
+          [{ type: "text", text: format_http(profile, http_data, domain_filter, params) }]
         end
 
         private
 
-        def self.format_http(profile, http_data)
+        def self.format_http(profile, http_data, domain_filter, params)
           threshold = Profiler.configuration.slow_http_threshold
+          requests = http_data["requests"] || []
+
+          if domain_filter && !domain_filter.empty?
+            requests = requests.select do |req|
+              host = begin
+                URI.parse(req["url"]).host.to_s
+              rescue URI::InvalidURIError
+                ""
+              end
+              host.include?(domain_filter)
+            end
+          end
+
           lines = []
           lines << "# Outbound HTTP Analysis: #{profile.token}\n"
           lines << "**Request:** #{profile.method} #{profile.path}"
+          lines << "**Started at:** #{profile.started_at&.strftime('%Y-%m-%d %H:%M:%S')}"
           lines << "**Total Outbound Requests:** #{http_data['total_requests']}"
+          lines << "**Showing:** #{requests.size} request(s)#{domain_filter ? " (filtered by domain: #{domain_filter})" : ""}"
           lines << "**Total Duration:** #{http_data['total_duration'].round(2)} ms"
           lines << "**Slow Requests (>#{threshold}ms):** #{http_data['slow_requests']}"
           lines << "**Error Requests:** #{http_data['error_requests']}\n"
 
-          if http_data["by_host"] && !http_data["by_host"].empty?
+          if http_data["by_host"] && !http_data["by_host"].empty? && !domain_filter
             lines << "## By Host"
             http_data["by_host"].each { |host, count| lines << "- **#{host}**: #{count}" }
             lines << ""
           end
 
-          if http_data["by_status"] && !http_data["by_status"].empty?
+          if http_data["by_status"] && !http_data["by_status"].empty? && !domain_filter
             lines << "## By Status"
             http_data["by_status"].each { |status, count| lines << "- **#{status}**: #{count}" }
             lines << ""
           end
 
-          if http_data["requests"] && !http_data["requests"].empty?
+          if requests && !requests.empty?
             lines << "## Request Details"
-            http_data["requests"].each_with_index do |req, i|
+            requests.each_with_index do |req, i|
               slow_flag = req["duration"] >= threshold ? " [SLOW]" : ""
               err_flag = req["status"] >= 400 || req["status"] == 0 ? " [ERROR]" : ""
               lines << "\n### Request #{i + 1}#{slow_flag}#{err_flag}"
+              lines << "- **ID:** #{req['id']}" if req["id"]
+              lines << "- **Started at:** #{req['started_at']}" if req["started_at"]
               lines << "- **Method:** #{req['method']}"
               lines << "- **URL:** #{req['url']}"
               lines << "- **Status:** #{req['status'] == 0 ? 'connection error' : req['status']}"
@@ -60,44 +85,67 @@ 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}" }
               end
+              lines << "- **Curl:**"
+              lines << "  ```bash"
+              lines << "  #{generate_curl_for_outbound(req)}"
+              lines << "  ```"
             end
             lines << ""
           end
 
           lines.join("\n")
         end
+
+        def self.generate_curl_for_outbound(req)
+          parts = ["curl -X #{req['method']}"]
+          req["request_headers"]
+            &.reject { |k, _| k.downcase == "user-agent" }
+            &.each { |k, v| parts << "  -H #{Shellwords.shellescape("#{k}: #{v}")}" }
+          if req["request_body"] && !req["request_body"].empty? && req["request_body_encoding"] != "base64"
+            parts << "  -d #{Shellwords.shellescape(req['request_body'])}"
+          end
+          parts << "  #{Shellwords.shellescape(req['url'])}"
+          parts.join(" \\\n")
+        end
       end
     end
   end

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('%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('%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/models/profile.rb

@@ -173,9 +173,17 @@ module Profiler
         params.to_h.except("password", "password_confirmation", "token", "secret")
       end
 
+      ALLOWED_HEADERS = %w[
+        Accept Accept-Charset Accept-Encoding Accept-Language
+        Authorization Cache-Control Connection Content-Length Content-Type
+        Cookie Host If-Modified-Since If-None-Match Origin
+        Referer User-Agent
+      ].freeze
+
       def extract_headers(env)
         env.select { |k, _| k.start_with?("HTTP_") }
            .transform_keys { |k| k.sub(/^HTTP_/, "").split("_").map(&:capitalize).join("-") }
+           .select { |k, _| ALLOWED_HEADERS.include?(k) }
       end
     end
   end

data/lib/profiler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Profiler
-  VERSION = "0.4.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.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Sébastien Duplessy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-03 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