rails-profiler 0.1.4

data/lib/profiler/collectors/performance_collector.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "base_collector"
+require_relative "../models/timeline_event"
+
+module Profiler
+  module Collectors
+    class PerformanceCollector < BaseCollector
+      def initialize(profile)
+        super
+        @events = []
+        @subscriptions = []
+      end
+
+      def icon
+        "⚡"
+      end
+
+      def priority
+        30
+      end
+
+      def tab_config
+        {
+          key: "performance",
+          label: "Performance",
+          icon: icon,
+          priority: priority,
+          enabled: true,
+          default_active: false
+        }
+      end
+
+      def subscribe
+        return unless defined?(ActiveSupport::Notifications)
+
+        # Subscribe to controller processing
+        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("process_action.action_controller") do |name, started, finished, unique_id, payload|
+          @events << Models::TimelineEvent.new(
+            name: "Controller: #{payload[:controller]}##{payload[:action]}",
+            started_at: started,
+            finished_at: finished,
+            payload: {
+              controller: payload[:controller],
+              action: payload[:action],
+              format: payload[:format],
+              method: payload[:method],
+              path: payload[:path],
+              status: payload[:status]
+            }
+          )
+        end
+
+        # Subscribe to view rendering
+        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("render_template.action_view") do |name, started, finished, unique_id, payload|
+          @events << Models::TimelineEvent.new(
+            name: "Render: #{payload[:identifier]}",
+            started_at: started,
+            finished_at: finished,
+            payload: {
+              identifier: payload[:identifier],
+              layout: payload[:layout]
+            }
+          )
+        end
+
+        # Subscribe to partial rendering
+        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("render_partial.action_view") do |name, started, finished, unique_id, payload|
+          @events << Models::TimelineEvent.new(
+            name: "Partial: #{payload[:identifier]}",
+            started_at: started,
+            finished_at: finished,
+            payload: {
+              identifier: payload[:identifier]
+            }
+          )
+        end
+      end
+
+      def collect
+        # Unsubscribe from all notifications
+        @subscriptions.each { |sub| ActiveSupport::Notifications.unsubscribe(sub) }
+
+        data = {
+          total_events: @events.size,
+          total_duration: @events.sum(&:duration).round(2),
+          events: @events.map(&:to_h)
+        }
+
+        store_data(data)
+      end
+
+      def toolbar_summary
+        duration = @events.sum(&:duration).round(2)
+
+        {
+          text: "#{@events.size} events (#{duration}ms)",
+          color: "blue"
+        }
+      end
+    end
+  end
+end

data/lib/profiler/collectors/request_collector.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "base_collector"
+
+module Profiler
+  module Collectors
+    class RequestCollector < BaseCollector
+      def icon
+        "🌐"
+      end
+
+      def priority
+        10
+      end
+
+      def tab_config
+        {
+          key: "request",
+          label: "Request",
+          icon: icon,
+          priority: priority,
+          enabled: true,
+          default_active: false
+        }
+      end
+
+      def collect
+        data = {
+          path: @profile.path,
+          method: @profile.method,
+          status: @profile.status,
+          duration: @profile.duration,
+          memory: @profile.memory,
+          params: @profile.params,
+          headers: @profile.headers,
+          response_headers: @profile.response_headers,
+          request_body: @profile.request_body,
+          request_body_encoding: @profile.request_body_encoding,
+          response_body: @profile.response_body,
+          response_body_encoding: @profile.response_body_encoding,
+          started_at: @profile.started_at&.iso8601,
+          finished_at: @profile.finished_at&.iso8601
+        }
+
+        store_data(data)
+      end
+
+      def toolbar_summary
+        status_color = case @profile.status
+                      when 200..299 then "green"
+                      when 300..399 then "blue"
+                      when 400..499 then "orange"
+                      when 500..599 then "red"
+                      else "gray"
+                      end
+
+        {
+          text: "#{@profile.method} #{@profile.status}",
+          color: status_color,
+          duration: @profile.duration,
+          memory: format_memory(@profile.memory)
+        }
+      end
+
+      private
+
+      def format_memory(bytes)
+        return "0 B" unless bytes
+
+        if bytes < 1024
+          "#{bytes} B"
+        elsif bytes < 1024 * 1024
+          "#{(bytes / 1024.0).round(2)} KB"
+        else
+          "#{(bytes / 1024.0 / 1024.0).round(2)} MB"
+        end
+      end
+    end
+  end
+end

