rails_error_dashboard 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af41ac0baefaf436b68c2db7ac1598a15f409cb76efbbf2eb8fb2daa9ceaab92
-  data.tar.gz: 22073a8675b855c06622dc34ae649608af129f57f5c391c9562c20bd95db53ec
+  metadata.gz: d1826105c19a4a203cf377fca2041763849b7b2ff7bb8a9f3a18601e22150f6b
+  data.tar.gz: fdabbc92770c81339e7499d739e941f4f2a7f3fda381a2a55ec4dcab5bb757cc
 SHA512:
-  metadata.gz: badaacf9fb78a5d93ee3d545d93877cc59c8685f8800567ad6f84979cec365baebd3f3193b905bbf73b67f99c70308c2480043bfb78c38f0a1b149637f1595c4
-  data.tar.gz: 548db884ddfcb084293083c3e8b787bdc50d0fd2128b8f68bdc315f578199ce9c36ef805a038657d437864055ee45e9f5bfc41ef6386be6e5b3c750be40ed238
+  metadata.gz: 6c365ae991e67cb59dd9e62deaabe694e06c7e9b64896a75bfa36473f3c735556c95482a929e8ade0328ffab05e10128e5d5e6832c94ead44cfffcf6567c05aa
+  data.tar.gz: 6b63c5a587bf93ec1599571343c8fcaf8230364266d97564f59217d8308632817557a05fec2398f3e3557ca33d83dbc9968c3f820722e3b1395e046cd58de15a

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

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

@@ -1664,6 +1664,13 @@ body.dark-mode .sidebar-section-body { background: var(--ctp-mantle); }
                   <% end %>
                 </li>
               <% end %>
+              <% if RailsErrorDashboard.configuration.enable_actioncable_tracking && RailsErrorDashboard.configuration.enable_breadcrumbs %>
+                <li class="nav-item">
+                  <%= link_to actioncable_health_summary_errors_path(nav_params), class: "nav-link #{request.path == actioncable_health_summary_errors_path ? 'active' : ''}" do %>
+                    <i class="bi bi-broadcast"></i> ActionCable
+                  <% end %>
+                </li>
+              <% end %>
               <% if RailsErrorDashboard.configuration.enable_system_health %>
                 <li class="nav-item">
                   <%= link_to job_health_summary_errors_path(nav_params), class: "nav-link #{request.path == job_health_summary_errors_path ? 'active' : ''}" do %>

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/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
+        if content.match?(/config\.use_separate_database\s*=\s*true/)
+          @database_mode = :separate
+          @database_name = content[/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/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.0"
+  VERSION = "0.5.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -465,7 +465,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.0\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n\U0001F195
+  \ Rails Error Dashboard v0.5.2\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