rails_error_dashboard 0.3.0 → 0.4.0

data/lib/generators/rails_error_dashboard/install/templates/initializer.rb

@@ -356,7 +356,54 @@ RailsErrorDashboard.configure do |config|
   config.enable_system_health = false
 
 <% end -%>
+<% if @enable_swallowed_exceptions -%>
+  # Swallowed Exception Detection - ENABLED
+  # Requires Ruby 3.3+ — detects exceptions that are raised then silently rescued
+  # Uses TracePoint(:rescue), which was added in Ruby 3.3 (Feature #19572)
+  config.detect_swallowed_exceptions = true
+  config.swallowed_exception_threshold = 0.95       # Rescue ratio to flag (95%+)
+  # config.swallowed_exception_flush_interval = 60   # Seconds between DB flushes
+  # config.swallowed_exception_max_cache_size = 1000  # Max entries per thread
+  # config.swallowed_exception_ignore_classes = []    # App-specific exceptions to skip
+  # To disable: Set config.detect_swallowed_exceptions = false
 
+<% else -%>
+  # Swallowed Exception Detection - DISABLED
+  # Requires Ruby 3.3+ (TracePoint(:rescue) not available before 3.3)
+  # To enable: Set config.detect_swallowed_exceptions = true
+  config.detect_swallowed_exceptions = false
+  # config.swallowed_exception_threshold = 0.95
+
+<% end -%>
+<% if @enable_diagnostic_dump -%>
+  # Diagnostic Dump - ENABLED
+  # On-demand system state snapshot via rake task or dashboard button
+  config.enable_diagnostic_dump = true
+  # To disable: Set config.enable_diagnostic_dump = false
+
+<% else -%>
+  # Diagnostic Dump - DISABLED
+  # On-demand system state snapshot (rake task + dashboard page)
+  # To enable: Set config.enable_diagnostic_dump = true
+  config.enable_diagnostic_dump = false
+
+<% end -%>
+<% if @enable_crash_capture -%>
+  # Process Crash Capture - ENABLED
+  # Captures fatal crashes via at_exit hook. Crash data is written to disk as JSON
+  # and imported into the database on next boot. Zero runtime overhead.
+  config.enable_crash_capture = true
+  # config.crash_capture_path = "/tmp/my_app_crashes"  # Default: Dir.tmpdir
+  # To disable: Set config.enable_crash_capture = false
+
+<% else -%>
+  # Process Crash Capture - DISABLED
+  # Captures fatal crashes via at_exit hook (written to disk, imported on next boot)
+  # To enable: Set config.enable_crash_capture = true
+  config.enable_crash_capture = false
+  # config.crash_capture_path = "/tmp/my_app_crashes"
+
+<% end -%>
   # Repository settings (auto-detected from git remote, optional override)
   # config.repository_url = ENV["REPOSITORY_URL"]  # e.g., "https://github.com/user/repo"
   # config.repository_branch = ENV.fetch("REPOSITORY_BRANCH", "main")  # Default branch

