rails-profiler 0.1.4

data/lib/profiler/collectors/cache_collector.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "base_collector"
+
+module Profiler
+  module Collectors
+    class CacheCollector < BaseCollector
+      def initialize(profile)
+        super
+        @cache_reads = []
+        @cache_writes = []
+        @cache_deletes = []
+        @subscriptions = []
+      end
+
+      def icon
+        "💾"
+      end
+
+      def priority
+        50
+      end
+
+      def tab_config
+        {
+          key: "cache",
+          label: "Cache",
+          icon: icon,
+          priority: priority,
+          enabled: true,
+          default_active: false
+        }
+      end
+
+      def subscribe
+        return unless defined?(ActiveSupport::Notifications)
+
+        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("cache_read.active_support") do |name, started, finished, unique_id, payload|
+          duration = ((finished - started) * 1000).round(2)
+          @cache_reads << {
+            key: payload[:key],
+            hit: payload[:hit],
+            duration: duration
+          }
+        end
+
+        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("cache_write.active_support") do |name, started, finished, unique_id, payload|
+          duration = ((finished - started) * 1000).round(2)
+          @cache_writes << {
+            key: payload[:key],
+            duration: duration
+          }
+        end
+
+        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("cache_delete.active_support") do |name, started, finished, unique_id, payload|
+          duration = ((finished - started) * 1000).round(2)
+          @cache_deletes << {
+            key: payload[:key],
+            duration: duration
+          }
+        end
+      end
+
+      def collect
+        @subscriptions.each { |sub| ActiveSupport::Notifications.unsubscribe(sub) }
+
+        hits = @cache_reads.count { |r| r[:hit] }
+        misses = @cache_reads.count { |r| !r[:hit] }
+
+        data = {
+          reads: @cache_reads,
+          writes: @cache_writes,
+          deletes: @cache_deletes,
+          total_reads: @cache_reads.size,
+          total_writes: @cache_writes.size,
+          total_deletes: @cache_deletes.size,
+          hits: hits,
+          misses: misses,
+          hit_rate: @cache_reads.empty? ? 0 : (hits.to_f / @cache_reads.size * 100).round(2)
+        }
+
+        store_data(data)
+      end
+
+      def toolbar_summary
+        hits = @cache_reads.count { |r| r[:hit] }
+        total = @cache_reads.size
+
+        {
+          text: "#{hits}/#{total} hits",
+          color: "cyan"
+        }
+      end
+    end
+  end
+end

data/lib/profiler/collectors/database_collector.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "base_collector"
+require_relative "../models/sql_query"
+
+module Profiler
+  module Collectors
+    class DatabaseCollector < BaseCollector
+      def initialize(profile)
+        super
+        @queries = []
+        @subscription = nil
+      end
+
+      def icon
+        "🗄️"
+      end
+
+      def priority
+        20
+      end
+
+      def tab_config
+        {
+          key: "database",
+          label: "Database",
+          icon: icon,
+          priority: priority,
+          enabled: true,
+          default_active: true
+        }
+      end
+
+      def subscribe
+        return unless defined?(ActiveSupport::Notifications)
+
+        @subscription = ActiveSupport::Notifications.monotonic_subscribe("sql.active_record") do |name, started, finished, unique_id, payload|
+          duration = ((finished - started) * 1000).round(2) # milliseconds
+
+          # Skip schema queries and internal Rails queries
+          next if payload[:name] == "SCHEMA"
+          next if payload[:sql] =~ /^(BEGIN|COMMIT|ROLLBACK|SAVEPOINT)/i
+
+          query = Models::SqlQuery.new(
+            sql: payload[:sql],
+            duration: duration,
+            binds: extract_binds(payload[:binds]),
+            name: payload[:name],
+            connection: payload[:connection],
+            backtrace: extract_backtrace
+          )
+
+          @queries << query
+        end
+      end
+
+      def collect
+        # Unsubscribe from notifications
+        ActiveSupport::Notifications.unsubscribe(@subscription) if @subscription
+
+        data = {
+          total_queries: @queries.size,
+          total_duration: @queries.sum(&:duration).round(2),
+          slow_queries: @queries.select { |q| q.slow?(Profiler.configuration.slow_query_threshold) }.size,
+          cached_queries: @queries.count(&:cached?),
+          queries: @queries.map(&:to_h)
+        }
+
+        store_data(data)
+      end
+
+      def toolbar_summary
+        total = @queries.size
+        slow = @queries.select { |q| q.slow?(Profiler.configuration.slow_query_threshold) }.size
+        duration = @queries.sum(&:duration).round(2)
+
+        color = if slow > 0
+                  "red"
+                elsif total > Profiler.configuration.max_queries_warning
+                  "orange"
+                else
+                  "green"
+                end
+
+        {
+          text: "#{total} queries (#{duration}ms)",
+          color: color,
+          slow_queries: slow
+        }
+      end
+
+      private
+
+      def extract_binds(binds)
+        return [] unless binds
+
+        binds.map do |bind|
+          if bind.respond_to?(:value)
+            bind.value
+          else
+            bind
+          end
+        end
+      end
+
+      def extract_backtrace
+        caller_locations(5, 10)
+          .reject { |loc| loc.path.include?("active_record") }
+          .map { |loc| "#{loc.path}:#{loc.lineno}:in `#{loc.label}`" }
+      end
+    end
+  end
+end