data/lib/profiler/collectors/view_collector.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "base_collector"
+
+module Profiler
+  module Collectors
+    class ViewCollector < BaseCollector
+      def initialize(profile)
+        super
+        @views = []
+        @partials = []
+        @subscriptions = []
+      end
+
+      def icon
+        "👁️"
+      end
+
+      def priority
+        40
+      end
+
+      def tab_config
+        {
+          key: "view",
+          label: "Views",
+          icon: icon,
+          priority: priority,
+          enabled: true,
+          default_active: false
+        }
+      end
+
+      def subscribe
+        return unless defined?(ActiveSupport::Notifications)
+
+        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("render_template.action_view") do |name, started, finished, unique_id, payload|
+          duration = ((finished - started) * 1000).round(2)
+          @views << {
+            identifier: payload[:identifier],
+            layout: payload[:layout],
+            duration: duration
+          }
+        end
+
+        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("render_partial.action_view") do |name, started, finished, unique_id, payload|
+          duration = ((finished - started) * 1000).round(2)
+          @partials << {
+            identifier: payload[:identifier],
+            duration: duration
+          }
+        end
+      end
+
+      def collect
+        @subscriptions.each { |sub| ActiveSupport::Notifications.unsubscribe(sub) }
+
+        data = {
+          views: @views,
+          partials: @partials,
+          total_views: @views.size,
+          total_partials: @partials.size,
+          total_duration: (@views + @partials).sum { |v| v[:duration] }.round(2)
+        }
+
+        store_data(data)
+      end
+
+      def toolbar_summary
+        total_duration = (@views + @partials).sum { |v| v[:duration] }.round(2)
+
+        {
+          text: "#{@views.size} views, #{@partials.size} partials (#{total_duration}ms)",
+          color: "purple"
+        }
+      end
+    end
+  end
+end

data/lib/profiler/configuration.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Profiler
+  class Configuration
+    attr_accessor :enabled, :storage, :storage_options, :collectors,
+                  :skip_paths, :slow_query_threshold, :max_queries_warning,
+                  :track_memory, :memory_warning_threshold,
+                  :mcp_enabled, :mcp_transport, :mcp_port,
+                  :authorization_mode, :max_profiles, :extension_cors_enabled,
+                  :track_ajax, :ajax_skip_paths,
+                  :track_http, :slow_http_threshold, :http_skip_hosts,
+                  :track_jobs
+
+    attr_reader :authorize_block
+
+    def initialize
+      @enabled = false
+      @storage = :memory
+      @storage_options = {}
+      @collectors = []
+      @skip_paths = [%r{^/_profiler}, /\.well-known/, /favicon\.ico/, /manifest\.json/]
+      @slow_query_threshold = 100 # milliseconds
+      @max_queries_warning = 50
+      @track_memory = true
+      @memory_warning_threshold = 100 * 1024 * 1024 # 100 MB
+      @mcp_enabled = false
+      @mcp_transport = :stdio
+      @mcp_port = 3001
+      @authorization_mode = :allow_all
+      @authorize_block = nil
+      @max_profiles = 100
+      @extension_cors_enabled = true
+      @track_ajax = true
+      @ajax_skip_paths = [/^\/_profiler/]
+      @track_http = true
+      @slow_http_threshold = 500 # milliseconds
+      @http_skip_hosts = []
+      @track_jobs = true
+    end
+
+    def authorize_with(&block)
+      @authorize_block = block
+    end
+
+    def authorized?(request)
+      case @authorization_mode
+      when :allow_all
+        true
+      when :allow_authorized
+        @authorize_block ? @authorize_block.call(request) : false
+      else
+        false
+      end
+    end
+
+    def storage_backend
+      @storage_backend ||= build_storage_backend
+    end
+
+    private
+
+    def build_storage_backend
+      case @storage
+      when :memory
+        require_relative "storage/memory_store"
+        Storage::MemoryStore.new(@storage_options)
+      when :file
+        require_relative "storage/file_store"
+        Storage::FileStore.new(@storage_options)
+      when :redis
+        require_relative "storage/redis_store"
+        Storage::RedisStore.new(@storage_options)
+      when :sqlite
+        require_relative "storage/sqlite_store"
+        Storage::SqliteStore.new(@storage_options)
+      else
+        raise Error, "Unknown storage backend: #{@storage}"
+      end
+    end
+  end
+end

data/lib/profiler/engine.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+
+module Profiler
+  class Engine < ::Rails::Engine
+    isolate_namespace Profiler
+
+    config.profiler = ActiveSupport::OrderedOptions.new
+
+    initializer "profiler.helpers" do
+      ActiveSupport.on_load(:action_controller) do
+        helper Profiler::Engine.helpers
+      end
+    end
+  end
+end

data/lib/profiler/instrumentation/active_job_instrumentation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Instrumentation
+    module ActiveJobInstrumentation
+      extend ActiveSupport::Concern
+
+      included do
+        around_perform do |job, block|
+          Profiler::JobProfiler.profile(
+            job_class: job.class.name,
+            job_id: job.job_id,
+            queue: job.queue_name,
+            arguments: job.arguments,
+            executions: job.executions,
+            &block
+          )
+        end
+      end
+    end
+  end
+end