data/lib/rails_error_dashboard/commands/flush_swallowed_exceptions.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Commands
+    # Command: Upsert swallowed exception raise/rescue counts into the database.
+    #
+    # Receives snapshot hashes from SwallowedExceptionTracker and merges them
+    # into hourly-bucketed rows. Uses find_or_initialize_by + increment for
+    # cross-database compatibility (no raw SQL upsert).
+    #
+    # raise_counts keys: "ClassName|path:line"
+    # rescue_counts keys: "ClassName|raise_path:line->rescue_path:line"
+    class FlushSwallowedExceptions
+      def self.call(raise_counts:, rescue_counts:)
+        new(raise_counts: raise_counts, rescue_counts: rescue_counts).call
+      end
+
+      def initialize(raise_counts:, rescue_counts:)
+        @raise_counts = raise_counts
+        @rescue_counts = rescue_counts
+      end
+
+      def call
+        period = Time.current.beginning_of_hour
+        app_id = current_application_id
+
+        # Process raise counts
+        @raise_counts.each do |key, count|
+          class_name, location = key.split("|", 2)
+          next if class_name.blank? || location.blank?
+
+          upsert_raise(class_name, location, period, app_id, count)
+        end
+
+        # Process rescue counts
+        @rescue_counts.each do |key, count|
+          class_name, locations = key.split("|", 2)
+          next if class_name.blank? || locations.blank?
+
+          raise_loc, rescue_loc = locations.split("->", 2)
+          next if raise_loc.blank?
+
+          upsert_rescue(class_name, raise_loc, rescue_loc, period, app_id, count)
+        end
+      rescue => e
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] FlushSwallowedExceptions failed: #{e.class} - #{e.message}"
+        )
+      end
+
+      private
+
+      def upsert_raise(class_name, location, period, app_id, count)
+        record = SwallowedException.find_or_initialize_by(
+          exception_class: truncate(class_name, 255),
+          raise_location: truncate(location, 500),
+          rescue_location: nil,
+          period_hour: period,
+          application_id: app_id
+        )
+
+        record.raise_count = (record.raise_count || 0) + count
+        record.last_seen_at = Time.current
+        record.save!
+      rescue => e
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] FlushSwallowedExceptions.upsert_raise failed for #{class_name}: #{e.message}"
+        )
+      end
+
+      def upsert_rescue(class_name, raise_loc, rescue_loc, period, app_id, count)
+        record = SwallowedException.find_or_initialize_by(
+          exception_class: truncate(class_name, 255),
+          raise_location: truncate(raise_loc, 500),
+          rescue_location: rescue_loc.present? ? truncate(rescue_loc, 500) : nil,
+          period_hour: period,
+          application_id: app_id
+        )
+
+        record.rescue_count = (record.rescue_count || 0) + count
+        record.last_seen_at = Time.current
+        record.save!
+      rescue => e
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] FlushSwallowedExceptions.upsert_rescue failed for #{class_name}: #{e.message}"
+        )
+      end
+
+      def current_application_id
+        app_name = RailsErrorDashboard.configuration.application_name
+        return nil unless app_name.present?
+
+        Application.find_by(name: app_name)&.id
+      rescue => e
+        nil
+      end
+
+      def truncate(str, max)
+        str.to_s.truncate(max, omission: "")
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -37,6 +37,34 @@ module RailsErrorDashboard
           context = context.merge(_serialized_system_health: Services::SystemHealthSnapshot.capture)
         end
 
+        # Capture local variables NOW (TracePoint attaches to exception, must extract before job dispatch)
+        if RailsErrorDashboard.configuration.enable_local_variables
+          begin
+            raw_locals = Services::LocalVariableCapturer.extract(exception)
+            if raw_locals.is_a?(Hash) && raw_locals.any?
+              context = context.merge(_serialized_local_variables: Services::VariableSerializer.call(raw_locals))
+            end
+          rescue => e
+            RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Async local variable serialization failed: #{e.message}")
+          end
+        end
+
+        # Capture instance variables NOW (same reason — attached to exception object)
+        if RailsErrorDashboard.configuration.enable_instance_variables
+          begin
+            raw_ivars = Services::LocalVariableCapturer.extract_instance_vars(exception)
+            if raw_ivars.is_a?(Hash) && raw_ivars.any?
+              context = context.merge(_serialized_instance_variables: Services::VariableSerializer.call(
+                raw_ivars,
+                max_count: RailsErrorDashboard.configuration.instance_variable_max_count,
+                additional_filter_patterns: RailsErrorDashboard.configuration.instance_variable_filter_patterns
+              ))
+            end
+          rescue => e
+            RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Async instance variable serialization failed: #{e.message}")
+          end
+        end
+
         # Enqueue the async job using ActiveJob
         # The queue adapter (:sidekiq, :solid_queue, :async) is configured separately
         AsyncErrorLoggingJob.perform_later(exception_data, context)
@@ -179,6 +207,46 @@ module RailsErrorDashboard
           attributes[:system_health] = health_data.to_json
         end
 
