rails_error_dashboard 0.2.4 → 0.3.1

data/lib/rails_error_dashboard/queries/job_health_summary.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Aggregate job queue health stats from system_health across all errors
+    # Scans error_logs system_health JSON, extracts job_queue data per error
+    class JobHealthSummary
+      def self.call(days = 30, application_id: nil)
+        new(days, application_id: application_id).call
+      end
+
+      def initialize(days = 30, application_id: nil)
+        @days = days
+        @application_id = application_id
+        @start_date = days.days.ago
+      end
+
+      def call
+        {
+          entries: aggregated_entries
+        }
+      end
+
+      private
+
+      def base_query
+        scope = ErrorLog.where("occurred_at >= ?", @start_date)
+                        .where.not(system_health: nil)
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
+      end
+
+      def aggregated_entries
+        results = []
+
+        base_query.select(:id, :system_health, :occurred_at).find_each(batch_size: 500) do |error_log|
+          health = parse_system_health(error_log.system_health)
+          next if health.blank?
+
+          job_queue = health["job_queue"]
+          next if job_queue.blank?
+
+          adapter = job_queue["adapter"]
+          next if adapter.blank?
+
+          results << build_entry(error_log, job_queue, adapter)
+        end
+
+        # Sort by failed count descending (worst first)
+        results.sort_by { |r| -(r[:failed] || 0) }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] JobHealthSummary query failed: #{e.class}: #{e.message}")
+        []
+      end
+
+      def build_entry(error_log, job_queue, adapter)
+        entry = {
+          error_id: error_log.id,
+          adapter: adapter,
+          occurred_at: error_log.occurred_at
+        }
+
+        case adapter
+        when "sidekiq"
+          entry.merge!(
+            enqueued: job_queue["enqueued"],
+            processed: job_queue["processed"],
+            failed: job_queue["failed"],
+            dead: job_queue["dead"],
+            scheduled: job_queue["scheduled"],
+            retry: job_queue["retry"],
+            workers: job_queue["workers"]
+          )
+        when "solid_queue"
+          entry.merge!(
+            ready: job_queue["ready"],
+            scheduled: job_queue["scheduled"],
+            claimed: job_queue["claimed"],
+            failed: job_queue["failed"],
+            blocked: job_queue["blocked"]
+          )
+        when "good_job"
+          entry.merge!(
+            queued: job_queue["queued"],
+            errored: job_queue["errored"],
+            finished: job_queue["finished"]
+          )
+        end
+
+        entry
+      end
+
+      def parse_system_health(raw)
+        return nil if raw.blank?
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/n_plus_one_summary.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Aggregate N+1 query patterns from breadcrumbs across all errors
+    # Scans error_logs breadcrumbs JSON, runs NplusOneDetector per error, and groups by fingerprint
+    class NplusOneSummary
+      def self.call(days = 30, application_id: nil)
+        new(days, application_id: application_id).call
+      end
+
+      def initialize(days = 30, application_id: nil)
+        @days = days
+        @application_id = application_id
+        @start_date = days.days.ago
+      end
+
+      def call
+        {
+          patterns: aggregated_patterns
+        }
+      end
+
+      private
+
+      def base_query
+        scope = ErrorLog.where("occurred_at >= ?", @start_date)
+                        .where.not(breadcrumbs: nil)
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
+      end
+
+      def aggregated_patterns
+        results = {}
+
+        base_query.select(:id, :breadcrumbs, :occurred_at).find_each(batch_size: 500) do |error_log|
+          crumbs = parse_breadcrumbs(error_log.breadcrumbs)
+          next if crumbs.empty?
+
+          patterns = Services::NplusOneDetector.call(crumbs)
+          next if patterns.empty?
+
+          patterns.each do |pattern|
+            fingerprint = pattern[:fingerprint]
+
+            if results[fingerprint]
+              results[fingerprint][:count] += pattern[:count]
+              results[fingerprint][:total_duration_ms] += pattern[:total_duration_ms]
+              results[fingerprint][:error_ids] << error_log.id
+              results[fingerprint][:last_seen] = [ results[fingerprint][:last_seen], error_log.occurred_at ].compact.max
+            else
+              results[fingerprint] = {
+                fingerprint: fingerprint,
+                sample_query: pattern[:sample_query],
+                count: pattern[:count],
+                error_ids: [ error_log.id ],
+                total_duration_ms: pattern[:total_duration_ms],
+                last_seen: error_log.occurred_at
+              }
+            end
+          end
+        end
+
+        results.values.each do |r|
+          r[:error_ids] = r[:error_ids].uniq
+          r[:error_count] = r[:error_ids].size
+          r[:total_duration_ms] = r[:total_duration_ms].round(2)
+        end
+        results.values.sort_by { |r| -r[:count] }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] NplusOneSummary query failed: #{e.class}: #{e.message}")
+        []
+      end
+
+      def parse_breadcrumbs(raw)
+        return [] if raw.blank?
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        []
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/breadcrumb_collector.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Pure service: Collect breadcrumbs (request activity trail) for error context
+    #
+    # Uses a thread-local ring buffer to capture events during a request lifecycle.
+    # Thread.current isolation means no mutex/lock is needed.
+    #
+    # SAFETY RULES (HOST_APP_SAFETY.md):
+    # - Every public method wrapped in rescue => e; nil
+    # - Never raise, never block, never allocate large objects
+    # - Messages truncated to 500 chars, metadata values to 200 chars
+    # - Ring buffer has fixed max size (no unbounded growth)
+    class BreadcrumbCollector
+      THREAD_KEY = :red_breadcrumbs
+      MAX_MESSAGE_LENGTH = 500
+      MAX_METADATA_VALUE_LENGTH = 200
+      MAX_METADATA_KEYS = 10
+
+      # Fixed-size ring buffer — O(1) append, wraps around when full
+      class RingBuffer
+        def initialize(max_size)
+          @max_size = max_size
+          @buffer = Array.new(max_size)
+          @write_pos = 0
+          @count = 0
+        end
+
+        def add(entry)
+          @buffer[@write_pos] = entry
+          @write_pos = (@write_pos + 1) % @max_size
+          @count += 1 if @count < @max_size
+        end
+
+        def to_a
+          return [] if @count == 0
+
+          if @count < @max_size
+            @buffer[0...@count]
+          else
+            # Buffer has wrapped — read from write_pos to end, then start to write_pos
+            @buffer[@write_pos...@max_size] + @buffer[0...@write_pos]
+          end
+        end
+
+        def clear
+          @buffer = Array.new(@max_size)
+          @write_pos = 0
+          @count = 0
+        end
+      end
+
+      # Initialize a new ring buffer for the current thread (start of request)
+      def self.init_buffer
+        size = RailsErrorDashboard.configuration.breadcrumb_buffer_size || 40
+        Thread.current[THREAD_KEY] = RingBuffer.new(size)
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] BreadcrumbCollector.init_buffer failed: #{e.message}")
+        nil
+      end
+
+      # Clear the ring buffer (end of request — MUST be called in ensure block)
+      def self.clear_buffer
+        Thread.current[THREAD_KEY] = nil
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] BreadcrumbCollector.clear_buffer failed: #{e.message}")
+        nil
+      end
+
+      # Add a breadcrumb to the current buffer
+      # @param category [String] Event category (sql, controller, cache, job, mailer, custom)
+      # @param message [String] Human-readable description
+      # @param duration_ms [Float, nil] Duration in milliseconds
+      # @param metadata [Hash, nil] Optional key-value pairs
+      def self.add(category, message, duration_ms: nil, metadata: nil)
+        buffer = Thread.current[THREAD_KEY]
+        return unless buffer
+
+        # Check category filter
+        allowed = RailsErrorDashboard.configuration.breadcrumb_categories
+        if allowed
+          cat_sym = category.to_s.to_sym
+          return unless allowed.include?(cat_sym)
+        end
+
+        # Build breadcrumb entry with compact keys
+        entry = {
+          t: (Time.now.to_f * 1000).to_i,
+          c: category.to_s,
+          m: truncate_message(message)
+        }
+
+        entry[:d] = duration_ms if duration_ms
+        entry[:meta] = truncate_metadata(metadata) if metadata.is_a?(Hash)
+
+        buffer.add(entry)
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] BreadcrumbCollector.add failed: #{e.message}")
+        nil
+      end
+
+      # Harvest breadcrumbs from the current buffer and clear it
+      # @return [Array<Hash>] Array of breadcrumb hashes (empty if none)
+      def self.harvest
+        buffer = Thread.current[THREAD_KEY]
+        return [] unless buffer
+
+        result = buffer.to_a
+        buffer.clear
+        result
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] BreadcrumbCollector.harvest failed: #{e.message}")
+        []
+      end
+
+      # Get the current buffer (for inspection)
+      # @return [RingBuffer, nil]
+      def self.current_buffer
+        Thread.current[THREAD_KEY]
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] BreadcrumbCollector.current_buffer failed: #{e.message}")
+        nil
+      end
+
+      # Filter sensitive data from breadcrumbs before storage
+      # Reuses existing SensitiveDataFilter — no new filter logic
+      # @param breadcrumbs [Array<Hash>] Raw breadcrumbs
+      # @return [Array<Hash>] Filtered breadcrumbs
+      def self.filter_sensitive(breadcrumbs)
+        return [] unless breadcrumbs.is_a?(Array)
+        return breadcrumbs unless RailsErrorDashboard.configuration.filter_sensitive_data
+
+        filter = SensitiveDataFilter.parameter_filter
+        return breadcrumbs unless filter
+
+        breadcrumbs.map do |crumb|
+          filtered = crumb.dup
+
+          # Filter message (SQL queries, key=value patterns)
+          if filtered[:m]
+            filtered[:m] = SensitiveDataFilter.send(:filter_message, filter, filtered[:m])
+          end
+
+          # Filter metadata values
+          if filtered[:meta].is_a?(Hash)
+            filtered[:meta] = filter.filter(filtered[:meta])
+          end
+
+          filtered
+        end
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] BreadcrumbCollector.filter_sensitive failed: #{e.message}")
+        breadcrumbs.is_a?(Array) ? breadcrumbs : []
+      end
+
+      # Truncate message to MAX_MESSAGE_LENGTH
+      def self.truncate_message(message)
+        str = message.to_s
+        str.length > MAX_MESSAGE_LENGTH ? str[0, MAX_MESSAGE_LENGTH] : str
+      rescue => e
+        ""
+      end
+      private_class_method :truncate_message
+
+      # Truncate metadata: limit keys and value lengths
+      def self.truncate_metadata(metadata)
+        return {} unless metadata.is_a?(Hash)
+
+        result = {}
+        metadata.first(MAX_METADATA_KEYS).each do |key, value|
+          str_value = value.to_s
+          result[key] = str_value.length > MAX_METADATA_VALUE_LENGTH ? str_value[0, MAX_METADATA_VALUE_LENGTH] : str_value
+        end
+        result
+      rescue => e
+        {}
+      end
+      private_class_method :truncate_metadata
+    end
+  end
+end

