rails-profiler 0.1.4

data/lib/profiler/mcp/resources/n1_patterns.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Resources
+      class N1Patterns
+        def self.call
+          profiles = Profiler.storage.list(limit: 100)
+
+          # Map normalized SQL -> list of occurrences across profiles
+          pattern_map = Hash.new { |h, k| h[k] = [] }
+
+          profiles.each do |profile|
+            db_data = profile.collector_data("database")
+            next unless db_data && db_data["queries"]
+
+            query_counts = db_data["queries"].group_by { |q| normalize_sql(q["sql"]) }
+                                             .transform_values(&:count)
+
+            query_counts.each do |normalized_sql, count|
+              pattern_map[normalized_sql] << {
+                token: profile.token,
+                path: profile.path,
+                count: count,
+                timestamp: profile.started_at&.iso8601
+              }
+            end
+          end
+
+          # Keep only patterns that appear in more than one profile OR appear multiple times in a single profile
+          n1_patterns = pattern_map.select do |_, occurrences|
+            occurrences.size > 1 || occurrences.any? { |o| o[:count] > 1 }
+          end
+
+          # Sort by total occurrence count descending
+          sorted = n1_patterns.map do |sql, occurrences|
+            total = occurrences.sum { |o| o[:count] }
+            { sql: sql, total_occurrences: total, profiles: occurrences }
+          end.sort_by { |p| -p[:total_occurrences] }.first(20)
+
+          {
+            uri: "profiler://n1-patterns",
+            mimeType: "application/json",
+            text: JSON.pretty_generate({
+              scanned_profiles: profiles.size,
+              total_patterns: sorted.size,
+              patterns: sorted
+            })
+          }
+        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/resources/recent_jobs.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Resources
+      class RecentJobs
+        def self.call
+          profiles = Profiler.storage.list(limit: 200)
+          jobs = profiles.select { |p| p.profile_type == "job" }.first(50)
+
+          data = jobs.map do |profile|
+            job_data = profile.collector_data("job") || {}
+            {
+              token: profile.token,
+              job_class: job_data["job_class"] || profile.path,
+              job_id: job_data["job_id"],
+              queue: job_data["queue"],
+              status: job_data["status"],
+              duration: profile.duration&.round(2),
+              executions: job_data["executions"],
+              error: job_data["error"],
+              timestamp: profile.started_at&.iso8601,
+              query_count: profile.collector_data("database")&.dig("total_queries") || 0
+            }
+          end
+
+          {
+            uri: "profiler://recent-jobs",
+            mimeType: "application/json",
+            text: JSON.pretty_generate({
+              total: data.size,
+              jobs: data
+            })
+          }
+        end
+      end
+    end
+  end
+end

data/lib/profiler/mcp/resources/recent_requests.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Resources
+      class RecentRequests
+        def self.call
+          profiles = Profiler.storage.list(limit: 50)
+
+          data = profiles.map do |profile|
+            {
+              token: profile.token,
+              path: profile.path,
+              method: profile.method,
+              status: profile.status,
+              duration: profile.duration&.round(2),
+              memory: profile.memory ? (profile.memory / 1024.0 / 1024.0).round(2) : nil,
+              timestamp: profile.started_at&.iso8601,
+              query_count: profile.collector_data("database")&.dig("total_queries") || 0
+            }
+          end
+
+          {
+            uri: "profiler://recent",
+            mimeType: "application/json",
+            text: JSON.pretty_generate({
+              total: data.size,
+              profiles: data
+            })
+          }
+        end
+      end
+    end
+  end
+end