+        # Capture local variables (if enabled and column exists)
+        if ErrorLog.column_names.include?("local_variables") && RailsErrorDashboard.configuration.enable_local_variables
+          begin
+            # Sync path: extract from exception ivar
+            raw_locals = Services::LocalVariableCapturer.extract(@exception)
+            # Async path fallback: use pre-serialized locals from call_async context
+            raw_locals ||= @context[:_serialized_local_variables]
+            if raw_locals.is_a?(Hash) && raw_locals.any?
+              serialized = raw_locals == @context[:_serialized_local_variables] ? raw_locals : Services::VariableSerializer.call(raw_locals)
+              attributes[:local_variables] = serialized.to_json
+            end
+          rescue => e
+            RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Local variable serialization failed: #{e.message}")
+          end
+        end
+
+        # Capture instance variables (if enabled and column exists)
+        if ErrorLog.column_names.include?("instance_variables") && RailsErrorDashboard.configuration.enable_instance_variables
+          begin
+            # Sync path: extract from exception ivar
+            raw_ivars = Services::LocalVariableCapturer.extract_instance_vars(@exception)
+            # Async path fallback: use pre-serialized ivars from call_async context
+            raw_ivars ||= @context[:_serialized_instance_variables]
+            if raw_ivars.is_a?(Hash) && raw_ivars.any?
+              serialized = if raw_ivars == @context[:_serialized_instance_variables]
+                raw_ivars
+              else
+                Services::VariableSerializer.call(
+                  raw_ivars,
+                  max_count: RailsErrorDashboard.configuration.instance_variable_max_count,
+                  additional_filter_patterns: RailsErrorDashboard.configuration.instance_variable_filter_patterns
+                )
+              end
+              attributes[:instance_variables] = serialized.to_json
+            end
+          rescue => e
+            RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Instance variable serialization failed: #{e.message}")
+          end
+        end
+
         # Find existing error or create new one
         # This ensures accurate occurrence tracking
         error_log = ErrorLog.find_or_increment_by_hash(error_hash, attributes.merge(error_hash: error_hash))

data/lib/rails_error_dashboard/configuration.rb

@@ -127,6 +127,37 @@ module RailsErrorDashboard
     # System health snapshot (GC, memory, threads, connection pool at error time)
     attr_accessor :enable_system_health            # Master switch (default: false)
 
+    # Local variable capture via TracePoint(:raise)
+    attr_accessor :enable_local_variables            # Master switch (default: false)
+    attr_accessor :local_variable_max_count           # Max variables to capture (default: 15)
+    attr_accessor :local_variable_max_depth           # Max object nesting depth (default: 3)
+    attr_accessor :local_variable_max_string_length   # Max string value length (default: 200)
+    attr_accessor :local_variable_max_array_items     # Max array items to serialize (default: 10)
+    attr_accessor :local_variable_max_hash_items      # Max hash entries to serialize (default: 20)
+    attr_accessor :local_variable_filter_patterns     # Additional sensitive name patterns (default: [])
+
+    # Instance variable capture from tp.self (receiver object at raise time)
+    attr_accessor :enable_instance_variables           # Master switch (default: false)
+    attr_accessor :instance_variable_max_count          # Max ivars to capture (default: 20)
+    attr_accessor :instance_variable_filter_patterns    # Additional sensitive ivar patterns (default: [])
+
+    # Swallowed exception detection via TracePoint(:raise) + TracePoint(:rescue) (Ruby 3.3+ only)
+    attr_accessor :detect_swallowed_exceptions          # Master switch (default: false)
+    attr_accessor :swallowed_exception_max_cache_size   # Max entries per thread (default: 1000)
+    attr_accessor :swallowed_exception_flush_interval   # Seconds between flushes (default: 60)
+    attr_accessor :swallowed_exception_threshold        # Rescue ratio to flag (default: 0.95)
+    attr_accessor :swallowed_exception_ignore_classes   # Additional exception classes to skip (default: [])
+
+    # Process crash capture via at_exit hook
+    attr_accessor :enable_crash_capture                 # Master switch (default: false)
+    attr_accessor :crash_capture_path                   # Directory for crash files (default: Dir.tmpdir)
+
+    # On-demand diagnostic dump (rake task + dashboard endpoint)
+    attr_accessor :enable_diagnostic_dump               # Master switch (default: false)
+
+    # Rack Attack event tracking (requires enable_breadcrumbs = true)
+    attr_accessor :enable_rack_attack_tracking          # Master switch (default: false)
+
     # Notification callbacks (managed via helper methods, not set directly)
     attr_reader :notification_callbacks
 