data/lib/profiler/instrumentation/net_http_instrumentation.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "base64"
+require "zlib"
+require "stringio"
+
+module Profiler
+  module Instrumentation
+    module NetHttpInstrumentation
+      module RequestPatch
+        def request(req, body = nil, &block)
+          collector = Thread.current[:profiler_http_collector]
+          return super unless collector
+          # Re-entrancy guard: Net::HTTP#request calls itself recursively when
+          # the connection isn't started yet. Only record the outermost call.
+          return super if Thread.current[:profiler_http_recording]
+
+          host = address.to_s
+          return super if NetHttpInstrumentation.skip_host?(host)
+
+          url = build_url(host, port, req.path, use_ssl?)
+          req_body = req.body.to_s
+          req_headers = req.to_hash.transform_values { |v| v.join(", ") }
+          t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          Thread.current[:profiler_http_recording] = true
+
+          response = super
+
+          duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(2)
+          resp_body_raw = response.body.to_s
+          resp_content_encoding = response["content-encoding"].to_s.strip.downcase
+          resp_body = NetHttpInstrumentation.decompress_body(resp_body_raw, resp_content_encoding)
+          resp_content_type = response["content-type"].to_s
+          req_content_type = req["content-type"].to_s
+
+          processed_req = req_body.empty? ? { body: nil, encoding: "text" } : NetHttpInstrumentation.process_body(req_body, req_content_type)
+          processed_resp = NetHttpInstrumentation.process_body(resp_body, resp_content_type)
+
+          t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          collector.record_request(
+            url: url,
+            method: req.method,
+            status: response.code.to_i,
+            duration: duration,
+            request_headers: req_headers,
+            request_body: processed_req[:body],
+            request_body_encoding: processed_req[:encoding],
+            request_size: req_body.bytesize,
+            response_headers: response.to_hash.transform_values { |v| v.join(", ") },
+            response_body: processed_resp[:body],
+            response_body_encoding: processed_resp[:encoding],
+            response_size: resp_body_raw.bytesize,
+            backtrace: NetHttpInstrumentation.extract_backtrace
+          )
+
+          fg = Thread.current[:profiler_flamegraph_collector]
+          fg&.record_http_event(started_at: t0, finished_at: t1, url: url, method: req.method, status: response.code.to_i)
+
+          response
+        rescue => e
+          if defined?(t0) && t0
+            duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(2)
+            collector&.record_request(
+              url: url,
+              method: req.method,
+              status: 0,
+              duration: duration,
+              request_headers: defined?(req_headers) ? req_headers : {},
+              request_body: nil,
+              request_body_encoding: "text",
+              request_size: 0,
+              response_headers: {},
+              response_body: nil,
+              response_body_encoding: "text",
+              response_size: 0,
+              backtrace: NetHttpInstrumentation.extract_backtrace,
+              error: e.message
+            )
+          end
+          raise
+        ensure
+          Thread.current[:profiler_http_recording] = false
+        end
+
+        private
+
+        def build_url(host, port, path, ssl)
+          scheme = ssl ? "https" : "http"
+          standard_port = (ssl && port == 443) || (!ssl && port == 80)
+          standard_port ? "#{scheme}://#{host}#{path}" : "#{scheme}://#{host}:#{port}#{path}"
+        end
+      end
+
+      SKIP_HOSTS = %w[127.0.0.1 localhost ::1].freeze
+
+      TEXT_BODY_LIMIT   = 512 * 1024 # 512 KB
+      BINARY_BODY_LIMIT = 256 * 1024 # 256 KB (before base64)
+
+      TEXT_CONTENT_TYPES   = /\A(text\/|application\/(json|xml|xhtml|javascript|x-www-form-urlencoded)|image\/svg)/i
+      BINARY_CONTENT_TYPES = /\A(image\/|application\/pdf|application\/octet-stream|application\/zip|audio\/|video\/)/i
+
+      def self.install!
+        return if @installed
+        Net::HTTP.prepend(RequestPatch)
+        @installed = true
+      end
+
+      def self.skip_host?(host)
+        SKIP_HOSTS.include?(host) ||
+          Profiler.configuration.http_skip_hosts.any? { |p| host.match?(p) }
+      end
+
+      def self.decompress_body(body, content_encoding)
+        return body if content_encoding.empty? || body.nil? || body.empty?
+
+        case content_encoding
+        when "gzip", "x-gzip"
+          Zlib::GzipReader.new(StringIO.new(body)).read
+        when "deflate"
+          Zlib::Inflate.inflate(body)
+        else
+          body
+        end
+      rescue StandardError
+        body
+      end
+
+      def self.process_body(body, content_type)
+        return { body: nil, encoding: "text" } if body.nil? || body.empty?
+
+        mime = content_type.split(";").first.to_s.strip
+
+        if mime.match?(BINARY_CONTENT_TYPES)
+          truncated = body.byteslice(0, BINARY_BODY_LIMIT) || ""
+          { body: Base64.strict_encode64(truncated.b), encoding: "base64" }
+        else
+          # Text (including unknown content types)
+          text = body.encode("UTF-8", invalid: :replace, undef: :replace, replace: "?")
+          { body: text.byteslice(0, TEXT_BODY_LIMIT), encoding: "text" }
+        end
+      end
+
+      def self.extract_backtrace
+        caller_locations(5, 15)
+          .reject { |l| l.path.to_s.include?("net/http") || l.path.to_s.include?("profiler/instrumentation") }
+          .first(5)
+          .map { |l| "#{l.path}:#{l.lineno}:in `#{l.label}`" }
+      end
+    end
+  end
+end