data/lib/profiler/collectors/dump_collector.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative "base_collector"
+require "pp"
+
+module Profiler
+  module Collectors
+    class DumpCollector < BaseCollector
+      def icon
+        "🔍"
+      end
+
+      def priority
+        15
+      end
+
+      def name
+        "dump"
+      end
+
+      def tab_config
+        {
+          key: "dump",
+          label: "Dumps",
+          icon: icon,
+          priority: priority,
+          enabled: true,
+          default_active: false
+        }
+      end
+
+      def collect
+        dumps = Thread.current[:profiler_dumps] || []
+
+        formatted_dumps = dumps.map do |dump|
+          {
+            value: dump[:value],
+            formatted: format_value(dump[:value]),
+            file: dump[:file],
+            line: dump[:line],
+            label: dump[:label],
+            timestamp: dump[:timestamp]
+          }
+        end
+
+        store_data({
+          count: formatted_dumps.size,
+          dumps: formatted_dumps
+        })
+
+        # Clear dumps for next request
+        Thread.current[:profiler_dumps] = []
+      end
+
+      def toolbar_summary
+        count = @data[:count] || 0
+        color = count > 0 ? "blue" : "gray"
+
+        {
+          text: "#{count} dump#{count != 1 ? 's' : ''}",
+          color: color
+        }
+      end
+
+      private
+
+      def format_value(value)
+        case value
+        when String
+          value.inspect
+        when Array, Hash
+          PP.pp(value, +"", 120).strip
+        when NilClass
+          "nil"
+        when TrueClass, FalseClass
+          value.to_s
+        when Numeric
+          value.to_s
+        else
+          # For objects, show class and instance variables
+          formatted = "#<#{value.class}:0x#{value.object_id.to_s(16)}"
+          ivars = value.instance_variables
+          if ivars.any?
+            formatted += " "
+            formatted += ivars.map do |ivar|
+              ivar_value = value.instance_variable_get(ivar)
+              "#{ivar}=#{ivar_value.inspect}"
+            end.join(", ")
+          end
+          formatted += ">"
+          formatted
+        end
+      rescue => e
+        "[Error formatting value: #{e.message}]"
+      end
+    end
+  end
+end