@@ -238,6 +269,37 @@ module RailsErrorDashboard
       # System health snapshot defaults - OFF by default (opt-in)
       @enable_system_health = false  # Capture GC, memory, threads, connection pool at error time
 
+      # Local variable capture defaults - OFF by default (opt-in)
+      @enable_local_variables = false           # TracePoint(:raise) for local var capture
+      @local_variable_max_count = 15            # Max variables per exception
+      @local_variable_max_depth = 3             # Max nesting depth for objects
+      @local_variable_max_string_length = 200   # Truncate strings beyond this
+      @local_variable_max_array_items = 10      # Max array items to serialize
+      @local_variable_max_hash_items = 20       # Max hash entries to serialize
+      @local_variable_filter_patterns = []      # Additional sensitive variable name patterns
+
+      # Instance variable capture defaults - OFF by default (opt-in)
+      @enable_instance_variables = false         # Capture ivars from tp.self at raise time
+      @instance_variable_max_count = 20          # Max ivars per exception
+      @instance_variable_filter_patterns = []    # Additional sensitive ivar name patterns
+
+      # Swallowed exception detection defaults - OFF by default (Ruby 3.3+ opt-in)
+      @detect_swallowed_exceptions = false       # TracePoint(:raise) + TracePoint(:rescue)
+      @swallowed_exception_max_cache_size = 1000 # Max entries per thread-local hash
+      @swallowed_exception_flush_interval = 60   # Seconds between DB flushes
+      @swallowed_exception_threshold = 0.95      # Rescue ratio to flag as swallowed
+      @swallowed_exception_ignore_classes = []   # Additional exception classes to skip
+
+      # Process crash capture defaults - OFF by default (opt-in)
+      @enable_crash_capture = false     # at_exit hook for fatal crash capture
+      @crash_capture_path = nil         # nil = Dir.tmpdir
+
+      # Diagnostic dump defaults - OFF by default (opt-in)
+      @enable_diagnostic_dump = false   # On-demand system state snapshot
+
+      # Rack Attack event tracking defaults - OFF by default (opt-in, requires breadcrumbs)
+      @enable_rack_attack_tracking = false
+
       # Internal logging defaults - SILENT by default
       @enable_internal_logging = false  # Opt-in for debugging
       @log_level = :silent  # Silent by default, use :debug, :info, :warn, :error, or :silent
@@ -256,11 +318,13 @@ module RailsErrorDashboard
 
     # Validate configuration values
     # Raises ConfigurationError if any validation fails
+    # Logs warnings for non-fatal issues (e.g., Ruby version incompatibilities)
     #
     # @raise [ConfigurationError] if configuration is invalid
     # @return [true] if configuration is valid
     def validate!
       errors = []
+      warnings = []
 
       # Validate sampling_rate (must be between 0.0 and 1.0)
       if sampling_rate && (sampling_rate < 0.0 || sampling_rate > 1.0)
@@ -330,6 +394,59 @@ module RailsErrorDashboard
         errors << "n_plus_one_threshold must be at least 2 (got: #{n_plus_one_threshold})"
       end
 