data/lib/rails_error_dashboard/services/cache_analyzer.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Pure algorithm: Analyze cache breadcrumbs at display time
+    #
+    # Operates on already-captured breadcrumb data — zero runtime cost.
+    # Called at display time only. Similar pattern to NplusOneDetector.
+    #
+    # @example
+    #   RailsErrorDashboard::Services::CacheAnalyzer.call(breadcrumbs)
+    #   # => { reads: 5, writes: 2, hits: 3, misses: 1, unknown: 1,
+    #   #      hit_rate: 75.0, total_duration_ms: 12.5,
+    #   #      slowest: { message: "cache read: users/1", duration_ms: 5.2 } }
+    class CacheAnalyzer
+      # @param breadcrumbs [Array<Hash>] Parsed breadcrumb array
+      # @return [Hash, nil] Cache analysis summary, or nil if no cache breadcrumbs
+      def self.call(breadcrumbs)
+        return nil unless breadcrumbs.is_a?(Array)
+
+        cache_crumbs = breadcrumbs.select { |c| c["c"] == "cache" }
+        return nil if cache_crumbs.empty?
+
+        reads = 0
+        writes = 0
+        hits = 0
+        misses = 0
+        unknown = 0
+        total_duration = 0.0
+        slowest = nil
+
+        cache_crumbs.each do |crumb|
+          message = crumb["m"].to_s
+          duration = crumb["d"].to_f
+
+          if message.start_with?("cache read:")
+            reads += 1
+            hit_status = crumb.dig("meta", "hit")
+            if hit_status.nil?
+              unknown += 1
+            elsif hit_status == true || hit_status == "true"
+              hits += 1
+            else
+              misses += 1
+            end
+          elsif message.start_with?("cache write:")
+            writes += 1
+          end
+
+          total_duration += duration
+
+          if slowest.nil? || duration > slowest[:duration_ms]
+            slowest = { message: message, duration_ms: duration }
+          end
+        end
+
+        # Only calculate hit_rate if we have read breadcrumbs with known hit status
+        known_reads = hits + misses
+        hit_rate = known_reads > 0 ? (hits.to_f / known_reads * 100).round(1) : nil
+
+        {
+          reads: reads,
+          writes: writes,
+          hits: hits,
+          misses: misses,
+          unknown: unknown,
+          hit_rate: hit_rate,
+          total_duration_ms: total_duration.round(1),
+          slowest: slowest
+        }
+      rescue => e
+        nil
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/curl_generator.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Pure algorithm: Assemble a curl command from an error log's request data
+    #
+    # Operates on data already stored in ErrorLog — zero runtime cost.
+    # Called at display time only.
+    #
+    # @example
+    #   RailsErrorDashboard::Services::CurlGenerator.call(error)
+    #   # => "curl -X POST 'https://example.com/users' -H 'Content-Type: application/json' -d '{\"name\":\"test\"}'"
+    class CurlGenerator
+      BODY_METHODS = %w[ POST PUT PATCH ].freeze
+
+      # @param error [ErrorLog] An error log record
+      # @return [String] curl command string, or "" if insufficient data
+      def self.call(error)
+        new(error).generate
+      rescue => e
+        ""
+      end
+
+      def initialize(error)
+        @error = error
+      end
+
+      # @return [String]
+      def generate
+        url = build_url
+        return "" if url.blank?
+
+        parts = [ "curl" ]
+
+        method = @error.respond_to?(:http_method) && @error.http_method.presence
+        parts << "-X #{method}" if method && method != "GET"
+
+        parts << shell_quote(url)
+
+        content_type = @error.respond_to?(:content_type) && @error.content_type.presence
+        parts << "-H #{shell_quote("Content-Type: #{content_type}")}" if content_type
+
+        user_agent = @error.respond_to?(:user_agent) && @error.user_agent.presence
+        parts << "-H #{shell_quote("User-Agent: #{user_agent}")}" if user_agent
+
+        if method && BODY_METHODS.include?(method.to_s.upcase)
+          body = @error.respond_to?(:request_params) && @error.request_params.presence
+          parts << "-d #{shell_quote(body)}" if body
+        end
+
+        parts.join(" ")
+      rescue => e
+        ""
+      end
+
+      private
+
+      def build_url
+        request_url = @error.respond_to?(:request_url) && @error.request_url.presence
+        return nil unless request_url
+
+        # If request_url is already a full URL, use it directly
+        return request_url if request_url.start_with?("http://", "https://")
+
+        # Otherwise, prepend hostname
+        hostname = @error.respond_to?(:hostname) && @error.hostname.presence
+        return nil unless hostname
+
+        scheme = hostname.include?("localhost") ? "http" : "https"
+        "#{scheme}://#{hostname}#{request_url}"
+      end
+
+      def shell_quote(str)
+        # Replace ' with '\'' (end quote, escaped quote, start quote)
+        escaped = str.to_s.gsub("'") { "'\\''" }
+        "'#{escaped}'"
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/database_health_inspector.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Display-time only service: queries PostgreSQL system tables when the
+    # DB Health page loads. NOT used in the capture path.
+    #
+    # Feature-detects PostgreSQL — returns nil for tables/indexes/activity
+    # on SQLite/MySQL. Connection pool stats work on all adapters.
+    # Every method individually rescue-wrapped (returns nil).
+    class DatabaseHealthInspector
+      def self.call
+        new.call
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] DatabaseHealthInspector failed: #{e.class}: #{e.message}")
+        { adapter: nil, postgresql: false, connection_pool: nil, tables: nil,
+          indexes: nil, unused_indexes: nil, activity: nil }
+      end
+
+      def call
+        {
+          adapter: adapter_name,
+          postgresql: postgresql?,
+          connection_pool: connection_pool_stats,
+          tables: postgresql? ? table_stats : nil,
+          indexes: postgresql? ? index_stats : nil,
+          unused_indexes: postgresql? ? unused_index_stats : nil,
+          activity: postgresql? ? activity_stats : nil
+        }
+      end
+
+      private
+
+      def connection
+        ActiveRecord::Base.connection
+      end
+
+      def adapter_name
+        connection.adapter_name
+      rescue => e
+        nil
+      end
+
+      def postgresql?
+        adapter_name == "PostgreSQL"
+      end
+
+      def connection_pool_stats
+        pool = ActiveRecord::Base.connection_pool
+        stat = pool.stat
+        { size: stat[:size], busy: stat[:busy], dead: stat[:dead],
+          idle: stat[:idle], waiting: stat[:waiting] }
+      rescue => e
+        nil
+      end
+
+      def table_stats
+        rows = connection.select_all(<<~SQL)
+          SELECT
+            schemaname,
+            relname AS name,
+            n_live_tup AS estimated_rows,
+            pg_total_relation_size(quote_ident(schemaname) || '.' || quote_ident(relname)) AS total_bytes,
+            seq_scan,
+            idx_scan,
+            n_dead_tup AS dead_tuples,
+            last_vacuum,
+            last_autovacuum,
+            last_analyze
+          FROM pg_stat_user_tables
+          ORDER BY pg_total_relation_size(quote_ident(schemaname) || '.' || quote_ident(relname)) DESC
+        SQL
+
+        rows.map do |row|
+          {
+            name: row["name"],
+            estimated_rows: row["estimated_rows"].to_i,
+            total_bytes: row["total_bytes"].to_i,
+            seq_scan: row["seq_scan"].to_i,
+            idx_scan: row["idx_scan"].to_i,
+            dead_tuples: row["dead_tuples"].to_i,
+            last_vacuum: row["last_vacuum"],
+            last_autovacuum: row["last_autovacuum"],
+            last_analyze: row["last_analyze"],
+            gem_table: row["name"].to_s.start_with?("rails_error_dashboard_")
+          }
+        end
+      rescue => e
+        nil
+      end
+
+      def index_stats
+        rows = connection.select_all(<<~SQL)
+          SELECT
+            sui.indexrelname AS name,
+            sui.relname AS table_name,
+            pg_relation_size(sui.indexrelid) AS size_bytes,
+            sui.idx_scan AS scans,
+            sui.idx_tup_read AS tuples_read,
+            sui.idx_tup_fetch AS tuples_fetched
+          FROM pg_stat_user_indexes sui
+          ORDER BY pg_relation_size(sui.indexrelid) DESC
+        SQL
+
+        rows.map do |row|
+          {
+            name: row["name"],
+            table_name: row["table_name"],
+            size_bytes: row["size_bytes"].to_i,
+            scans: row["scans"].to_i,
+            tuples_read: row["tuples_read"].to_i,
+            tuples_fetched: row["tuples_fetched"].to_i
+          }
+        end
+      rescue => e
+        nil
+      end
+
+      def unused_index_stats
+        rows = connection.select_all(<<~SQL)
+          SELECT
+            sui.indexrelname AS name,
+            sui.relname AS table_name,
+            pg_relation_size(sui.indexrelid) AS size_bytes
+          FROM pg_stat_user_indexes sui
+          WHERE sui.idx_scan = 0
+            AND pg_relation_size(sui.indexrelid) > 0
+          ORDER BY pg_relation_size(sui.indexrelid) DESC
+        SQL
+
+        rows.map do |row|
+          {
+            name: row["name"],
+            table_name: row["table_name"],
+            size_bytes: row["size_bytes"].to_i
+          }
+        end
+      rescue => e
+        nil
+      end
+
+      def activity_stats
+        rows = connection.select_all(<<~SQL)
+          SELECT
+            COALESCE(state, 'unknown') AS state,
+            COUNT(*) AS count,
+            COUNT(*) FILTER (WHERE wait_event_type IS NOT NULL) AS waiting
+          FROM pg_stat_activity
+          WHERE datname = current_database()
+          GROUP BY state
+          ORDER BY count DESC
+        SQL
+
+        by_state = rows.map do |row|
+          { state: row["state"], count: row["count"].to_i, waiting: row["waiting"].to_i }
+        end
+
+        {
+          by_state: by_state,
+          total: by_state.sum { |r| r[:count] },
+          total_waiting: by_state.sum { |r| r[:waiting] }
+        }
+      rescue => e
+        nil
+      end
+    end
+  end
+end