rails-profiler 0.1.4

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

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "cgi"
+
+module Profiler
+  module MCP
+    module Tools
+      class GetProfileDetail
+        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
+
+          text = format_profile_detail(profile)
+
+          [
+            {
+              type: "text",
+              text: text
+            }
+          ]
+        end
+
+        private
+
+        def self.format_profile_detail(profile)
+          lines = []
+          lines << "# Profile Details: #{profile.token}\n"
+          lines << "**Request:** #{profile.method} #{profile.path}"
+          lines << "**Status:** #{profile.status}"
+          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"
+
+          # Job section
+          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 << ""
+          end
+
+          # Request section
+          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
+
+            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?
+              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
+          end
+
+          # 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
+            lines << ""
+          end
+
+          # Curl command
+          req_data_for_curl = profile.collector_data("request")
+          lines << "## Curl Command"
+          lines << "```bash"
+          lines << generate_curl(profile, req_data_for_curl)
+          lines << "```"
+          lines << ""
+
+          # Database section
+          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
+              end
+            end
+            lines << ""
+          end
+
+          # Performance section
+          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
+            end
+            lines << ""
+          end
+
+          # Views section
+          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 << ""
+            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 << ""
+            end
+          end
+
+          # Cache section
+          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 << ""
+            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 << ""
+            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 << ""
+            end
+          end
+
+          # Ajax section
+          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 << ""
+            end
+          end
+
+          # HTTP section
+          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 << ""
+            end
+          end
+
+          # Dumps section
+          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 << ""
+          end
+
+          lines.join("\n")
+        end
+
+        def self.generate_curl(profile, req_data)
+          headers  = req_data&.dig("headers")  || {}
+          params   = req_data&.dig("params")   || {}
+          req_body = req_data&.dig("request_body")
+
+          parts = ["curl -X #{profile.method}"]
+
+          headers.reject { |k, _| k == "User-Agent" }.each do |k, v|
+            parts << "  -H #{Shellwords.shellescape("#{k}: #{v}")}"
+          end
+
+          if %w[POST PUT PATCH].include?(profile.method)
+            if req_body && !req_body.empty?
+              parts << "  -d #{Shellwords.shellescape(req_body)}"
+            elsif !params.empty?
+              ct = headers["Content-Type"].to_s
+              if ct.include?("application/json")
+                parts << "  -d #{Shellwords.shellescape(params.to_json)}"
+              else
+                params.each { |k, v| parts << "  --data-urlencode #{Shellwords.shellescape("#{k}=#{v}")}" }
+              end
+            end
+          end
+
+          url = "http://localhost:3000#{profile.path}"
+          if profile.method == "GET" && !params.empty?
+            qs = params.map { |k, v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join("&")
+            url += "?#{qs}"
+          end
+
+          parts << "  #{Shellwords.shellescape(url)}"
+          parts.join(" \\\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Tools
+      class GetProfileDumps
+        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
+
+          dump_data = profile.collector_data("dump")
+          unless dump_data && dump_data["count"].to_i > 0
+            return [{ type: "text", text: "No variable dumps found in this profile" }]
+          end
+
+          [{ type: "text", text: format_dumps(profile, dump_data) }]
+        end
+
+        private
+
+        def self.format_dumps(profile, dump_data)
+          lines = []
+          lines << "# Variable Dumps: #{profile.token}\n"
+          lines << "**Request:** #{profile.method} #{profile.path}"
+          lines << "**Total Dumps:** #{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 << "- **Timestamp:** #{dump['timestamp']}" if dump['timestamp']
+            lines << "\n```"
+            lines << (dump['formatted'] || dump['value'].inspect)
+            lines << "```\n"
+          end
+
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Tools
+      class GetProfileHttp
+        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
+
+          http_data = profile.collector_data("http")
+          unless http_data && http_data["total_requests"].to_i > 0
+            return [{ type: "text", text: "No outbound HTTP requests found in this profile" }]
+          end
+
+          [{ type: "text", text: format_http(profile, http_data) }]
+        end
+
+        private
+
+        def self.format_http(profile, http_data)
+          threshold = Profiler.configuration.slow_http_threshold
+          lines = []
+          lines << "# Outbound HTTP Analysis: #{profile.token}\n"
+          lines << "**Request:** #{profile.method} #{profile.path}"
+          lines << "**Total Outbound Requests:** #{http_data['total_requests']}"
+          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?
+            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?
+            lines << "## By Status"
+            http_data["by_status"].each { |status, count| lines << "- **#{status}**: #{count}" }
+            lines << ""
+          end
+
+          if http_data["requests"] && !http_data["requests"].empty?
+            lines << "## Request Details"
+            http_data["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 << "- **Method:** #{req['method']}"
+              lines << "- **URL:** #{req['url']}"
+              lines << "- **Status:** #{req['status'] == 0 ? 'connection error' : req['status']}"
+              lines << "- **Duration:** #{req['duration'].round(2)} ms"
+              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
+              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
+              end
+              if req["backtrace"] && !req["backtrace"].empty?
+                lines << "- **Called from:**"
+                req["backtrace"].first(3).each { |frame| lines << "  - #{frame}" }
+              end
+            end
+            lines << ""
+          end
+
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Tools
+      class QueryJobs
+        def self.call(params)
+          limit = params["limit"]&.to_i || 20
+          profiles = Profiler.storage.list(limit: [limit * 5, 200].min)
+
+          jobs = profiles.select { |p| p.profile_type == "job" }
+
+          if params["queue"]
+            jobs = jobs.select do |p|
+              job_data = p.collector_data("job")
+              job_data && job_data["queue"] == params["queue"]
+            end
+          end
+
+          if params["status"]
+            jobs = jobs.select do |p|
+              job_data = p.collector_data("job")
+              job_data && job_data["status"] == params["status"]
+            end
+          end
+
+          jobs = jobs.first(limit)
+
+          text = format_jobs_table(jobs)
+
+          [{ type: "text", text: text }]
+        end
+
+        private
+
+        def self.format_jobs_table(jobs)
+          if jobs.empty?
+            return "No job profiles found matching the criteria."
+          end
+
+          lines = []
+          lines << "# Background Job Profiles\n"
+          lines << "Found #{jobs.size} jobs:\n"
+          lines << "| Time | Job Class | Queue | Status | Duration | Token |"
+          lines << "|------|-----------|-------|--------|----------|-------|"
+
+          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} |"
+          end
+
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Profiler
+  module MCP
+    module Tools
+      class QueryProfiles
+        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
+
+          if params["min_duration"]
+            min_dur = params["min_duration"].to_f
+            profiles = profiles.select { |p| p.duration && p.duration >= min_dur }
+          end
+
+          if params["profile_type"]
+            profiles = profiles.select { |p| p.profile_type == params["profile_type"] }
+          end
+
+          # Format as markdown table
+          text = format_profiles_table(profiles)
+
+          [
+            {
+              type: "text",
+              text: text
+            }
+          ]
+        end
+
+        private
+
+        def self.format_profiles_table(profiles)
+          if profiles.empty?
+            return "No profiles found matching the criteria."
+          end
+
+          lines = []
+          lines << "# Profiled Requests\n"
+          lines << "Found #{profiles.size} profiles:\n"
+          lines << "| Time | Type | Method | Path | Duration | Queries | Status | Token |"
+          lines << "|------|------|--------|------|----------|---------|--------|-------|"
+
+          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} |"
+          end
+
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/profiler/middleware/cors_middleware.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Middleware
+    class CorsMiddleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        # Apply CORS and frame options to all profiler endpoints
+        if env['PATH_INFO'].start_with?('/_profiler/')
+          # Handle OPTIONS preflight request
+          if env['REQUEST_METHOD'] == 'OPTIONS'
+            return [
+              200,
+              cors_headers,
+              ['']
+            ]
+          end
+
+          status, headers, body = @app.call(env)
+
+          # Add CORS headers
+          cors_headers.each do |key, value|
+            headers[key] = value
+          end
+
+          # Allow embedding in iframes from Chrome extensions
+          headers.delete('X-Frame-Options')
+          # Don't set CSP if controller requested to skip it
+          unless env['profiler.skip_csp']
+            # Allow embedding from standard web origins
+            headers['Content-Security-Policy'] = "frame-ancestors 'self' http: https:"
+          end
+
+          [status, headers, body]
+        else
+          @app.call(env)
+        end
+      end
+
+      private
+
+      def cors_headers
+        {
+          'Access-Control-Allow-Origin' => '*',
+          'Access-Control-Allow-Methods' => 'GET, POST, OPTIONS',
+          'Access-Control-Allow-Headers' => 'Content-Type, X-Requested-With, Accept',
+          'Access-Control-Expose-Headers' => 'X-Profiler-Token'
+        }
+      end
+    end
+  end
+end