data/lib/profiler/mcp/resources/slow_queries.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Resources
+      class SlowQueries
+        def self.call
+          profiles = Profiler.storage.list(limit: 100)
+          slow_threshold = Profiler.configuration.slow_query_threshold
+
+          slow_queries = []
+
+          profiles.each do |profile|
+            db_data = profile.collector_data("database")
+            next unless db_data && db_data["queries"]
+
+            db_data["queries"].each do |query|
+              if query["duration"] > slow_threshold
+                slow_queries << {
+                  profile_token: profile.token,
+                  profile_path: profile.path,
+                  sql: query["sql"],
+                  duration: query["duration"].round(2),
+                  timestamp: profile.started_at&.iso8601
+                }
+              end
+            end
+          end
+
+          # Sort by duration descending
+          slow_queries.sort_by! { |q| -q[:duration] }
+          slow_queries = slow_queries.first(50)
+
+          {
+            uri: "profiler://slow-queries",
+            mimeType: "application/json",
+            text: JSON.pretty_generate({
+              threshold: slow_threshold,
+              total: slow_queries.size,
+              queries: slow_queries
+            })
+          }
+        end
+      end
+    end
+  end
+end

data/lib/profiler/mcp/server.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "mcp"
+
+module Profiler
+  module MCP
+    class Server
+      class << self
+        def instance
+          @instance ||= new
+        end
+
+        def rack_app
+          # Memoized at class level — survives route reloads in development
+          @rack_app ||= ->(env) { instance.http_transport.handle_request(Rack::Request.new(env)) }
+        end
+      end
+
+      def initialize
+        tools = build_tools
+        resources, @resource_handlers = build_resources
+
+        @server = ::MCP::Server.new(
+          name: "rails-profiler",
+          version: Profiler::VERSION,
+          tools: tools,
+          resources: resources
+        )
+
+        @server.resources_read_handler do |params|
+          uri = params[:uri]
+          handler = @resource_handlers[uri]
+          next [{ uri: uri, mimeType: "application/json", text: "Resource not found: #{uri}" }] unless handler
+
+          result = handler.call
+          [{ uri: result[:uri], mimeType: result[:mimeType], text: result[:text] }]
+        end
+      end
+
+      def http_transport
+        @http_transport ||= begin
+          t = ::MCP::Server::Transports::StreamableHTTPTransport.new(@server)
+          @server.transport = t
+          t
+        end
+      end
+
+      def start(transport: :stdio)
+        case transport
+        when :stdio
+          ::MCP::Server::Transports::StdioTransport.new(@server).open
+        when :http
+          $stderr.puts "MCP HTTP transport active — endpoint: /_profiler/mcp"
+        else
+          raise Error, "Unknown transport: #{transport}"
+        end
+      end
+
+      private
+
+      def build_tools
+        require_relative "tools/query_profiles"
+        require_relative "tools/get_profile_detail"
+        require_relative "tools/analyze_queries"
+        require_relative "tools/get_profile_ajax"
+        require_relative "tools/get_profile_dumps"
+        require_relative "tools/get_profile_http"
+        require_relative "tools/query_jobs"
+        require_relative "tools/clear_profiles"
+
+        [
+          define_tool(
+            name: "query_profiles",
+            description: "Search and filter profiled requests by path, method, duration, etc.",
+            input_schema: {
+              properties: {
+                path: { type: "string", description: "Filter by request path (partial match)" },
+                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" }
+              }
+            },
+            handler: Tools::QueryProfiles
+          ),
+          define_tool(
+            name: "get_profile",
+            description: "Get detailed profile data by token",
+            input_schema: {
+              properties: {
+                token: { type: "string", description: "Profile token (required)" }
+              },
+              required: ["token"]
+            },
+            handler: Tools::GetProfileDetail
+          ),
+          define_tool(
+            name: "analyze_queries",
+            description: "Analyze SQL queries for N+1 problems, duplicates, and slow queries",
+            input_schema: {
+              properties: {
+                token: { type: "string", description: "Profile token (required)" }
+              },
+              required: ["token"]
+            },
+            handler: Tools::AnalyzeQueries
+          ),
+          define_tool(
+            name: "get_profile_ajax",
+            description: "Get detailed AJAX sub-request breakdown for a profile",
+            input_schema: {
+              properties: {
+                token: { type: "string", description: "Profile token (required)" }
+              },
+              required: ["token"]
+            },
+            handler: Tools::GetProfileAjax
+          ),
+          define_tool(
+            name: "get_profile_dumps",
+            description: "Get variable dumps captured during a profile",
+            input_schema: {
+              properties: {
+                token: { type: "string", description: "Profile token (required)" }
+              },
+              required: ["token"]
+            },
+            handler: Tools::GetProfileDumps
+          ),
+          define_tool(
+            name: "get_profile_http",
+            description: "Get outbound HTTP request breakdown for a profile (external API calls made during the request)",
+            input_schema: {
+              properties: {
+                token: { type: "string", description: "Profile token (required)" }
+              },
+              required: ["token"]
+            },
+            handler: Tools::GetProfileHttp
+          ),
+          define_tool(
+            name: "query_jobs",
+            description: "Search and filter background job profiles by queue, status, etc.",
+            input_schema: {
+              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" }
+              }
+            },
+            handler: Tools::QueryJobs
+          ),
+          define_tool(
+            name: "clear_profiles",
+            description: "Clear profiler history. Omit type to clear everything, or pass 'http'/'job' to clear only requests or jobs.",
+            input_schema: {
+              properties: {
+                type: { type: "string", description: "Optional: 'http' to clear only requests, 'job' to clear only jobs" }
+              }
+            },
+            handler: Tools::ClearProfiles
+          )
+        ]
+      end
+
+      def define_tool(name:, description:, input_schema:, handler:)
+        ::MCP::Tool.define(name: name, description: description, input_schema: input_schema) do |server_context: nil, **args|
+          result = handler.call(args.transform_keys(&:to_s))
+          ::MCP::Tool::Response.new(result)
+        end
+      end
+
+      def build_resources
+        require_relative "resources/recent_requests"
+        require_relative "resources/slow_queries"
+        require_relative "resources/n1_patterns"
+        require_relative "resources/recent_jobs"
+
+        handlers = {
+          "profiler://recent" => Resources::RecentRequests,
+          "profiler://slow-queries" => Resources::SlowQueries,
+          "profiler://n1-patterns" => Resources::N1Patterns,
+          "profiler://recent-jobs" => Resources::RecentJobs
+        }
+
+        resources = [
+          ::MCP::Resource.new(
+            uri: "profiler://recent",
+            name: "Recent Requests",
+            description: "List of recently profiled requests",
+            mime_type: "application/json"
+          ),
+          ::MCP::Resource.new(
+            uri: "profiler://slow-queries",
+            name: "Slow SQL Queries",
+            description: "List of slow database queries across all profiles",
+            mime_type: "application/json"
+          ),
+          ::MCP::Resource.new(
+            uri: "profiler://n1-patterns",
+            name: "N+1 Query Patterns",
+            description: "Cross-profile N+1 query pattern detection across the last 100 profiles",
+            mime_type: "application/json"
+          ),
+          ::MCP::Resource.new(
+            uri: "profiler://recent-jobs",
+            name: "Recent Jobs",
+            description: "List of recently profiled background jobs",
+            mime_type: "application/json"
+          )
+        ]
+
+        [resources, handlers]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Tools
+      class AnalyzeQueries
+        def self.call(params)
+          token = params["token"]
+          unless token
+            return [
+              {
+                type: "text",
+                text: "Error: token parameter is required"
+              }
+            ]
+          end
+
+          profile = Profiler.storage.load(token)
+          unless profile
+            return [
+              {
+                type: "text",
+                text: "Profile not found: #{token}"
+              }
+            ]
+          end
+
+          db_data = profile.collector_data("database")
+          unless db_data && db_data["queries"]
+            return [
+              {
+                type: "text",
+                text: "No database queries found in this profile"
+              }
+            ]
+          end
+
+          text = analyze_and_format(db_data["queries"])
+
+          [
+            {
+              type: "text",
+              text: text
+            }
+          ]
+        end
+
+        private
+
+        def self.analyze_and_format(queries)
+          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"
+            end
+
+            if query_counts.size > 5
+              lines << "_... and #{query_counts.size - 5} more duplicate patterns_\n"
+            end
+          else
+            lines << "## ✅ No Duplicate Queries"
+            lines << "No potential N+1 query problems detected\n"
+          end
+
+          # Overall statistics
+          lines << "## Summary Statistics"
+          lines << "- **Total Queries:** #{queries.size}"
+          lines << "- **Total Duration:** #{queries.sum { |q| q['duration'] }.round(2)}ms"
+          lines << "- **Average Duration:** #{(queries.sum { |q| q['duration'] } / queries.size).round(2)}ms"
+          lines << "- **Slow Queries:** #{slow_queries.size}"
+          lines << "- **Duplicate Patterns:** #{query_counts.size}"
+          lines << "- **Cached Queries:** #{queries.count { |q| q['cached'] }}"
+
+          lines.join("\n")
+        end
+
+        def self.normalize_sql(sql)
+          # Normalize SQL by removing bind values for comparison
+          sql.gsub(/\$\d+/, '?')
+             .gsub(/\b\d+\b/, '?')
+             .gsub(/'[^']*'/, '?')
+             .gsub(/"[^"]*"/, '?')
+             .strip
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Tools
+      class ClearProfiles
+        def self.call(params)
+          type = params["type"]
+
+          if type && !%w[http job].include?(type)
+            return [{ type: "text", text: "Error: type must be 'http' or 'job'" }]
+          end
+
+          Profiler.storage.clear(type: type)
+
+          label = type ? "#{type} profiles" : "all profiles (requests and jobs)"
+          [{ type: "text", text: "Cleared #{label}." }]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Tools
+      class GetProfileAjax
+        def self.call(params)
+          token = params["token"]
+          unless token
+            return [{ type: "text", text: "Error: token parameter is required" }]
+          end
+
+          profile = Profiler.storage.load(token)
+          unless profile
+            return [{ type: "text", text: "Profile not found: #{token}" }]
+          end
+
+          ajax_data = profile.collector_data("ajax")
+          unless ajax_data && ajax_data["total_requests"].to_i > 0
+            return [{ type: "text", text: "No AJAX requests found in this profile" }]
+          end
+
+          [{ type: "text", text: format_ajax(profile, ajax_data) }]
+        end
+
+        private
+
+        def self.format_ajax(profile, ajax_data)
+          lines = []
+          lines << "# AJAX Analysis: #{profile.token}\n"
+          lines << "**Request:** #{profile.method} #{profile.path}"
+          lines << "**Total AJAX Requests:** #{ajax_data['total_requests']}"
+          lines << "**Total Duration:** #{ajax_data['total_duration'].round(2)} ms\n"
+
+          if ajax_data["by_method"] && !ajax_data["by_method"].empty?
+            lines << "## By Method"
+            ajax_data["by_method"].each { |method, count| lines << "- **#{method}**: #{count}" }
+            lines << ""
+          end
+
+          if ajax_data["by_status"] && !ajax_data["by_status"].empty?
+            lines << "## By Status"
+            ajax_data["by_status"].each { |status, count| lines << "- **#{status}**: #{count}" }
+            lines << ""
+          end
+
+          if ajax_data["requests"] && !ajax_data["requests"].empty?
+            lines << "## Request List"
+            ajax_data["requests"].each_with_index do |req, index|
+              lines << "\n### Request #{index + 1}"
+              lines << "- **Method:** #{req['method']}"
+              lines << "- **Path:** #{req['path']}"
+              lines << "- **Status:** #{req['status']}"
+              lines << "- **Duration:** #{req['duration'].round(2)} ms"
+              lines << "- **Token:** #{req['token']}" if req['token']
+              lines << "- **Started At:** #{req['started_at']}" if req['started_at']
+            end
+            lines << ""
+          end
+
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end