data/lib/profiler/instrumentation/sidekiq_middleware.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Instrumentation
+    class SidekiqMiddleware
+      def call(worker, job, queue, &block)
+        Profiler::JobProfiler.profile(
+          job_class: job["class"],
+          job_id: job["jid"],
+          queue: queue,
+          arguments: job["args"],
+          executions: job["retry_count"].to_i,
+          &block
+        )
+      end
+    end
+  end
+end

data/lib/profiler/job_profiler.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "models/profile"
+require_relative "collectors/job_collector"
+require_relative "collectors/database_collector"
+require_relative "collectors/cache_collector"
+require_relative "collectors/http_collector"
+
+module Profiler
+  class JobProfiler
+    JOB_COLLECTOR_CLASSES = [
+      Collectors::DatabaseCollector,
+      Collectors::CacheCollector,
+      Collectors::HttpCollector
+    ].freeze
+
+    def self.profile(job_class:, job_id:, queue:, arguments:, executions:, &block)
+      return block.call unless Profiler.enabled? && Profiler.configuration.track_jobs
+
+      new(
+        job_class: job_class,
+        job_id: job_id,
+        queue: queue,
+        arguments: arguments,
+        executions: executions
+      ).run(&block)
+    end
+
+    def initialize(job_class:, job_id:, queue:, arguments:, executions:)
+      @job_class = job_class
+      @job_id = job_id
+      @queue = queue
+      @arguments = arguments
+      @executions = executions
+    end
+
+    def run(&block)
+      profile = Models::Profile.new
+      profile.profile_type = "job"
+      profile.path = @job_class
+      profile.method = "JOB"
+
+      job_collector = Collectors::JobCollector.new(profile, {
+        job_class: @job_class,
+        job_id: @job_id,
+        queue: @queue,
+        arguments: sanitize_arguments(@arguments),
+        executions: @executions
+      })
+
+      collectors = [job_collector] + JOB_COLLECTOR_CLASSES.map { |klass| klass.new(profile) }
+      collectors.each { |c| c.subscribe if c.respond_to?(:subscribe) }
+
+      memory_before = current_memory if Profiler.configuration.track_memory
+
+      job_status = "completed"
+      error_message = nil
+
+      begin
+        result = block.call
+        result
+      rescue => e
+        job_status = "failed"
+        error_message = "#{e.class}: #{e.message}"
+        raise
+      ensure
+        if Profiler.configuration.track_memory
+          profile.memory = current_memory - memory_before
+        end
+
+        job_collector.update_status(job_status, error_message)
+        profile.finish(job_status == "completed" ? 200 : 500)
+
+        collectors.each do |collector|
+          begin
+            collector.collect if collector.respond_to?(:collect)
+            profile.add_collector_metadata(collector)
+          rescue => e
+            warn "Profiler JobProfiler: Collector #{collector.class} failed: #{e.message}"
+          end
+        end
+
+        Profiler.storage.save(profile.token, profile)
+      end
+    end
+
+    private
+
+    def sanitize_arguments(args)
+      return [] unless args
+
+      args.map do |arg|
+        case arg
+        when String then arg.length > 200 ? "#{arg[0, 200]}..." : arg
+        when Numeric, TrueClass, FalseClass, NilClass then arg
+        else
+          inspected = arg.inspect
+          inspected.length > 200 ? "#{inspected[0, 200]}..." : inspected
+        end
+      rescue
+        arg.to_s
+      end
+    end
+
+    def current_memory
+      return 0 unless defined?(GC.stat)
+
+      stats = GC.stat
+      if stats.key?(:total_allocated_size)
+        stats[:total_allocated_size]
+      elsif stats.key?(:total_allocated_objects)
+        stats[:total_allocated_objects] * 40
+      else
+        0
+      end
+    end
+  end
+end