rails_error_dashboard 0.3.0 → 0.3.1

data/app/views/rails_error_dashboard/errors/job_health_summary.html.erb

@@ -0,0 +1,152 @@
+<% content_for :page_title, "Job Health" %>
+
+<div class="container-fluid py-4">
+  <div class="d-flex justify-content-between align-items-center mb-4">
+    <h1 class="h3 mb-0">
+      <i class="bi bi-cpu me-2"></i>
+      Job Health
+    </h1>
+
+    <div class="btn-group" role="group">
+      <%= link_to job_health_summary_errors_path(days: 7), class: "btn btn-sm #{@days == 7 ? 'btn-primary' : 'btn-outline-primary'}" do %>
+        7 Days
+      <% end %>
+      <%= link_to job_health_summary_errors_path(days: 30), class: "btn btn-sm #{@days == 30 ? 'btn-primary' : 'btn-outline-primary'}" do %>
+        30 Days
+      <% end %>
+      <%= link_to job_health_summary_errors_path(days: 90), class: "btn btn-sm #{@days == 90 ? 'btn-primary' : 'btn-outline-primary'}" do %>
+        90 Days
+      <% end %>
+    </div>
+  </div>
+
+  <% if @errors_with_jobs == 0 %>
+    <div class="text-center py-5">
+      <i class="bi bi-check-circle display-1 text-success mb-3"></i>
+      <h4 class="text-muted">No Job Queue Data Found</h4>
+      <p class="text-muted">
+        No job queue stats were detected in system health snapshots over the last <%= @days %> days.
+      </p>
+      <div class="card mx-auto" style="max-width: 500px;">
+        <div class="card-body text-start">
+          <h6>How job health tracking works:</h6>
+          <ul class="mb-0">
+            <li>System health must be enabled (<code>enable_system_health = true</code>)</li>
+            <li>Job queue stats are captured automatically when Sidekiq, SolidQueue, or GoodJob is detected</li>
+            <li>Stats are collected per-error at the time of capture</li>
+            <li>This page shows job queue health per-error, sorted by failed count</li>
+          </ul>
+        </div>
+      </div>
+    </div>
+  <% else %>
+    <div class="row mb-4">
+      <div class="col-md-4">
+        <div class="card text-center">
+          <div class="card-body">
+            <div class="display-6 text-info"><%= @errors_with_jobs %></div>
+            <small class="text-muted">Errors with Job Data</small>
+          </div>
+        </div>
+      </div>
+      <div class="col-md-4">
+        <div class="card text-center">
+          <div class="card-body">
+            <% failed_color = @total_failed > 0 ? "danger" : "success" %>
+            <div class="display-6 text-<%= failed_color %>"><%= @total_failed %></div>
+            <small class="text-muted">Total Failed Jobs</small>
+          </div>
+        </div>
+      </div>
+      <div class="col-md-4">
+        <div class="card text-center">
+          <div class="card-body">
+            <div class="display-6 text-secondary"><%= @adapters_detected.size %></div>
+            <small class="text-muted">Adapters Detected</small>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <div class="card mb-4">
+      <div class="card-header bg-white d-flex justify-content-between align-items-center">
+        <h5 class="mb-0">
+          <i class="bi bi-cpu text-info me-2"></i>
+          Job Queue Health by Error
+          <span class="badge bg-info"><%= @errors_with_jobs %></span>
+        </h5>
+        <small class="text-muted"><%== @pagy.info_tag %></small>
+      </div>
+      <div class="card-body p-0">
+        <div class="table-responsive">
+          <table class="table table-hover mb-0">
+            <thead class="table-light">
+              <tr>
+                <th width="100">Error</th>
+                <th width="120">Adapter</th>
+                <th width="80">Failed</th>
+                <th width="120">Queued</th>
+                <th>Other Stats</th>
+                <th width="140">Last Seen</th>
+              </tr>
+            </thead>
+            <tbody>
+              <% @entries.each do |entry| %>
+                <tr>
+                  <td><%= link_to "##{entry[:error_id]}", error_path(entry[:error_id]), class: "text-decoration-none" %></td>
+                  <td><span class="badge bg-secondary"><%= entry[:adapter] %></span></td>
+                  <td>
+                    <% failed = entry[:failed] || entry[:errored] || 0 %>
+                    <% if failed > 0 %>
+                      <span class="badge bg-danger"><%= failed %></span>
+                    <% else %>
+                      <span class="text-success">0</span>
+                    <% end %>
+                  </td>
+                  <td>
+                    <% case entry[:adapter] %>
+                    <% when "sidekiq" %>
+                      <%= entry[:enqueued] %> enqueued
+                    <% when "solid_queue" %>
+                      <%= entry[:ready] %> ready
+                    <% when "good_job" %>
+                      <%= entry[:queued] %> queued
+                    <% end %>
+                  </td>
+                  <td>
+                    <small class="text-muted">
+                      <% case entry[:adapter] %>
+                      <% when "sidekiq" %>
+                        dead: <%= entry[:dead] %>, retry: <%= entry[:retry] %>, workers: <%= entry[:workers] %>
+                      <% when "solid_queue" %>
+                        claimed: <%= entry[:claimed] %>, blocked: <%= entry[:blocked] %>, scheduled: <%= entry[:scheduled] %>
+                      <% when "good_job" %>
+                        finished: <%= entry[:finished] %>
+                      <% end %>
+                    </small>
+                  </td>
+                  <td><%= local_time_ago(entry[:occurred_at]) %></td>
+                </tr>
+              <% end %>
+            </tbody>
+          </table>
+        </div>
+      </div>
+      <div class="card-footer bg-white border-top d-flex justify-content-between align-items-center">
+        <div>
+          <small class="text-muted">
+            <i class="bi bi-lightbulb text-warning"></i> High failed job counts during errors may indicate job queue saturation or upstream service issues.
+          </small>
+          <small class="ms-3">
+            <a href="https://guides.rubyonrails.org/active_job_basics.html" target="_blank" rel="noopener" class="text-decoration-none">
+              <i class="bi bi-book"></i> Active Job Guide <i class="bi bi-box-arrow-up-right" style="font-size: 0.7em;"></i>
+            </a>
+          </small>
+        </div>
+        <div>
+          <%== @pagy.series_nav(:bootstrap) if @pagy.pages > 1 %>
+        </div>
+      </div>
+    </div>
+  <% end %>
+</div>

