rails_error_dashboard 0.5.1 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9cbc9542b74dde89d9ef8e71bc6d55dc6c15b1bc1d8c0decc3181f83a39ab085
-  data.tar.gz: 25402cf18e90cbe62350700875c61cd334ae2798838892b5a0861b8fd2864abc
+  metadata.gz: 85ee33f8363a0a875c4c00bd2242a7d282dba7502cc78cf8af84a4583f376121
+  data.tar.gz: 51183380c9642cbabc19582daa191ee7ee4c161cc2c98fbc3dd6693459e91b40
 SHA512:
-  metadata.gz: 8baf9b17c79ba1ec2ac2a2cb1fca9044a5ef995a69993321014dfbd9de1c75f1dd6084deb6a4a35a40ce8d25679bb5557ef2e5a198280dd8d1ba42f13adc8625
-  data.tar.gz: 1603904cb93c8d7902530e3768d62dd60c747138f40a9dad315c111c0d67c51e843859624eca512234ff0a123887ffdde1568dab15753d942725e998decdcb15
+  metadata.gz: 827a994438026c7b42c42927665406c165357de706014596f533d1d23b0121e33a71aa6b2a55f131e274abe2e24dde6d484a4c6b869958363a2ef4fce641c378
+  data.tar.gz: ffa7bc26d8f565f10835735e2721589c6c56a13f1ee64f72a06e1b6cd5913c6e5ad8278838368578b57ec99a9cb46ddbf304ee27db4e78c74218db39cc778286

data/README.md