+      # Validate local variable capture settings
+      if enable_local_variables
+        if local_variable_max_count && local_variable_max_count < 1
+          errors << "local_variable_max_count must be at least 1 (got: #{local_variable_max_count})"
+        end
+        if local_variable_max_depth && local_variable_max_depth < 1
+          errors << "local_variable_max_depth must be at least 1 (got: #{local_variable_max_depth})"
+        end
+        if local_variable_max_string_length && local_variable_max_string_length < 1
+          errors << "local_variable_max_string_length must be at least 1 (got: #{local_variable_max_string_length})"
+        end
+      end
+
+      # Validate instance variable capture settings
+      if enable_instance_variables && instance_variable_max_count && instance_variable_max_count < 1
+        errors << "instance_variable_max_count must be at least 1 (got: #{instance_variable_max_count})"
+      end
+
+      # Validate swallowed exception detection settings
+      # Auto-disable on Ruby < 3.3 (warn, don't crash)
+      if detect_swallowed_exceptions && RUBY_VERSION < "3.3"
+        warnings << "detect_swallowed_exceptions requires Ruby 3.3+ (current: #{RUBY_VERSION}). " \
+                    "TracePoint(:rescue) was added in Ruby 3.3 (Feature #19572). " \
+                    "Feature has been auto-disabled. Upgrade Ruby to use this feature."
+        @detect_swallowed_exceptions = false
+      end
+      # Validate sub-settings only if feature is still active after version check
+      if detect_swallowed_exceptions
+        if swallowed_exception_max_cache_size && swallowed_exception_max_cache_size < 1
+          errors << "swallowed_exception_max_cache_size must be at least 1 (got: #{swallowed_exception_max_cache_size})"
+        end
+        if swallowed_exception_flush_interval && swallowed_exception_flush_interval < 1
+          errors << "swallowed_exception_flush_interval must be at least 1 (got: #{swallowed_exception_flush_interval})"
+        end
+        if swallowed_exception_threshold && (swallowed_exception_threshold < 0.0 || swallowed_exception_threshold > 1.0)
+          errors << "swallowed_exception_threshold must be between 0.0 and 1.0 (got: #{swallowed_exception_threshold})"
+        end
+      end
+
+      # Validate rack_attack tracking requires breadcrumbs
+      if enable_rack_attack_tracking && !enable_breadcrumbs
+        warnings << "enable_rack_attack_tracking requires enable_breadcrumbs = true. " \
+                    "Rack Attack tracking has been auto-disabled."
+        @enable_rack_attack_tracking = false
+      end
+
+      # Validate crash capture path (must exist if custom path specified)
+      if enable_crash_capture && crash_capture_path
+        unless Dir.exist?(crash_capture_path)
+          errors << "crash_capture_path '#{crash_capture_path}' does not exist"
+        end
+      end
+
       # Validate notification dependencies
       if enable_slack_notifications && (slack_webhook_url.nil? || slack_webhook_url.strip.empty?)
         errors << "slack_webhook_url is required when enable_slack_notifications is true"
@@ -388,6 +505,11 @@ module RailsErrorDashboard
         errors << "notification_threshold_alerts must be an Array (got: #{notification_threshold_alerts.class})"
       end
 
+      # Log warnings (non-fatal issues)
+      warnings.each do |warning|
+        Rails.logger.warn "[Rails Error Dashboard] #{warning}" if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+      end
+
       # Raise exception if any errors found
       raise ConfigurationError, errors if errors.any?
 

data/lib/rails_error_dashboard/engine.rb

@@ -69,6 +69,30 @@ module RailsErrorDashboard
       if RailsErrorDashboard.configuration.enable_breadcrumbs
         RailsErrorDashboard::Subscribers::BreadcrumbSubscriber.subscribe!
       end
+
+      # Subscribe to Rack Attack AS::Notifications events (requires breadcrumbs + Rack::Attack)
+      if RailsErrorDashboard.configuration.enable_rack_attack_tracking &&
+         RailsErrorDashboard.configuration.enable_breadcrumbs &&
+         defined?(Rack::Attack)
+        RailsErrorDashboard::Subscribers::RackAttackSubscriber.subscribe!
+      end
+
+      # Enable TracePoint(:raise) for local variable and/or instance variable capture
+      if RailsErrorDashboard.configuration.enable_local_variables ||
+         RailsErrorDashboard.configuration.enable_instance_variables
+        RailsErrorDashboard::Services::LocalVariableCapturer.enable!
+      end
+
+      # Enable TracePoint(:raise) + TracePoint(:rescue) for swallowed exception detection
+      if RailsErrorDashboard.configuration.detect_swallowed_exceptions
+        RailsErrorDashboard::Services::SwallowedExceptionTracker.enable!
+      end
+
+      # Import crash files from previous process death, then register at_exit hook
+      if RailsErrorDashboard.configuration.enable_crash_capture
+        RailsErrorDashboard::Services::CrashCapture.import!
+        RailsErrorDashboard::Services::CrashCapture.enable!
+      end
     end
   end
 end

data/lib/rails_error_dashboard/queries/dashboard_stats.rb