data/config/routes.rb

@@ -25,6 +25,8 @@ RailsErrorDashboard::Engine.routes.draw do
       get :deprecations
       get :n_plus_one_summary
       get :cache_health_summary
+      get :job_health_summary
+      get :database_health_summary
       post :batch_action
     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

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/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

data/lib/rails_error_dashboard/services/rspec_generator.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Pure algorithm: Assemble an RSpec request spec 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::RspecGenerator.call(error)
+    #   # => "RSpec.describe 'POST /users', type: :request do\n  it 'reproduces the error' do\n    ..."
+    class RspecGenerator
+      BODY_METHODS = %w[ POST PUT PATCH DELETE ].freeze
+
+      # @param error [ErrorLog] An error log record
+      # @return [String] RSpec request spec 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
+        path = request_path
+        return "" if path.blank?
+
+        method = http_method
+        lines = []
+        lines << header_lines(method, path)
+        lines << ""
+        lines << "  it \"reproduces the error\" do"
+        lines << request_line(method, path)
+        lines << ""
+        lines << "    # Original error: #{error_type}"
+        lines << "    # Expect the response to indicate the error"
+        lines << "    expect(response).to have_http_status(:internal_server_error)"
+        lines << "  end"
+        lines << "end"
+
+        lines.join("\n")
+      rescue => e
+        ""
+      end
+
+      private
+
+      def header_lines(method, path)
+        "RSpec.describe \"#{method} #{path}\", type: :request do"
+      end
+
+      def request_line(method, path)
+        verb = method.downcase
+        parts = []
+
+        if BODY_METHODS.include?(method) && parsed_params.present?
+          params_str = format_params(parsed_params)
+          headers_str = format_headers
+
+          args = [ "\"#{path}\"" ]
+          args << "params: #{params_str}"
+          args << "headers: #{headers_str}" if headers_str
+
+          parts << "    #{verb} #{args.join(', ')}"
+        else
+          query_params = extract_query_params(path)
+          clean_path = path.split("?").first
+
+          if query_params.present?
+            params_str = format_params(query_params)
+            parts << "    #{verb} \"#{clean_path}\", params: #{params_str}"
+          else
+            parts << "    #{verb} \"#{path}\""
+          end
+        end
+
+        parts.join("\n")
+      end
+
+      def http_method
+        method = @error.respond_to?(:http_method) && @error.http_method.presence
+        (method || "GET").upcase
+      end
+
+      def request_path
+        url = @error.respond_to?(:request_url) && @error.request_url.presence
+        return nil if url.blank?
+
+        # Strip scheme + host to get just the path
+        if url.start_with?("http://", "https://")
+          URI.parse(url).request_uri
+        else
+          url
+        end
+      rescue URI::InvalidURIError
+        url
+      end
+
+      def error_type
+        @error.respond_to?(:error_type) && @error.error_type.presence || "Unknown"
+      end
+
+      def parsed_params
+        raw = @error.respond_to?(:request_params) && @error.request_params.presence
+        return nil if raw.blank?
+
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def extract_query_params(path)
+        query = path.split("?", 2).last
+        return nil if query == path || query.blank?
+
+        Rack::Utils.parse_query(query)
+      rescue => e
+        nil
+      end
+
+      def format_params(hash)
+        return nil if hash.blank?
+
+        pairs = hash.map { |k, v| "#{format_key(k)} => #{v.inspect}" }
+        "{ #{pairs.join(', ')} }"
+      end
+
+      def format_headers
+        content_type = @error.respond_to?(:content_type) && @error.content_type.presence
+        return nil if content_type.blank?
+
+        "{ \"Content-Type\" => #{content_type.inspect} }"
+      end
+
+      def format_key(key)
+        key.to_s.inspect
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/lib/rails_error_dashboard.rb

@@ -54,6 +54,8 @@ require "rails_error_dashboard/services/notification_throttler"
 require "rails_error_dashboard/services/breadcrumb_collector"
 require "rails_error_dashboard/services/n_plus_one_detector"
 require "rails_error_dashboard/services/curl_generator"
+require "rails_error_dashboard/services/rspec_generator"
+require "rails_error_dashboard/services/database_health_inspector"
 require "rails_error_dashboard/services/cache_analyzer"
 require "rails_error_dashboard/subscribers/breadcrumb_subscriber"
 require "rails_error_dashboard/queries/co_occurring_errors"
@@ -89,6 +91,8 @@ require "rails_error_dashboard/queries/critical_alerts"
 require "rails_error_dashboard/queries/deprecation_warnings"
 require "rails_error_dashboard/queries/n_plus_one_summary"
 require "rails_error_dashboard/queries/cache_health_summary"
+require "rails_error_dashboard/queries/job_health_summary"
+require "rails_error_dashboard/queries/database_health_summary"
 require "rails_error_dashboard/error_reporter"
 require "rails_error_dashboard/middleware/error_catcher"
 require "rails_error_dashboard/middleware/rate_limiter"