data/lib/profiler/collectors/flamegraph_collector.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require_relative "base_collector"
+require_relative "../models/timeline_event"
+
+module Profiler
+  module Collectors
+    class FlameGraphCollector < BaseCollector
+      def initialize(profile)
+        super
+        @events = []
+        @subscriptions = []
+      end
+
+      def icon
+        "🔥"
+      end
+
+      def priority
+        30
+      end
+
+      def tab_config
+        {
+          key: "flamegraph",
+          label: "Flame Graph",
+          icon: icon,
+          priority: priority,
+          enabled: true,
+          default_active: false
+        }
+      end
+
+      def subscribe
+        return unless defined?(ActiveSupport::Notifications)
+
+        Thread.current[:profiler_flamegraph_collector] = self
+
+        # Controller action
+        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("process_action.action_controller") do |_name, started, finished, _unique_id, payload|
+          @events << Models::TimelineEvent.new(
+            name: "#{payload[:controller]}##{payload[:action]}",
+            started_at: started,
+            finished_at: finished,
+            category: "controller",
+            payload: {
+              controller: payload[:controller],
+              action: payload[:action],
+              format: payload[:format],
+              method: payload[:method],
+              path: payload[:path],
+              status: payload[:status]
+            }
+          )
+        end
+
+        # Template rendering
+        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("render_template.action_view") do |_name, started, finished, _unique_id, payload|
+          identifier = short_identifier(payload[:identifier])
+          @events << Models::TimelineEvent.new(
+            name: "Render: #{identifier}",
+            started_at: started,
+            finished_at: finished,
+            category: "view",
+            payload: { identifier: identifier, layout: payload[:layout] }
+          )
+        end
+
+        # Partial rendering
+        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("render_partial.action_view") do |_name, started, finished, _unique_id, payload|
+          identifier = short_identifier(payload[:identifier])
+          @events << Models::TimelineEvent.new(
+            name: "Partial: #{identifier}",
+            started_at: started,
+            finished_at: finished,
+            category: "partial",
+            payload: { identifier: identifier }
+          )
+        end
+
+        # SQL queries
+        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("sql.active_record") do |_name, started, finished, _unique_id, payload|
+          next if payload[:name] == "SCHEMA"
+          next if payload[:sql] =~ /^(BEGIN|COMMIT|ROLLBACK|SAVEPOINT)/i
+
+          sql = payload[:sql].to_s
+          @events << Models::TimelineEvent.new(
+            name: sql.length > 80 ? "#{sql[0, 80]}..." : sql,
+            started_at: started,
+            finished_at: finished,
+            category: "sql",
+            payload: { sql: sql, name: payload[:name] }
+          )
+        end
+
+        # Cache operations
+        %w[cache_read.active_support cache_write.active_support cache_delete.active_support].each do |event_name|
+          @subscriptions << ActiveSupport::Notifications.monotonic_subscribe(event_name) do |name, started, finished, _unique_id, payload|
+            op = name.split(".").first.sub("cache_", "")
+            key = payload[:key].to_s
+            @events << Models::TimelineEvent.new(
+              name: "cache_#{op}: #{key.length > 60 ? "#{key[0, 60]}..." : key}",
+              started_at: started,
+              finished_at: finished,
+              category: "cache",
+              payload: { operation: op, key: key, hit: payload[:hit] }
+            )
+          end
+        end
+      end
+
+      # Called by NetHttpInstrumentation to record outbound HTTP events
+      def record_http_event(started_at:, finished_at:, url:, method:, status:)
+        @events << Models::TimelineEvent.new(
+          name: "HTTP #{method} #{url}",
+          started_at: started_at,
+          finished_at: finished_at,
+          category: "http",
+          payload: { url: url, method: method, status: status }
+        )
+      end
+
+      def collect
+        @subscriptions.each { |sub| ActiveSupport::Notifications.unsubscribe(sub) }
+        Thread.current[:profiler_flamegraph_collector] = nil
+
+        root_events = build_hierarchy(@events)
+
+        store_data({
+          total_events: @events.size,
+          total_duration: @events.empty? ? 0 : @events.map(&:duration).sum.round(2),
+          root_events: root_events.map(&:to_h)
+        })
+      end
+
+      def toolbar_summary
+        {
+          text: "#{@events.size} events",
+          color: "blue"
+        }
+      end
+
+      private
+
+      def build_hierarchy(events)
+        return [] if events.empty?
+
+        # Sort by started_at ASC, then by duration DESC (longest first = parents first)
+        sorted = events.sort_by { |e| [e.started_at, -e.duration] }
+
+        # Stack-based nesting: each stack entry is a potential parent
+        roots = []
+        stack = []
+
+        sorted.each do |event|
+          # Pop stack entries that have finished before this event starts
+          stack.pop while stack.any? && stack.last.finished_at <= event.started_at
+
+          # Pop stack entries where this event doesn't fit inside
+          stack.pop while stack.any? && event.finished_at > stack.last.finished_at
+
+          if stack.any?
+            stack.last.add_child(event)
+          else
+            roots << event
+          end
+
+          stack.push(event)
+        end
+
+        roots
+      end
+
+      def short_identifier(identifier)
+        return identifier.to_s unless identifier.to_s.include?("/")
+
+        parts = identifier.to_s.split("/")
+        parts.last(2).join("/")
+      end
+    end
+  end
+end