@@ -309,37 +309,58 @@ module RailsErrorDashboard
       def top_errors_by_impact
         base_scope.where("occurred_at >= ?", 7.days.ago)
                 .group(:error_type, :id)
-                .select("error_type, id, occurrence_count,
+                .select("error_type, id, message, occurred_at, occurrence_count,
                         COUNT(DISTINCT user_id) as affected_users,
                         COUNT(DISTINCT user_id) * occurrence_count as impact_score")
                 .order("impact_score DESC")
                 .limit(6)
                 .map do |error|
-                  full_error = ErrorLog.find(error.id)
                   {
                     id: error.id,
                     error_type: error.error_type,
-                    message: full_error.message&.truncate(80),
-                    severity: full_error.severity,
+                    message: error.message&.truncate(80),
+                    severity: Services::SeverityClassifier.classify(error.error_type),
                     occurrence_count: error.occurrence_count,
                     affected_users: error.affected_users.to_i,
                     impact_score: error.impact_score.to_i,
-                    occurred_at: full_error.occurred_at
+                    occurred_at: error.occurred_at
                   }
                 end
       end
 
       # Calculate average resolution time (MTTR) in hours for the last 30 days
+      # Uses SQL AVG to avoid loading all resolved errors into Ruby memory
       def average_resolution_time
-        resolved_errors = base_scope.resolved.where("resolved_at >= ?", 30.days.ago)
-        return nil if resolved_errors.empty?
+        scope = base_scope.resolved.where("resolved_at >= ?", 30.days.ago)
+        return nil unless scope.exists?
 
-        total_seconds = resolved_errors.sum do |error|
-          (error.resolved_at - error.occurred_at).to_i
+        avg_seconds = scope.pick(Arel.sql(avg_seconds_sql))
+        return nil unless avg_seconds
+
+        (avg_seconds.to_f / 3600.0).round(2)
+      end
+
+      def avg_seconds_sql
+        case db_adapter
+        when :postgresql
+          "AVG(EXTRACT(EPOCH FROM (resolved_at - occurred_at)))"
+        when :mysql
+          "AVG(TIMESTAMPDIFF(SECOND, occurred_at, resolved_at))"
+        else
+          # SQLite: julianday difference * 86400 gives seconds
+          "AVG((julianday(resolved_at) - julianday(occurred_at)) * 86400)"
         end
+      end
 
-        average_seconds = total_seconds / resolved_errors.count.to_f
-        (average_seconds / 3600.0).round(2) # Convert to hours
+      def db_adapter
+        adapter = ErrorLog.connection.adapter_name.downcase
+        if adapter.include?("postgresql")
+          :postgresql
+        elsif adapter.include?("mysql") || adapter.include?("trilogy")
+          :mysql
+        else
+          :sqlite
+        end
       end
     end
   end

data/lib/rails_error_dashboard/queries/database_health_summary.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: Aggregate connection pool health stats from system_health across all errors
+    # Scans error_logs system_health JSON, extracts connection_pool data per error
+    class DatabaseHealthSummary
+      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, :error_type, :system_health, :occurred_at).find_each(batch_size: 500) do |error_log|
+          health = parse_system_health(error_log.system_health)
+          next if health.blank?
+
+          pool = health["connection_pool"]
+          next if pool.blank?
+
+          results << build_entry(error_log, pool)
+        end
+
+        # Sort by stress score descending (worst first)
+        results.sort_by { |r| -(r[:busy] + r[:dead] + r[:waiting]) }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] DatabaseHealthSummary query failed: #{e.class}: #{e.message}")
+        []
+      end
+
+      def build_entry(error_log, pool)
+        size = pool["size"].to_i
+        busy = pool["busy"].to_i
+        dead = pool["dead"].to_i
+        idle = pool["idle"].to_i
+        waiting = pool["waiting"].to_i
+        utilization = size > 0 ? (busy.to_f / size * 100).round(1) : 0.0
+
+        {
+          error_id: error_log.id,
+          error_type: error_log.error_type,
+          size: size,
+          busy: busy,
+          dead: dead,
+          idle: idle,
+          waiting: waiting,
+          utilization: utilization,
+          occurred_at: error_log.occurred_at
+        }
+      end
+
+      def parse_system_health(raw)
+        return nil if raw.blank?
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end