@@ -22,7 +22,7 @@ gem 'rails_error_dashboard'
 
 **[rails-error-dashboard.anjan.dev](https://rails-error-dashboard.anjan.dev)** — Username: `gandalf` · Password: `youshallnotpass`
 
-> **Beta Software** — Functional and tested (2,600+ tests passing), but the API may change before v1.0. Supports Rails 7.0-8.1 and Ruby 3.2-4.0.
+> **Beta Software** — Functional and tested (2,700+ tests passing), but the API may change before v1.0. Supports Rails 7.0-8.1 and Ruby 3.2-4.0.
 
 ### Screenshots
 
@@ -87,12 +87,13 @@ config.enable_breadcrumbs = true
 <details>
 <summary><strong>System Health Snapshot</strong></summary>
 
-Know your app's runtime state at the moment of failure — GC stats, process memory, thread count, connection pool utilization, Puma thread stats, RubyVM cache health, and YJIT compilation stats captured automatically.
+Know your app's runtime state at the moment of failure — GC stats, process memory, thread count, connection pool utilization, Puma thread stats, RubyVM cache health, YJIT compilation stats, and deep runtime insights captured automatically.
 
 - Sub-millisecond total snapshot, every metric individually rescue-wrapped
 - No ObjectSpace scanning, no Thread backtraces, no subprocess calls
 - RubyVM.stat: constant cache invalidations, shape cache stats
 - YJIT runtime stats: compiled iseqs, invalidation count, code region sizes
+- **v0.5.2** — File descriptor utilization, system load averages, system memory pressure, TCP connection states, GC context (trigger reason, last major/minor), process swap and peak RSS — all with color-coded danger indicators
 
 ```ruby
 config.enable_system_health = true
@@ -153,9 +154,9 @@ config.enable_git_blame = true
 </details>
 
 <details>
-<summary><strong>Error Replay — Copy as cURL / RSpec</strong></summary>
+<summary><strong>Error Replay — Copy as cURL / RSpec / LLM Markdown</strong></summary>
 
-Replay failing requests with one click. Copy the request as a cURL command or generate an RSpec test from the captured error context.
+Replay failing requests with one click. Copy the request as a cURL command, generate an RSpec test, or **copy all error details as clean Markdown** for pasting into an LLM session. The LLM export includes app backtrace, cause chain, local/instance variables, breadcrumbs, environment, system health, and related errors — with framework frames filtered and sensitive data preserved as `[FILTERED]`.
 
 [Complete documentation →](docs/FEATURES.md#error-details-page)
 </details>

data/app/controllers/rails_error_dashboard/errors_controller.rb

@@ -4,6 +4,7 @@ module RailsErrorDashboard
   class ErrorsController < ApplicationController
     before_action :authenticate_dashboard_user!
     before_action :set_application_context
+    before_action :check_default_credentials
 
     FILTERABLE_PARAMS = %i[
       error_type
@@ -78,6 +79,7 @@ module RailsErrorDashboard
       # - parent_cascade_patterns/child_cascade_patterns: Used if cascade detection is enabled
       @error = ErrorLog.includes(:comments, :parent_cascade_patterns, :child_cascade_patterns).find(params[:id])
       @related_errors = @error.related_errors(limit: 5, application_id: @current_application_id)
+      @error_markdown = Services::MarkdownErrorFormatter.call(@error, related_errors: @related_errors)
 
       # Dispatch plugin event for error viewed
       RailsErrorDashboard::PluginRegistry.dispatch(:on_error_viewed, @error)
@@ -508,6 +510,10 @@ module RailsErrorDashboard
       @applications = Application.ordered_by_name.pluck(:name, :id)
     end
 
+    def check_default_credentials
+      @default_credentials_warning = RailsErrorDashboard.configuration.default_credentials?
+    end
+
     def authenticate_dashboard_user!
       auth_lambda = RailsErrorDashboard.configuration.authenticate_with
 

data/app/views/layouts/rails_error_dashboard.html.erb

@@ -774,6 +774,16 @@ body.dark-mode .alert-danger {
   color: var(--ctp-text) !important;
 }
 
+body.dark-mode .alert-warning {
+  background-color: rgba(249, 226, 175, 0.15) !important;
+  border-color: var(--ctp-yellow) !important;
+  color: var(--ctp-text) !important;
+}
+
+body.dark-mode .alert-warning code {
+  color: var(--ctp-peach) !important;
+}
+
 /* Chartkick specific - force text visibility */
 body.dark-mode #chart-1 text,
 body.dark-mode [id^="chart-"] text {
@@ -1747,6 +1757,18 @@ body.dark-mode .sidebar-section-body { background: var(--ctp-mantle); }
 
         <!-- Main content -->
         <main class="col-md-10 ms-sm-auto px-md-4" id="mainContent">
+          <% if @default_credentials_warning %>
+            <div class="alert alert-warning d-flex align-items-center mt-3 mb-0" role="alert" style="border-left: 4px solid #ffc107;">
+              <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" fill="currentColor" class="me-2 flex-shrink-0" viewBox="0 0 16 16">
+                <path d="M8.982 1.566a1.13 1.13 0 0 0-1.96 0L.165 13.233c-.457.778.091 1.767.98 1.767h13.713c.889 0 1.438-.99.98-1.767L8.982 1.566zM8 5c.535 0 .954.462.9.995l-.35 3.507a.552.552 0 0 1-1.1 0L7.1 5.995A.905.905 0 0 1 8 5zm.002 6a1 1 0 1 1 0 2 1 1 0 0 1 0-2z"/>
+              </svg>
+              <div>
+                <strong>Security Warning:</strong> You are using default credentials (gandalf/youshallnotpass).
+                Set <code>ERROR_DASHBOARD_USER</code> and <code>ERROR_DASHBOARD_PASSWORD</code> environment variables,
+                or configure <code>authenticate_with</code> in your initializer. The app will not boot in production until this is changed.
+              </div>
+            </div>
+          <% end %>
           <%= yield %>
         </main>
       </div>

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

@@ -299,7 +299,37 @@
                 <div class="sidebar-section-title"><i class="bi bi-heart-pulse"></i> System Health</div>
                 <small class="sidebar-section-hint">Runtime state when error fired</small>
                 <div class="sidebar-section-body">
-                  <% if health[:process_memory_mb] %>
+                  <% if health[:process_memory] %>
+                    <% pm = health[:process_memory] %>
+                    <div class="mb-1">
+                      <small class="text-muted">Memory (RSS):</small>
+                      <% mem = pm[:rss_mb].to_f %>
+                      <code class="ms-1 text-<%= mem > 1024 ? 'danger' : mem > 512 ? 'warning' : 'success' %>">
+                        <%= mem %> MB
+                      </code>
+                    </div>
+                    <% if pm[:swap_mb].to_f > 0 %>
+                      <div class="mb-1">
+                        <small class="text-muted">Process Swap:</small>
+                        <code class="ms-1 text-danger"><%= pm[:swap_mb] %> MB</code>
+                      </div>
+                    <% end %>
+                    <% if pm[:rss_peak_mb] %>
+                      <div class="mb-1">
+                        <small class="text-muted">Peak RSS:</small>
+                        <code class="ms-1"><%= pm[:rss_peak_mb] %> MB</code>
+                      </div>
+                    <% end %>
+                    <% if pm[:os_threads] %>
+                      <div class="mb-1">
+                        <small class="text-muted">OS Threads:</small>
+                        <code class="ms-1"><%= pm[:os_threads] %></code>
+                        <% if health[:thread_count] %>
+                          <small class="text-muted ms-1">(Ruby: <%= health[:thread_count] %>)</small>
+                        <% end %>
+                      </div>
+                    <% end %>
+                  <% elsif health[:process_memory_mb] %>
                     <div class="mb-1">
                       <small class="text-muted">Memory (RSS):</small>
                       <% mem = health[:process_memory_mb].to_f %>
@@ -307,12 +337,61 @@
                         <%= mem %> MB
                       </code>
                     </div>
+                    <% if health[:thread_count] %>
+                      <div class="mb-1">
+                        <small class="text-muted">Threads:</small>
+                        <code class="ms-1"><%= health[:thread_count] %></code>
+                      </div>
+                    <% end %>
                   <% end %>
 
-                  <% if health[:thread_count] %>
+                  <% if health[:file_descriptors] %>
+                    <% fd = health[:file_descriptors] %>
                     <div class="mb-1">
-                      <small class="text-muted">Threads:</small>
-                      <code class="ms-1"><%= health[:thread_count] %></code>
+                      <small class="text-muted">File Descriptors:</small>
+                      <% fd_pct = fd[:utilization_pct].to_f %>
+                      <code class="ms-1 text-<%= fd_pct > 80 ? 'danger' : fd_pct > 60 ? 'warning' : 'success' %>">
+                        <%= fd[:open] %> / <%= fd[:limit] %> (<%= fd_pct %>%)
+                      </code>
+                    </div>
+                  <% end %>
+
+                  <% if health[:system_load] %>
+                    <% sl = health[:system_load] %>
+                    <div class="mb-1">
+                      <small class="text-muted">Load Average:</small>
+                      <% lr = sl[:load_ratio].to_f %>
+                      <code class="ms-1 text-<%= lr > 2.0 ? 'danger' : lr > 1.0 ? 'warning' : 'success' %>">
+                        <%= sl[:load_1m] %><% if sl[:cpu_count] %> / <%= sl[:cpu_count] %> CPUs<% end %>
+                      </code>
+                      <small class="text-muted ms-1">(5m: <%= sl[:load_5m] %>, 15m: <%= sl[:load_15m] %>)</small>
+                    </div>
+                  <% end %>
+
+                  <% if health[:system_memory] %>
+                    <% sm = health[:system_memory] %>
+                    <div class="mb-1">
+                      <small class="text-muted">System Memory:</small>
+                      <% used_pct = sm[:used_pct].to_f %>
+                      <code class="ms-1 text-<%= used_pct > 90 ? 'danger' : used_pct > 80 ? 'warning' : 'success' %>">
+                        <%= sm[:available_mb] %> MB free / <%= sm[:total_mb] %> MB (<%= used_pct %>% used)
+                      </code>
+                    </div>
+                    <% if sm[:swap_used_mb].to_i > 0 %>
+                      <div class="mb-1">
+                        <small class="text-muted">System Swap:</small>
+                        <code class="ms-1 text-danger"><%= sm[:swap_used_mb] %> MB used</code>
+                      </div>
+                    <% end %>
+                  <% end %>
+
+                  <% if health[:tcp_connections] %>
+                    <% tcp = health[:tcp_connections] %>
+                    <div class="mb-1">
+                      <small class="text-muted">TCP Connections:</small>
+                      <code class="ms-1">
+                        <%= tcp[:established] %> established<% if tcp[:close_wait].to_i > 0 %>, <span class="text-danger"><%= tcp[:close_wait] %> close_wait</span><% end %><% if tcp[:time_wait].to_i > 0 %>, <span class="text-warning"><%= tcp[:time_wait] %> time_wait</span><% end %>
+                      </code>
                     </div>
                   <% end %>
 
@@ -327,6 +406,16 @@
                     </div>
                   <% end %>
 
+                  <% if health[:gc_latest] %>
+                    <% gcl = health[:gc_latest] %>
+                    <div class="mb-1">
+                      <small class="text-muted">Last GC:</small>
+                      <code class="ms-1">
+                        <%= gcl[:major_by] ? "major (#{gcl[:major_by]})" : "minor" %> by <%= gcl[:gc_by] %><% if gcl[:state].to_s != "none" %>, <span class="text-warning">state: <%= gcl[:state] %></span><% end %>
+                      </code>
+                    </div>
+                  <% end %>
+
                   <% if health[:connection_pool] %>
                     <% cp = health[:connection_pool] %>
                     <div class="mb-1">

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

@@ -32,6 +32,9 @@
       <button type="button" class="btn btn-outline-secondary" onclick="downloadErrorJSON(event)" title="Download error details as JSON">
         <i class="bi bi-download"></i> Export JSON
       </button>
+      <button type="button" class="btn btn-outline-secondary" onclick="copyToClipboard(this.dataset.markdown, this)" data-markdown="<%= j @error_markdown %>" title="Copy error details as Markdown for LLM debugging">
+        <i class="bi bi-clipboard"></i> Copy for LLM
+      </button>
       <% if @error.respond_to?(:muted?) && @error.muted? %>
         <button type="button" class="btn btn-secondary" disabled>
           <i class="bi bi-bell-slash"></i> Muted

data/db/migrate/20251223000000_create_rails_error_dashboard_complete_schema.rb

@@ -208,9 +208,9 @@ class CreateRailsErrorDashboardCompleteSchema < ActiveRecord::Migration[7.0]
 
     # Create swallowed_exceptions table (from 20260306000003)
     create_table :rails_error_dashboard_swallowed_exceptions do |t|
-      t.string   :exception_class,  null: false
-      t.string   :raise_location,   null: false, limit: 500
-      t.string   :rescue_location,  limit: 500
+      t.string   :exception_class,  null: false, limit: 250
+      t.string   :raise_location,   null: false, limit: 250
+      t.string   :rescue_location,  limit: 250
       t.datetime :period_hour,      null: false
       t.integer  :raise_count,      null: false, default: 0
       t.integer  :rescue_count,     null: false, default: 0

data/db/migrate/20260306000003_create_rails_error_dashboard_swallowed_exceptions.rb

@@ -3,9 +3,9 @@
 class CreateRailsErrorDashboardSwallowedExceptions < ActiveRecord::Migration[7.0]
   def change
     create_table :rails_error_dashboard_swallowed_exceptions do |t|
-      t.string   :exception_class,  null: false
-      t.string   :raise_location,   null: false, limit: 500
-      t.string   :rescue_location,  limit: 500
+      t.string   :exception_class,  null: false, limit: 250
+      t.string   :raise_location,   null: false, limit: 250
+      t.string   :rescue_location,  limit: 250
       t.datetime :period_hour,      null: false
       t.integer  :raise_count,      null: false, default: 0
       t.integer  :rescue_count,     null: false, default: 0

data/db/migrate/20260325000001_fix_swallowed_exceptions_index_for_mysql.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Fix MySQL "Specified key was too long" error on the swallowed_exceptions
+# composite unique index. The original columns (varchar 255 + 500 + 500)
+# total 5042 bytes under utf8mb4, exceeding MySQL's 3072-byte InnoDB limit.
+#
+# Reduces all three string columns to limit: 250, bringing the total to
+# 3022 bytes (250 * 4 * 3 + 6 length prefixes + 16 datetime/bigint).
+#
+# See: https://github.com/AnjanJ/rails_error_dashboard/issues/96
+class FixSwallowedExceptionsIndexForMysql < ActiveRecord::Migration[7.0]
+  def up
+    return unless table_exists?(:rails_error_dashboard_swallowed_exceptions)
+
+    # Remove the oversized index if it exists (it may not exist on MySQL
+    # since the original migration would have failed at this point)
+    if index_exists?(:rails_error_dashboard_swallowed_exceptions, name: "index_swallowed_exceptions_upsert_key")
+      remove_index :rails_error_dashboard_swallowed_exceptions, name: "index_swallowed_exceptions_upsert_key"
+    end
+
+    # Shrink columns to fit within MySQL's 3072-byte index key limit
+    change_column :rails_error_dashboard_swallowed_exceptions, :exception_class, :string, null: false, limit: 250
+    change_column :rails_error_dashboard_swallowed_exceptions, :raise_location, :string, null: false, limit: 250
+    change_column :rails_error_dashboard_swallowed_exceptions, :rescue_location, :string, limit: 250
+
+    # Re-add the index with the smaller columns
+    add_index :rails_error_dashboard_swallowed_exceptions,
+              [ :exception_class, :raise_location, :rescue_location, :period_hour, :application_id ],
+              unique: true,
+              name: "index_swallowed_exceptions_upsert_key"
+  end
+
+  def down
+    return unless table_exists?(:rails_error_dashboard_swallowed_exceptions)
+
+    if index_exists?(:rails_error_dashboard_swallowed_exceptions, name: "index_swallowed_exceptions_upsert_key")
+      remove_index :rails_error_dashboard_swallowed_exceptions, name: "index_swallowed_exceptions_upsert_key"
+    end
+
+    change_column :rails_error_dashboard_swallowed_exceptions, :exception_class, :string, null: false
+    change_column :rails_error_dashboard_swallowed_exceptions, :raise_location, :string, null: false, limit: 500
+    change_column :rails_error_dashboard_swallowed_exceptions, :rescue_location, :string, limit: 500
+
+    add_index :rails_error_dashboard_swallowed_exceptions,
+              [ :exception_class, :raise_location, :rescue_location, :period_hour, :application_id ],
+              unique: true,
+              name: "index_swallowed_exceptions_upsert_key"
+  end
+end

data/lib/generators/rails_error_dashboard/install/install_generator.rb

@@ -226,7 +226,27 @@ module RailsErrorDashboard
         say "\n"
       end
 
+      def detect_existing_config
+        initializer_path = File.join(destination_root, "config/initializers/rails_error_dashboard.rb")
+        return unless File.exist?(initializer_path)
+
+        content = File.read(initializer_path)
+        @existing_install_detected = true
+
+        # Detect separate database from existing config (skip comments)
+        if content.match?(/^\s*config\.use_separate_database\s*=\s*true/)
+          @database_mode = :separate
+          @database_name = content[/^\s*config\.database\s*=\s*:(\w+)/, 1] || "error_dashboard"
+          @enable_separate_database = true
+          @application_name = detect_application_name
+          say_status "detected", "existing separate database configuration", :green
+        end
+      end
+
       def select_database_mode
+        # Skip if existing config already detected database mode
+        return if @existing_install_detected && @database_mode
+
         # Skip if not interactive or if --separate_database was passed via CLI
         if options[:separate_database]
           @database_mode = :separate
@@ -333,6 +353,12 @@ module RailsErrorDashboard
         @enable_crash_capture = @selected_features&.dig(:crash_capture) || options[:crash_capture]
         @enable_diagnostic_dump = @selected_features&.dig(:diagnostic_dump) || options[:diagnostic_dump]
 
+        # Don't overwrite existing initializer on upgrade — user's config is precious
+        if @existing_install_detected
+          say_status "skip", "config/initializers/rails_error_dashboard.rb (preserving existing config)", :yellow
+          return
+        end
+
         template "initializer.rb", "config/initializers/rails_error_dashboard.rb"
       end
 
@@ -343,10 +369,17 @@ module RailsErrorDashboard
 
         FileUtils.mkdir_p(target_dir)
 
-        # Check which migrations are already installed (by descriptive name, ignoring timestamp)
-        existing = Dir.glob(File.join(target_dir, "*rails_error_dashboard*.rb")).map { |f|
-          File.basename(f).sub(/^\d+_/, "")
-        }.to_set
+        # Check BOTH migration directories to prevent cross-directory duplication (#93)
+        # A user who installed with separate DB and re-runs without the flag should not
+        # get duplicate migrations in db/migrate/
+        existing = Set.new
+        [ "db/migrate", "db/error_dashboard_migrate" ].each do |dir|
+          full_path = File.join(destination_root, dir)
+          next unless Dir.exist?(full_path)
+          Dir.glob(File.join(full_path, "*rails_error_dashboard*.rb")).each do |f|
+            existing.add(File.basename(f).sub(/^\d+_/, ""))
+          end
+        end
 
         timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
 

data/lib/rails_error_dashboard/commands/flush_swallowed_exceptions.rb

@@ -52,8 +52,8 @@ module RailsErrorDashboard
 
       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),
+          exception_class: truncate(class_name, 250),
+          raise_location: truncate(location, 250),
           rescue_location: nil,
           period_hour: period,
           application_id: app_id
@@ -70,9 +70,9 @@ module RailsErrorDashboard
 
       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,
+          exception_class: truncate(class_name, 250),
+          raise_location: truncate(raise_loc, 250),
+          rescue_location: rescue_loc.present? ? truncate(rescue_loc, 250) : nil,
           period_hour: period,
           application_id: app_id
         )

data/lib/rails_error_dashboard/configuration.rb

@@ -332,6 +332,12 @@ module RailsErrorDashboard
       errors = []
       warnings = []
 
+      # Block boot with default or blank credentials in production
+      if default_credentials? &&
+         defined?(Rails) && Rails.respond_to?(:env) && Rails.env.production?
+        errors << "Default or blank credentials cannot be used in production. Set ERROR_DASHBOARD_USER and ERROR_DASHBOARD_PASSWORD environment variables, or use authenticate_with for custom auth."
+      end
+
       # Validate sampling_rate (must be between 0.0 and 1.0)
       if sampling_rate && (sampling_rate < 0.0 || sampling_rate > 1.0)
         errors << "sampling_rate must be between 0.0 and 1.0 (got: #{sampling_rate})"
@@ -529,6 +535,18 @@ module RailsErrorDashboard
       true
     end
 
+    # Check if using default or blank demo credentials with basic auth
+    #
+    # @return [Boolean] true if basic auth is active with default gandalf/youshallnotpass or blank credentials
+    def default_credentials?
+      return false unless authenticate_with.nil?
+
+      default = dashboard_username == "gandalf" && dashboard_password == "youshallnotpass"
+      blank = dashboard_username.to_s.strip.empty? || dashboard_password.to_s.strip.empty?
+
+      default || blank
+    end
+
     # Get the effective user model (auto-detected if not configured)
     #
     # @return [String, nil] User model class name

data/lib/rails_error_dashboard/services/markdown_error_formatter.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Pure algorithm: Format error details as clean Markdown for LLM debugging
+    #
+    # Reads data already stored in ErrorLog — zero runtime cost.
+    # Called at display time only. Sections are conditional — only included
+    # when data is present.
+    #
+    # @example
+    #   RailsErrorDashboard::Services::MarkdownErrorFormatter.call(error, related_errors: related)
+    #   # => "# NoMethodError\n\nundefined method 'foo' for nil\n\n## Backtrace\n\n..."
+    class MarkdownErrorFormatter
+      MAX_BACKTRACE_LINES = 15
+      MAX_BREADCRUMBS = 10
+      MAX_VARIABLES = 10
+
+      # @param error [ErrorLog] An error log record
+      # @param related_errors [Array] Related error results with :error and :similarity
+      # @return [String] Markdown-formatted error details, or "" on failure
+      def self.call(error, related_errors: [])
+        new(error, related_errors).generate
+      rescue => e
+        ""
+      end
+
+      def initialize(error, related_errors)
+        @error = error
+        @related_errors = related_errors
+      end
+
+      # @return [String]
+      def generate
+        sections = []
+
+        sections << heading_section
+        sections << backtrace_section
+        sections << cause_chain_section
+        sections << local_variables_section
+        sections << instance_variables_section
+        sections << request_context_section
+        sections << breadcrumbs_section
+        sections << environment_section
+        sections << system_health_section
+        sections << related_errors_section
+        sections << metadata_section
+
+        sections.compact.join("\n\n")
+      rescue => e
+        ""
+      end
+
+      private
+
+      def heading_section
+        "# #{@error.error_type}\n\n#{@error.message}"
+      end
+
+      def backtrace_section
+        raw = @error.backtrace
+        return nil if raw.blank?
+
+        lines = raw.split("\n")
+        app_lines = lines.reject { |l| l.include?("/gems/") || l.include?("/ruby/") || l.include?("/vendor/") }
+        app_lines = lines.first(MAX_BACKTRACE_LINES) if app_lines.empty?
+        app_lines = app_lines.first(MAX_BACKTRACE_LINES)
+
+        "## Backtrace\n\n```\n#{app_lines.join("\n")}\n```"
+      end
+
+      def cause_chain_section
+        raw = @error.exception_cause
+        return nil if raw.blank?
+
+        causes = parse_json(raw)
+        return nil unless causes.is_a?(Array) && causes.any?
+
+        items = causes.each_with_index.map { |cause, i|
+          "#{i + 1}. **#{cause["class_name"]}** — #{cause["message"]}"
+        }
+
+        "## Exception Cause Chain\n\n#{items.join("\n")}"
+      end
+
+      def local_variables_section
+        raw = @error.local_variables
+        return nil if raw.blank?
+
+        vars = parse_json(raw)
+        return nil unless vars.is_a?(Hash) && vars.any?
+
+        rows = vars.first(MAX_VARIABLES).map { |name, info|
+          if info.is_a?(Hash)
+            "| #{name} | #{info["type"]} | #{truncate_value(info["value"])} |"
+          else
+            "| #{name} | — | #{truncate_value(info)} |"
+          end
+        }
+
+        "## Local Variables\n\n| Variable | Type | Value |\n|----------|------|-------|\n#{rows.join("\n")}"
+      end
+
+      def instance_variables_section
+        raw = @error.instance_variables
+        return nil if raw.blank?
+
+        vars = parse_json(raw)
+        return nil unless vars.is_a?(Hash) && vars.any?
+
+        self_class = vars.delete("_self_class")
+        return nil if vars.empty? && self_class.nil?
+
+        lines = []
+        lines << "**Class:** #{self_class}" if self_class
+
+        if vars.any?
+          rows = vars.first(MAX_VARIABLES).map { |name, info|
+            if info.is_a?(Hash)
+              "| #{name} | #{info["type"]} | #{truncate_value(info["value"])} |"
+            else
+              "| #{name} | — | #{truncate_value(info)} |"
+            end
+          }
+          lines << "| Variable | Type | Value |\n|----------|------|-------|\n#{rows.join("\n")}"
+        end
+
+        "## Instance Variables\n\n#{lines.join("\n\n")}"
+      end
+
+      def request_context_section
+        return nil if @error.request_url.blank?
+
+        items = []
+        items << "- **Method:** #{@error.http_method}" if @error.http_method.present?
+        items << "- **URL:** #{@error.request_url}"
+        items << "- **Hostname:** #{@error.hostname}" if @error.hostname.present?
+        items << "- **Content-Type:** #{@error.content_type}" if @error.content_type.present?
+        items << "- **Duration:** #{@error.request_duration_ms}ms" if @error.request_duration_ms.present?
+        items << "- **IP:** #{@error.ip_address}" if @error.ip_address.present?
+
+        "## Request Context\n\n#{items.join("\n")}"
+      end
+
+      def breadcrumbs_section
+        raw = @error.breadcrumbs
+        return nil if raw.blank?
+
+        crumbs = parse_json(raw)
+        return nil unless crumbs.is_a?(Array) && crumbs.any?
+
+        # Take last N breadcrumbs (most recent, closest to error)
+        crumbs = crumbs.last(MAX_BREADCRUMBS)
+
+        rows = crumbs.map { |c|
+          time = c["t"] ? Time.at(c["t"] / 1000.0).utc.strftime("%H:%M:%S.%L") : "—"
+          duration = c["d"] ? "#{c["d"]}ms" : "—"
+          "| #{time} | #{c["c"]} | #{truncate_value(c["m"], 80)} | #{duration} |"
+        }
+
+        "## Breadcrumbs (last #{crumbs.size})\n\n| Time | Category | Message | Duration |\n|------|----------|---------|----------|\n#{rows.join("\n")}"
+      end
+
+      def environment_section
+        raw = @error.environment_info
+        return nil if raw.blank?
+
+        env = parse_json(raw)
+        return nil unless env.is_a?(Hash) && env.any?
+
+        items = []
+        items << "- **Ruby:** #{env["ruby_version"]}" if env["ruby_version"]
+        items << "- **Rails:** #{env["rails_version"]}" if env["rails_version"]
+        items << "- **Env:** #{env["rails_env"]}" if env["rails_env"]
+        items << "- **Server:** #{env["server"]}" if env["server"]
+        items << "- **DB:** #{env["database_adapter"]}" if env["database_adapter"]
+
+        version_line = []
+        version_line << "- **App Version:** #{@error.app_version}" if @error.app_version.present?
+        version_line << "- **Git:** #{@error.git_sha}" if @error.git_sha.present?
+        items.concat(version_line)
+
+        return nil if items.empty?
+
+        "## Environment\n\n#{items.join("\n")}"
+      end
+
+      def system_health_section
+        raw = @error.system_health
+        return nil if raw.blank?
+
+        health = parse_json(raw)
+        return nil unless health.is_a?(Hash) && health.any?
+
+        items = []
+        items << "- **Memory:** #{health["process_memory_mb"]} MB RSS" if health["process_memory_mb"]
+        items << "- **Threads:** #{health["thread_count"]}" if health["thread_count"]
+
+        pool = health["connection_pool"]
+        if pool.is_a?(Hash)
+          items << "- **DB Pool:** #{pool["busy"]}/#{pool["size"]} busy" if pool["size"]
+        end
+
+        gc = health["gc_stats"]
+        if gc.is_a?(Hash)
+          items << "- **GC:** #{gc["major_gc_count"]} major cycles" if gc["major_gc_count"]
+        end
+
+        return nil if items.empty?
+
+        "## System Health at Error Time\n\n#{items.join("\n")}"
+      end
+
+      def related_errors_section
+        return nil if @related_errors.nil? || @related_errors.empty?
+
+        items = @related_errors.map { |r|
+          pct = (r.similarity * 100).round(1)
+          "- `#{r.error.error_type}` — #{r.error.message} (#{pct}% similar, #{r.error.occurrence_count} occurrences)"
+        }
+
+        "## Related Errors\n\n#{items.join("\n")}"
+      end
+
+      def metadata_section
+        items = []
+        items << "- **Severity:** #{@error.severity}" if @error.severity.present?
+        items << "- **Status:** #{@error.status}" if @error.status.present?
+        items << "- **Priority:** P#{3 - @error.priority_level}" if @error.priority_level.present?
+        items << "- **Platform:** #{@error.platform}" if @error.platform.present?
+        items << "- **First seen:** #{@error.first_seen_at&.utc&.strftime("%Y-%m-%d %H:%M:%S UTC")}" if @error.first_seen_at
+        items << "- **Occurrences:** #{@error.occurrence_count}" if @error.occurrence_count
+        items << "- **Assigned to:** #{@error.assigned_to}" if @error.assigned_to.present?
+
+        "## Metadata\n\n#{items.join("\n")}"
+      end
+
+      def parse_json(raw)
+        return nil if raw.blank?
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def truncate_value(value, max_length = 200)
+        str = value.to_s
+        str.length > max_length ? "#{str[0...max_length]}..." : str
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/system_health_snapshot.rb

@@ -4,16 +4,21 @@ module RailsErrorDashboard
   module Services
     # Pure algorithm: Capture runtime health metrics at error time
     #
-    # Captures GC stats, process RSS memory, thread count, connection pool stats,
-    # and Puma stats. NOT memoized — fresh data every call (unlike EnvironmentSnapshot).
+    # Captures GC stats, process memory (RSS/swap/peak), thread count, connection pool,
+    # Puma stats, job queue, RubyVM/YJIT, ActionCable, file descriptors, system load,
+    # system memory pressure, GC context, and TCP connection states.
+    #
+    # NOT memoized — fresh data every call (unlike EnvironmentSnapshot).
     # Every metric call individually wrapped in rescue => nil.
     #
     # Safety contract (from HOST_APP_SAFETY.md):
-    # - Total snapshot < 1ms budget
+    # - Total snapshot < 1ms budget (~0.3ms typical on Linux)
     # - NEVER ObjectSpace.each_object or ObjectSpace.count_objects (heap scan)
     # - NEVER Thread.list.map(&:backtrace) (GVL hold)
     # - Thread.list.count only (O(1), safe)
-    # - Process memory: Linux procfs ONLY, no fork/subprocess ever
+    # - Process/system metrics: Linux procfs ONLY, no fork/subprocess ever
+    # - All procfs reads guarded with File.exist? — returns nil on macOS/non-Linux
+    # - TCP file size guard (skip if > 1MB) to protect against connection leak scenarios
     # - No new gems, no global state, no Thread.current, no mutex
     class SystemHealthSnapshot
       # Capture current system health metrics
@@ -27,9 +32,12 @@ module RailsErrorDashboard
 
       # @return [Hash] Health snapshot
       def capture
+        mem = process_memory
         {
           gc: gc_stats,
-          process_memory_mb: process_memory_mb,
+          gc_latest: gc_latest,
+          process_memory: mem,
+          process_memory_mb: mem&.dig(:rss_mb),  # backward compat
           thread_count: thread_count,
           connection_pool: connection_pool_stats,
           puma: puma_stats,
@@ -37,6 +45,10 @@ module RailsErrorDashboard
           ruby_vm: ruby_vm_stats,
           yjit: yjit_stats,
           actioncable: actioncable_stats,
+          file_descriptors: file_descriptors,
+          system_load: system_load,
+          system_memory: system_memory,
+          tcp_connections: tcp_connections,
           captured_at: Time.current.iso8601
         }
       end
@@ -55,13 +67,33 @@ module RailsErrorDashboard
         nil
       end
 
-      def process_memory_mb
-        # Linux ONLY — procfs read, no fork, ~0.01ms
+      # GC.latest_gc_info — context about the most recent GC run
+      # Works on all platforms (Ruby API, no procfs)
+      def gc_latest
+        info = GC.latest_gc_info
+        {
+          major_by: info[:major_by]&.to_s,
+          gc_by: info[:gc_by]&.to_s,
+          state: info[:state]&.to_s,
+          immediate_sweep: info[:immediate_sweep]
+        }
+      rescue => e
+        nil
+      end
+
+      # Process memory from /proc/self/status — single file read, 4 fields extracted
+      # Linux ONLY — returns nil on macOS/non-Linux (~0.02ms)
+      def process_memory
         return nil unless File.exist?("/proc/self/status")
-        content = File.read("/proc/self/status")
-        match = content.match(/VmRSS:\s+(\d+)\s+kB/)
-        return nil unless match
-        (match[1].to_i / 1024.0).round(1)
+        status = File.read("/proc/self/status")
+        rss = status[/^VmRSS:\s+(\d+)/, 1]&.to_i
+        return nil unless rss
+        {
+          rss_mb: (rss / 1024.0).round(1),
+          swap_mb: (status[/^VmSwap:\s+(\d+)/, 1].to_i / 1024.0).round(1),
+          rss_peak_mb: (status[/^VmHWM:\s+(\d+)/, 1].to_i / 1024.0).round(1),
+          os_threads: status[/^Threads:\s+(\d+)/, 1]&.to_i
+        }
       rescue => e
         nil
       end
@@ -186,6 +218,88 @@ module RailsErrorDashboard
       rescue => e
         nil
       end
+
+      # File descriptor count vs ulimit — detects FD exhaustion
+      # Linux ONLY — /proc/self/fd (~0.05ms)
+      def file_descriptors
+        return nil unless File.exist?("/proc/self/fd")
+        open_count = Dir.children("/proc/self/fd").size
+        soft_limit, _hard = Process.getrlimit(:NOFILE)
+        {
+          open: open_count,
+          limit: soft_limit,
+          utilization_pct: soft_limit > 0 ? (open_count.to_f / soft_limit * 100).round(1) : nil
+        }
+      rescue => e
+        nil
+      end
+
+      # System load averages from /proc/loadavg + CPU count
+      # Linux ONLY — returns nil on macOS (~0.01ms)
+      def system_load
+        return nil unless File.exist?("/proc/loadavg")
+        parts = File.read("/proc/loadavg").split
+        require "etc" unless defined?(Etc)
+        cpu_count = Etc.nprocessors rescue nil
+        load_1m = parts[0].to_f
+        {
+          load_1m: load_1m,
+          load_5m: parts[1].to_f,
+          load_15m: parts[2].to_f,
+          cpu_count: cpu_count,
+          load_ratio: cpu_count && cpu_count > 0 ? (load_1m / cpu_count).round(2) : nil
+        }
+      rescue => e
+        nil
+      end
+
+      # System-wide memory pressure from /proc/meminfo
+      # Linux ONLY — returns nil on macOS (~0.02ms)
+      def system_memory
+        return nil unless File.exist?("/proc/meminfo")
+        meminfo = File.read("/proc/meminfo")
+        total = meminfo[/^MemTotal:\s+(\d+)/, 1]&.to_i
+        available = meminfo[/^MemAvailable:\s+(\d+)/, 1]&.to_i
+        swap_total = meminfo[/^SwapTotal:\s+(\d+)/, 1]&.to_i
+        swap_free = meminfo[/^SwapFree:\s+(\d+)/, 1]&.to_i
+        {
+          total_mb: total ? (total / 1024.0).round(0) : nil,
+          available_mb: available ? (available / 1024.0).round(0) : nil,
+          used_pct: total && available && total > 0 ? ((1 - available.to_f / total) * 100).round(1) : nil,
+          swap_used_mb: swap_total && swap_free ? ((swap_total - swap_free) / 1024.0).round(0) : nil
+        }
+      rescue => e
+        nil
+      end
+
+      # TCP connection states from /proc/self/net/tcp (+tcp6)
+      # Linux ONLY — returns nil on macOS (~0.05ms typical)
+      # Safety: skips if file > 1MB (protects against connection leak scenarios)
+      def tcp_connections
+        path = "/proc/self/net/tcp"
+        return nil unless File.exist?(path)
+        return nil if File.size(path) > 1_048_576
+        lines = File.readlines(path).drop(1)
+        states = lines.map { |l| l.strip.split[3] }
+        result = {
+          established: states.count("01"),
+          close_wait: states.count("08"),
+          time_wait: states.count("06"),
+          listen: states.count("0A")
+        }
+        path6 = "/proc/self/net/tcp6"
+        if File.exist?(path6) && File.size(path6) <= 1_048_576
+          lines6 = File.readlines(path6).drop(1)
+          states6 = lines6.map { |l| l.strip.split[3] }
+          result[:established] += states6.count("01")
+          result[:close_wait] += states6.count("08")
+          result[:time_wait] += states6.count("06")
+          result[:listen] += states6.count("0A")
+        end
+        result
+      rescue => e
+        nil
+      end
     end
   end
 end

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.5.1"
+  VERSION = "0.5.3"
 end

data/lib/rails_error_dashboard.rb

@@ -55,6 +55,7 @@ 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/markdown_error_formatter"
 require "rails_error_dashboard/services/database_health_inspector"
 require "rails_error_dashboard/services/cache_analyzer"
 require "rails_error_dashboard/services/variable_serializer"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.3
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -340,6 +340,7 @@ files:
 - db/migrate/20260306000003_create_rails_error_dashboard_swallowed_exceptions.rb
 - db/migrate/20260307000001_create_rails_error_dashboard_diagnostic_dumps.rb
 - db/migrate/20260323000001_add_muted_to_error_logs.rb
+- db/migrate/20260325000001_fix_swallowed_exceptions_index_for_mysql.rb
 - lib/generators/rails_error_dashboard/install/install_generator.rb
 - lib/generators/rails_error_dashboard/install/templates/README
 - lib/generators/rails_error_dashboard/install/templates/initializer.rb
@@ -428,6 +429,7 @@ files:
 - lib/rails_error_dashboard/services/git_blame_reader.rb
 - lib/rails_error_dashboard/services/github_link_generator.rb
 - lib/rails_error_dashboard/services/local_variable_capturer.rb
+- lib/rails_error_dashboard/services/markdown_error_formatter.rb
 - lib/rails_error_dashboard/services/n_plus_one_detector.rb
 - lib/rails_error_dashboard/services/notification_helpers.rb
 - lib/rails_error_dashboard/services/notification_throttler.rb
@@ -465,7 +467,7 @@ metadata:
   bug_tracker_uri: https://github.com/AnjanJ/rails_error_dashboard/issues
   funding_uri: https://buymeacoffee.com/anjanj
 post_install_message: "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n
-  \ Rails Error Dashboard v0.5.1\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n\U0001F195
+  \ Rails Error Dashboard v0.5.3\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n\U0001F195
   First time? Quick start:\n   rails generate rails_error_dashboard:install\n   rails
   db:migrate\n   # Add to config/routes.rb:\n   mount RailsErrorDashboard::Engine
   => '/error_dashboard'\n\n\U0001F504 Upgrading from v0.1.x?\n   rails db:migrate\n