data/lib/profiler/collectors/http_collector.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "base_collector"
+require_relative "../instrumentation/net_http_instrumentation"
+
+module Profiler
+  module Collectors
+    class HttpCollector < BaseCollector
+      def initialize(profile)
+        super
+        @requests = []
+      end
+
+      def icon
+        "🔗"
+      end
+
+      def priority
+        35
+      end
+
+      def tab_config
+        {
+          key: "http",
+          label: "Outbound HTTP",
+          icon: icon,
+          priority: priority,
+          enabled: true,
+          default_active: false
+        }
+      end
+
+      def subscribe
+        return unless Profiler.configuration.track_http
+
+        Profiler::Instrumentation::NetHttpInstrumentation.install!
+        Thread.current[:profiler_http_collector] = self
+      end
+
+      def collect
+        Thread.current[:profiler_http_collector] = nil
+
+        threshold = Profiler.configuration.slow_http_threshold
+
+        store_data(
+          total_requests: @requests.size,
+          total_duration: @requests.sum { |r| r[:duration] }.round(2),
+          slow_requests: @requests.count { |r| r[:duration] >= threshold },
+          error_requests: @requests.count { |r| r[:status] >= 400 || r[:status] == 0 },
+          by_host: group_by_host,
+          by_status: group_by_status,
+          requests: @requests.map { |r| r.transform_keys(&:to_s) }
+        )
+      end
+
+      def record_request(payload)
+        @requests << payload
+      end
+
+      def toolbar_summary
+        total = @requests.size
+        return { text: "0 HTTP", color: "green" } if total == 0
+
+        threshold = Profiler.configuration.slow_http_threshold
+        errors = @requests.count { |r| r[:status] >= 400 || r[:status] == 0 }
+        slow = @requests.count { |r| r[:duration] >= threshold }
+        duration = @requests.sum { |r| r[:duration] }.round(2)
+
+        color = if errors > 0 || slow > 0
+                  "red"
+                elsif total > 10
+                  "orange"
+                else
+                  "green"
+                end
+
+        { text: "#{total} HTTP (#{duration}ms)", color: color }
+      end
+
+      private
+
+      def group_by_host
+        @requests.each_with_object(Hash.new(0)) do |req, h|
+          host = begin
+            URI.parse(req[:url]).host || "unknown"
+          rescue URI::InvalidURIError
+            "unknown"
+          end
+          h[host] += 1
+        end
+      end
+
+      def group_by_status
+        @requests.each_with_object(Hash.new(0)) do |req, h|
+          status = req[:status]
+          key = if status == 0
+                  "error"
+                elsif status < 300
+                  "2xx"
+                elsif status < 400
+                  "3xx"
+                elsif status < 500
+                  "4xx"
+                else
+                  "5xx"
+                end
+          h[key] += 1
+        end
+      end
+    end
+  end
+end

data/lib/profiler/collectors/job_collector.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "base_collector"
+
+module Profiler
+  module Collectors
+    class JobCollector < BaseCollector
+      def initialize(profile, job_data = {})
+        super(profile)
+        @job_data = job_data.merge(status: "running")
+      end
+
+      def icon
+        "⚙️"
+      end
+
+      def priority
+        5
+      end
+
+      def tab_config
+        {
+          key: "job",
+          label: "Job",
+          icon: icon,
+          priority: priority,
+          enabled: true,
+          default_active: true
+        }
+      end
+
+      def update_status(status, error_message = nil)
+        @job_data[:status] = status
+        @job_data[:error] = error_message if error_message
+      end
+
+      def collect
+        store_data(@job_data)
+      end
+
+      def has_data?
+        @job_data.any?
+      end
+
+      def toolbar_summary
+        { text: @job_data[:job_class].to_s, color: @job_data[:status] == "failed" ? "red" : "green" }
+      end
+    end
+  end
+end