rails_error_dashboard 0.5.11 → 0.5.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e91844bfccd6f88a89ad933cb4f100bb79e941f5b43a78155b6b21a46a58fffb
-  data.tar.gz: fffcde71a4ed1859cf70ef17ed7eca18531ac9d6be9f17fb3d1a9deceba4e0ca
+  metadata.gz: 2c512995247150c6d418591b4ea85b40778b37c5b484666cf2af2226cbad9da7
+  data.tar.gz: 72283fdf63f2ea4fac3cdde62098bc247c4262862fbd8dd2ef80b5b804fcd626
 SHA512:
-  metadata.gz: ab28a1843285439c9874a8d3552e5dceda81f4ced4cbc1d8d0ee6950a772758a1769f0a323bc207f2884c991c22d3938551b5b0a25f693ab19c6c5d0d0da23a7
-  data.tar.gz: a921a83a5fafceb78323dc3f2c48d559c722efbbf79b2708113f5c9d482ace9c2347700415aeee63e1af864d11a036bdc08ba43cfd860f2f28ea0621c8c7eb30
+  metadata.gz: 5a66093c81993d0af82915235a2da1bbb5d0ba6779a9882d2e87bb90b4d98012d9d3f4be91703c570ac9253cd346d17f53a5eb8e21f9cc6bf44728e72ec23ef1
+  data.tar.gz: '06290bf609e62810e613530eceff8dcc86936a8b39f7e27c5ac0b8bd2ba5090f05e2df7ed4b86f1ca6d732fa849cfeea6d3fd361f4ef79e9a304fd010239f8ad'

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

@@ -2,7 +2,7 @@
   <td onclick="event.stopPropagation();">
     <input type="checkbox" class="error-checkbox form-check-input" value="<%= error.id %>" data-error-id="<%= error.id %>">
   </td>
-  <td onclick="window.location='<%= error_path(error) %>';">
+  <td onclick="window.location='<%= rails_error_dashboard.error_path(error) %>';">
     <% severity = error.severity %>
     <% if severity == :critical %>
       <span class="badge bg-danger" data-bs-toggle="tooltip" title="Critical severity - requires immediate attention">CRITICAL</span>
@@ -17,7 +17,7 @@
       <br><small class="text-muted" data-bs-toggle="tooltip" title="Priority score (0-100) based on severity, frequency, recency, and user impact">P<%= error.priority_score %></small>
     <% end %>
   </td>
-  <td onclick="window.location='<%= error_path(error) %>';">
+  <td onclick="window.location='<%= rails_error_dashboard.error_path(error) %>';">
     <code class="text-danger" data-bs-toggle="tooltip" title="<%= error.error_type %>"><%= error.error_type.split('::').last %></code>
     <% if error.recent? %>
       <span class="badge bg-success ms-1" data-bs-toggle="tooltip" title="Error occurred within the last hour">NEW</span>
@@ -26,29 +26,29 @@
       <br><small class="badge bg-light text-dark" data-bs-toggle="tooltip" title="App version when error occurred">v<%= error.app_version %></small>
     <% end %>
   </td>
-  <td onclick="window.location='<%= error_path(error) %>';">
+  <td onclick="window.location='<%= rails_error_dashboard.error_path(error) %>';">
     <div class="text-truncate" style="max-width: 300px;" title="<%= error.message %>">
       <%= error.message %>
     </div>
   </td>
-  <td onclick="window.location='<%= error_path(error) %>';">
+  <td onclick="window.location='<%= rails_error_dashboard.error_path(error) %>';">
     <span class="badge bg-primary"><%= error.occurrence_count %>x</span>
   </td>
-  <td onclick="window.location='<%= error_path(error) %>';">
+  <td onclick="window.location='<%= rails_error_dashboard.error_path(error) %>';">
     <small>
       <strong>First:</strong> <%= local_time(error.first_seen_at, format: :short) %><br>
       <strong>Last:</strong> <%= local_time(error.last_seen_at, format: :short) %>
     </small>
   </td>
   <% if local_assigns[:show_application] %>
-    <td onclick="window.location='<%= error_path(error) %>';">
+    <td onclick="window.location='<%= rails_error_dashboard.error_path(error) %>';">
       <span class="badge bg-info">
         <%= error.application&.name || 'Unknown' %>
       </span>
     </td>
   <% end %>
   <% if local_assigns[:show_platform] %>
-    <td onclick="window.location='<%= error_path(error) %>';">
+    <td onclick="window.location='<%= rails_error_dashboard.error_path(error) %>';">
       <% if error.platform == 'iOS' %>
         <span class="badge badge-ios"><i class="bi bi-apple"></i> iOS</span>
       <% elsif error.platform == 'Android' %>
@@ -60,7 +60,7 @@
       <% end %>
     </td>
   <% end %>
-  <td onclick="window.location='<%= error_path(error) %>';">
+  <td onclick="window.location='<%= rails_error_dashboard.error_path(error) %>';">
     <% if error.user_id %>
       <small data-bs-toggle="tooltip" title="User affected by this error">User #<%= error.user_id %></small>
       <% if error.respond_to?(:user_impact_percentage) %>
@@ -73,7 +73,7 @@
       <small class="text-muted" data-bs-toggle="tooltip" title="No specific user affected">-</small>
     <% end %>
   </td>
-  <td onclick="window.location='<%= error_path(error) %>';">
+  <td onclick="window.location='<%= rails_error_dashboard.error_path(error) %>';">
     <% if error.resolved? %>
       <i class="bi bi-check-circle-fill text-success"
          data-bs-toggle="tooltip"
@@ -95,7 +95,7 @@
     <% end %>
   </td>
   <td onclick="event.stopPropagation();">
-    <%= link_to error_path(error), class: "btn btn-sm btn-outline-primary" do %>
+    <%= link_to rails_error_dashboard.error_path(error), class: "btn btn-sm btn-outline-primary" do %>
       <i class="bi bi-eye"></i>
     <% end %>
   </td>

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

@@ -205,7 +205,7 @@
               should_show = show_if_key.nil? || @config.send(show_if_key)
               next unless should_show
 
-              value = @config.send(setting_key)
+              value = @config.send(setting_meta[:method] || setting_key)
             %>
             <div class="col-md-6 mb-3">
               <div class="d-flex justify-content-between align-items-center">

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

@@ -15,7 +15,7 @@ module RailsErrorDashboard
       class_option :pagerduty, type: :boolean, default: false, desc: "Enable PagerDuty notifications"
       class_option :webhooks, type: :boolean, default: false, desc: "Enable webhook notifications"
       # Performance options
-      class_option :async_logging, type: :boolean, default: false, desc: "Enable async error logging"
+      class_option :async_logging, type: :boolean, default: true, desc: "Enable async error logging (default: true, uses Rails :async adapter — no extra infrastructure needed)"
       class_option :error_sampling, type: :boolean, default: false, desc: "Enable error sampling (reduce volume)"
       class_option :separate_database, type: :boolean, default: false, desc: "Use separate database for errors"
       class_option :database, type: :string, default: nil, desc: "Database name to use for errors (e.g., 'error_dashboard')"
@@ -35,11 +35,13 @@ module RailsErrorDashboard
       class_option :swallowed_exceptions, type: :boolean, default: false, desc: "Enable swallowed exception detection (Ruby 3.3+)"
       class_option :crash_capture, type: :boolean, default: false, desc: "Enable process crash capture via at_exit hook"
       class_option :diagnostic_dump, type: :boolean, default: false, desc: "Enable on-demand diagnostic dump"
+      class_option :quick, type: :boolean, default: false, desc: "Zero-prompt install with sensible defaults (~60 seconds to working dashboard)"
 
       def welcome_message
         say "\n"
         say "=" * 70
-        say "  📊 Rails Error Dashboard Installation", :cyan
+        say "  Rails Error Dashboard Installation", :cyan
+        say "  Quick mode: zero prompts, working dashboard in ~60 seconds", :yellow if quick_mode?
         say "=" * 70
         say "\n"
         say "Core features will be enabled automatically:", :green
@@ -52,7 +54,15 @@ module RailsErrorDashboard
       end
 
       def select_optional_features
-        return unless options[:interactive] && behavior == :invoke
+        return unless behavior == :invoke
+
+        if quick_mode?
+          @selected_features = build_quick_defaults
+          say "  Using sensible defaults (analytics ON, notifications OFF, breadcrumbs OFF)", :green
+          return
+        end
+
+        return unless options[:interactive]
         return unless $stdin.tty?  # Skip interactive mode if not running in a terminal
 
         say "Let's configure optional features...\n", :cyan
@@ -60,166 +70,116 @@ module RailsErrorDashboard
 
         @selected_features = {}
 
-        # Feature definitions with descriptions - organized by category
-        # Note: separate_database is handled separately via select_database_mode
-        features = [
-          # === NOTIFICATIONS ===
-          {
-            key: :slack,
-            name: "Slack Notifications",
-            description: "Send error alerts to Slack channels",
-            category: "Notifications"
-          },
-          {
-            key: :email,
-            name: "Email Notifications",
-            description: "Send error alerts via email",
-            category: "Notifications"
-          },
-          {
-            key: :discord,
-            name: "Discord Notifications",
-            description: "Send error alerts to Discord",
-            category: "Notifications"
-          },
-          {
-            key: :pagerduty,
-            name: "PagerDuty Integration",
-            description: "Critical errors to PagerDuty",
-            category: "Notifications"
-          },
-          {
-            key: :webhooks,
-            name: "Generic Webhooks",
-            description: "Send data to custom endpoints",
-            category: "Notifications"
-          },
-
-          # === PERFORMANCE & SCALABILITY ===
-          {
-            key: :async_logging,
-            name: "Async Error Logging",
-            description: "Process errors in background jobs (faster responses)",
-            category: "Performance"
-          },
-          {
-            key: :error_sampling,
-            name: "Error Sampling",
-            description: "Log only % of non-critical errors (reduce volume)",
-            category: "Performance"
-          },
-
-          # === ADVANCED ANALYTICS ===
-          {
-            key: :baseline_alerts,
-            name: "Baseline Anomaly Alerts",
-            description: "Auto-detect unusual error rate spikes",
-            category: "Advanced Analytics"
-          },
-          {
-            key: :similar_errors,
-            name: "Fuzzy Error Matching",
-            description: "Find similar errors across different hashes",
-            category: "Advanced Analytics"
-          },
-          {
-            key: :co_occurring_errors,
-            name: "Co-occurring Errors",
-            description: "Detect errors that happen together",
-            category: "Advanced Analytics"
-          },
-          {
-            key: :error_cascades,
-            name: "Error Cascade Detection",
-            description: "Identify error chains (A causes B causes C)",
-            category: "Advanced Analytics"
-          },
-          {
-            key: :error_correlation,
-            name: "Error Correlation Analysis",
-            description: "Correlate with versions, users, time",
-            category: "Advanced Analytics"
-          },
-          {
-            key: :platform_comparison,
-            name: "Platform Comparison",
-            description: "Compare iOS vs Android vs Web health",
-            category: "Advanced Analytics"
-          },
-          {
-            key: :occurrence_patterns,
-            name: "Occurrence Pattern Detection",
-            description: "Detect cyclical patterns and bursts",
-            category: "Advanced Analytics"
-          },
-
-          # === DEVELOPER TOOLS ===
-          {
-            key: :source_code_integration,
-            name: "Source Code Integration (NEW!)",
-            description: "View source code directly in error details",
-            category: "Developer Tools"
-          },
-          {
-            key: :git_blame,
-            name: "Git Blame Integration (NEW!)",
-            description: "Show git blame info (author, commit, timestamp)",
-            category: "Developer Tools"
-          },
-          {
-            key: :breadcrumbs,
-            name: "Breadcrumbs (NEW!)",
-            description: "Capture request activity trail (SQL, controller, cache events)",
-            category: "Developer Tools"
-          },
-          {
-            key: :system_health,
-            name: "System Health Snapshot (NEW!)",
-            description: "Capture GC, memory, threads, connection pool at error time",
-            category: "Developer Tools"
-          },
-          {
-            key: :swallowed_exceptions,
-            name: "Swallowed Exception Detection (Ruby 3.3+)",
-            description: "Detect exceptions being silently rescued via TracePoint(:rescue)",
-            category: "Developer Tools"
-          },
-          {
-            key: :crash_capture,
-            name: "Process Crash Capture",
-            description: "Capture fatal crashes via at_exit hook (written to disk, imported on next boot)",
-            category: "Developer Tools"
-          },
-          {
-            key: :diagnostic_dump,
-            name: "Diagnostic Dump",
-            description: "On-demand system state snapshot (rake task + dashboard page)",
-            category: "Developer Tools"
-          }
-        ]
-
-        features.each_with_index do |feature, index|
-          say "\n[#{index + 1}/#{features.length}] #{feature[:name]}", :cyan
-          say "    #{feature[:description]}", :white
-
-          # Check if feature was passed via command line option
-          if options[feature[:key]]
-            @selected_features[feature[:key]] = true
-            say "    ✓ Enabled (via --#{feature[:key]} flag)", :green
-          else
-            response = ask("    Enable? (y/N):", :yellow, limited_to: [ "y", "Y", "n", "N", "" ])
-            @selected_features[feature[:key]] = response.downcase == "y"
+        # =====================================================================
+        # QUESTION 1: Notifications (gated — one y/N opens 5 sub-questions)
+        # =====================================================================
+        notification_keys = %i[slack email discord pagerduty webhooks]
+        any_notification_cli_flag = notification_keys.any? { |k| options[k] }
+
+        say "[1/3] Notifications [background/dashboard only — zero request overhead]", :cyan
+        say "    Alert your team via Slack, email, Discord, PagerDuty, or webhooks.", :white
 
-            if @selected_features[feature[:key]]
-              say "    ✓ Enabled", :green
-            else
-              say "    ✗ Disabled", :white
+        if any_notification_cli_flag
+          # Individual CLI flags passed — respect them, skip the gate prompt
+          notification_keys.each { |k| @selected_features[k] = options[k] }
+          say "    ✓ Using CLI flags for notification channels", :green
+        else
+          wants_notifications = ask("    Set up notifications? (y/N):", :yellow, limited_to: [ "y", "Y", "n", "N", "" ])
+          if wants_notifications.downcase == "y"
+            notification_channels = [
+              { key: :slack,      name: "Slack",     hint: "SLACK_WEBHOOK_URL" },
+              { key: :email,      name: "Email",     hint: "ERROR_NOTIFICATION_EMAILS" },
+              { key: :discord,    name: "Discord",   hint: "DISCORD_WEBHOOK_URL" },
+              { key: :pagerduty,  name: "PagerDuty", hint: "PAGERDUTY_INTEGRATION_KEY" },
+              { key: :webhooks,   name: "Webhooks",  hint: "WEBHOOK_URLS" }
+            ]
+            notification_channels.each do |ch|
+              r = ask("      #{ch[:name]}? (ENV[#{ch[:hint]}]) (y/N):", :yellow, limited_to: [ "y", "Y", "n", "N", "" ])
+              @selected_features[ch[:key]] = r.downcase == "y"
             end
+          else
+            notification_keys.each { |k| @selected_features[k] = false }
+            say "    ✓ Notifications off (enable anytime in initializer)", :white
           end
+        end
 
-          if @selected_features[feature[:key]] && feature[:key] == :swallowed_exceptions && RUBY_VERSION < "3.3"
-            say "    ⚠ Warning: This feature requires Ruby 3.3+ (you have #{RUBY_VERSION})", :yellow
-            say "    The feature will be included in your config but won't activate until you upgrade Ruby.", :white
+        # =====================================================================
+        # QUESTION 2: Advanced Analytics (grouped — defaults YES)
+        # =====================================================================
+        analytics_keys = %i[baseline_alerts similar_errors co_occurring_errors
+                             error_cascades error_correlation platform_comparison occurrence_patterns]
+        any_analytics_cli_flag = analytics_keys.any? { |k| options[k] }
+
+        say "\n[2/3] Advanced Analytics (7 features) [background/dashboard only]", :cyan
+        say "    Baseline alerts, fuzzy matching, co-occurring errors, cascade detection,", :white
+        say "    correlation analysis, platform comparison, occurrence patterns.", :white
+        say "    All run at query time or as background jobs — zero request-path overhead.", :white
+
+        if any_analytics_cli_flag
+          # Let create_initializer_file read options[] directly via the &.dig fallback
+          say "    ✓ Using individual CLI flags for analytics", :white
+        else
+          response = ask("    Enable all? (Y/n):", :yellow, limited_to: [ "y", "Y", "n", "N", "" ])
+          analytics_on = response.downcase != "n"
+          analytics_keys.each { |k| @selected_features[k] = analytics_on }
+          say analytics_on ? "    ✓ All 7 analytics features enabled" : "    ✗ Analytics disabled (enable individually in initializer)", analytics_on ? :green : :white
+        end
+
+        # =====================================================================
+        # QUESTION 3: Advanced Options (gated — defaults NO)
+        # =====================================================================
+        advanced_keys = %i[async_logging error_sampling breadcrumbs system_health
+                           source_code_integration git_blame swallowed_exceptions
+                           crash_capture diagnostic_dump]
+        any_advanced_cli_flag = advanced_keys.any? { |k| options[k] }
+
+        say "\n[3/3] Advanced Options (performance tuning & diagnostics)", :cyan
+        say "    Async logging, error sampling, breadcrumbs, system health,", :white
+        say "    source code viewer, git blame, crash capture, and more.", :white
+
+        if any_advanced_cli_flag
+          # CLI flags passed — set them and skip the gate
+          advanced_features = [
+            { key: :async_logging,           name: "Async Logging",                  desc: "Process errors in background jobs [removes request-path overhead]" },
+            { key: :error_sampling,          name: "Error Sampling",                 desc: "Log only % of non-critical errors [error-time only]" },
+            { key: :breadcrumbs,             name: "Breadcrumbs",                    desc: "6 AS::Notifications subscribers: SQL, cache, jobs, mailers, Rack::Attack, ActionCable [request-path overhead]" },
+            { key: :system_health,           name: "System Health Snapshot",         desc: "GC, memory, threads, connection pool at error time [error-time only]" },
+            { key: :source_code_integration, name: "Source Code Integration",        desc: "Inline source viewer in error details [dashboard only]" },
+            { key: :git_blame,               name: "Git Blame",                      desc: "Author, commit, timestamp per source line [dashboard only]" },
+            { key: :swallowed_exceptions,    name: "Swallowed Exception Detection",  desc: "TracePoint(:rescue) catches silently rescued exceptions [request-path overhead, Ruby 3.3+]" },
+            { key: :crash_capture,           name: "Process Crash Capture",          desc: "at_exit hook captures fatal crashes [error-time only]" },
+            { key: :diagnostic_dump,         name: "Diagnostic Dump",                desc: "On-demand system snapshot via rake task [background/dashboard only]" }
+          ]
+          advanced_features.each { |f| @selected_features[f[:key]] = options[f[:key]] }
+          say "    ✓ Using CLI flags for advanced options", :white
+        else
+          wants_advanced = ask("    Configure advanced options? (y/N):", :yellow, limited_to: [ "y", "Y", "n", "N", "" ])
+          if wants_advanced.downcase == "y"
+            advanced_features = [
+              { key: :async_logging,           name: "Async Logging",                  desc: "Process errors in background jobs — removes overhead from request path [removes request-path overhead]" },
+              { key: :error_sampling,          name: "Error Sampling",                 desc: "Log only % of non-critical errors to reduce volume [error-time only]" },
+              { key: :breadcrumbs,             name: "Breadcrumbs",                    desc: "Subscribes 6 AS::Notifications: SQL, cache, jobs, mailers, Rack::Attack, ActionCable [request-path overhead]" },
+              { key: :system_health,           name: "System Health Snapshot",         desc: "GC stats, memory (RSS/peak/swap), threads, connection pool at error time [error-time only]" },
+              { key: :source_code_integration, name: "Source Code Integration",        desc: "View source code inline in error details (+/- 7 lines context) [dashboard only]" },
+              { key: :git_blame,               name: "Git Blame Integration",          desc: "Show author, commit, timestamp for each source line (requires git) [dashboard only]" },
+              { key: :swallowed_exceptions,    name: "Swallowed Exception Detection",  desc: "Detect silently rescued exceptions via TracePoint(:rescue) [request-path overhead, Ruby 3.3+]" },
+              { key: :crash_capture,           name: "Process Crash Capture",          desc: "Capture fatal crashes via at_exit hook, written to disk [error-time only]" },
+              { key: :diagnostic_dump,         name: "Diagnostic Dump",                desc: "On-demand system state snapshot via rake task or dashboard button [background/dashboard only]" }
+            ]
+            advanced_features.each do |f|
+              say "\n    #{f[:name]}", :cyan
+              say "    #{f[:desc]}", :white
+              r = ask("    Enable? (y/N):", :yellow, limited_to: [ "y", "Y", "n", "N", "" ])
+              @selected_features[f[:key]] = r.downcase == "y"
+              if @selected_features[f[:key]] && f[:key] == :swallowed_exceptions && RUBY_VERSION < "3.3"
+                say "    ⚠ Requires Ruby 3.3+ (you have #{RUBY_VERSION}) — will activate after upgrade", :yellow
+              end
+            end
+          else
+            # Set all advanced keys to false EXCEPT async_logging which defaults ON via class_option.
+            # We do not set async_logging here so options[:async_logging] (default: true) wins in create_initializer_file.
+            (advanced_keys - [ :async_logging ]).each { |k| @selected_features[k] = false }
+            say "    ✓ Using defaults (async logging ON, everything else OFF)", :white
           end
         end
 
@@ -247,6 +207,13 @@ module RailsErrorDashboard
         # Skip if existing config already detected database mode
         return if @existing_install_detected && @database_mode
 
+        # Quick mode: use shared DB, no prompt
+        if quick_mode?
+          @database_mode = :same
+          @application_name = detect_application_name
+          return
+        end
+
         # Skip if not interactive or if --separate_database was passed via CLI
         if options[:separate_database]
           @database_mode = :separate
@@ -421,6 +388,7 @@ module RailsErrorDashboard
         say "  ✓ Dashboard UI", :green
         say "  ✓ Real-time Updates", :green
         say "  ✓ Analytics", :green
+        say "  ✓ Async Logging (Rails :async adapter — no extra infrastructure needed)", :green
 
         # Count optional features enabled
         enabled_count = 0
@@ -496,7 +464,16 @@ module RailsErrorDashboard
         say "  → Set DISCORD_WEBHOOK_URL in .env", :yellow if @enable_discord
         say "  → Set PAGERDUTY_INTEGRATION_KEY in .env", :yellow if @enable_pagerduty
         say "  → Set WEBHOOK_URLS in .env", :yellow if @enable_webhooks
-        say "  → Ensure Sidekiq/Solid Queue running", :yellow if @enable_async_logging
+        if @enable_async_logging
+          # Check which async adapter is in use — only warn about external workers when needed
+          async_section = File.exist?(File.join(destination_root, "config/initializers/rails_error_dashboard.rb")) &&
+                          File.read(File.join(destination_root, "config/initializers/rails_error_dashboard.rb"))
+          if async_section && (async_section.include?("async_adapter = :sidekiq") || async_section.include?("async_adapter = :solid_queue"))
+            say "  → Ensure your background worker (Sidekiq/SolidQueue) is running for async logging", :yellow
+          else
+            say "  ✓ Async logging uses Rails :async adapter — no extra process needed", :green
+          end
+        end
 
         # Database-specific instructions
         if @enable_separate_database
@@ -554,6 +531,36 @@ module RailsErrorDashboard
 
       private
 
+      def quick_mode?
+        options[:quick]
+      end
+
+      def build_quick_defaults
+        {
+          # Async ON (built-in Rails :async adapter, zero infrastructure)
+          async_logging: true,
+          # All analytics ON — run at query/background time, zero request-path overhead
+          baseline_alerts: true,
+          similar_errors: true,
+          co_occurring_errors: true,
+          error_cascades: true,
+          error_correlation: true,
+          platform_comparison: true,
+          occurrence_patterns: true,
+          # ON — small overhead, high insight value
+          breadcrumbs: true,       # ~0.1ms per request — SQL, cache, job trail leading to each error
+          system_health: true,     # ~1ms per error — GC, memory, threads at exact error moment
+          error_sampling: true,    # 50% sampling on non-critical errors — halves storage, still shows patterns
+          # OFF — require credentials, config, or niche use case
+          slack: false, email: false, discord: false, pagerduty: false, webhooks: false,
+          source_code_integration: false,
+          git_blame: false,
+          swallowed_exceptions: false,
+          crash_capture: false,
+          diagnostic_dump: false
+        }
+      end
+
       def detect_application_name
         if defined?(Rails) && Rails.application
           Rails.application.class.module_parent_name

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

@@ -138,17 +138,19 @@ RailsErrorDashboard.configure do |config|
 
 <% if @enable_async_logging -%>
   # Async Error Logging - ENABLED
-  # Errors will be logged in background jobs for better performance
+  # Errors are logged in background jobs — zero impact on request response time.
+  # Default adapter is :async (Rails built-in, no extra infrastructure needed).
+  # Swap to :sidekiq or :solid_queue when you have a background worker running.
   config.async_logging = true
-  config.async_adapter = :sidekiq  # Options: :sidekiq, :solid_queue, :async
+  config.async_adapter = :async  # Options: :async (built-in), :sidekiq, :solid_queue
   # To disable: Set config.async_logging = false
 
 <% else -%>
   # Async Error Logging - DISABLED
-  # Errors are logged synchronously (blocking)
-  # To enable: Set config.async_logging = true and configure adapter
+  # Errors are logged synchronously (adds ~1-5ms to requests that trigger errors)
+  # To enable: Set config.async_logging = true
   config.async_logging = false
-  # config.async_adapter = :sidekiq  # Options: :sidekiq, :solid_queue, :async
+  # config.async_adapter = :async  # Options: :async (built-in), :sidekiq, :solid_queue
 
 <% end -%>
   # Backtrace size limiting (100 lines is industry standard: Rollbar, Airbrake, Bugsnag)
@@ -156,15 +158,18 @@ RailsErrorDashboard.configure do |config|
 
 <% if @enable_error_sampling -%>
   # Error Sampling - ENABLED
-  # Reduce volume by logging only a percentage of non-critical errors
-  # Critical errors are ALWAYS logged regardless of sampling rate
-  config.sampling_rate = 0.1  # 10% - Adjust as needed (0.0 to 1.0)
+  # Samples non-critical errors to reduce storage volume.
+  # Critical and high severity errors are ALWAYS logged at 100% regardless of this setting.
+  # 0.5 = log 50% of non-critical occurrences — halves storage while keeping
+  # occurrence counts meaningful and error patterns visible.
+  # Tune lower (e.g. 0.1) if one error is flooding the DB; set to 1.0 to log everything.
+  config.sampling_rate = 0.5  # 50% of non-critical errors
   # To disable: Set config.sampling_rate = 1.0 (100%)
 
 <% else -%>
   # Error Sampling - DISABLED
-  # All errors are logged (100% sampling rate)
-  # To enable: Set config.sampling_rate < 1.0 (e.g., 0.1 for 10%)
+  # All errors are logged (100% sampling rate).
+  # To enable: Set config.sampling_rate < 1.0 (e.g., 0.5 for 50%, 0.1 for 10%)
   config.sampling_rate = 1.0
 
 <% end -%>

data/lib/rails_error_dashboard/configuration.rb

@@ -511,44 +511,56 @@ module RailsErrorDashboard
         @enable_activestorage_tracking = false
       end
 
+      # Skip credential/service-dependent validations during Docker builds.
+      # SECRET_KEY_BASE_DUMMY=1 means no credentials or external services available.
+      build_env = ENV["SECRET_KEY_BASE_DUMMY"].present?
+
       # Validate issue tracking configuration
-      if enable_issue_tracking && effective_issue_tracker_token.blank?
-        warnings << "enable_issue_tracking is true but no token configured. " \
-                    "Set issue_tracker_token or RED_BOT_TOKEN env var. " \
-                    "Tip: Create a dedicated RED (Rails Error Dashboard) bot account on your platform."
-      end
+      unless build_env
+        if enable_issue_tracking && effective_issue_tracker_token.blank?
+          warnings << "enable_issue_tracking is true but no token configured. " \
+                      "Set issue_tracker_token or RED_BOT_TOKEN env var. " \
+                      "Tip: Create a dedicated RED (Rails Error Dashboard) bot account on your platform."
+        end
 
-      if enable_issue_tracking && effective_issue_tracker_provider.nil?
-        warnings << "enable_issue_tracking is true but provider could not be detected. " \
-                    "Set issue_tracker_provider or git_repository_url."
+        if enable_issue_tracking && effective_issue_tracker_provider.nil?
+          warnings << "enable_issue_tracking is true but provider could not be detected. " \
+                      "Set issue_tracker_provider or git_repository_url."
+        end
       end
 
-      # Validate crash capture path (must exist if custom path specified)
-      if enable_crash_capture && crash_capture_path
+      # Validate crash capture path — auto-create if missing
+      if enable_crash_capture && crash_capture_path && !build_env
         unless Dir.exist?(crash_capture_path)
-          errors << "crash_capture_path '#{crash_capture_path}' does not exist"
+          begin
+            FileUtils.mkdir_p(crash_capture_path)
+          rescue => e
+            errors << "crash_capture_path '#{crash_capture_path}' could not be created: #{e.message}"
+          end
         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"
-      end
+      # Validate notification dependencies (skip during builds — credentials unavailable)
+      unless build_env
+        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"
+        end
 
-      if enable_email_notifications && notification_email_recipients.empty?
-        errors << "notification_email_recipients is required when enable_email_notifications is true"
-      end
+        if enable_email_notifications && notification_email_recipients.empty?
+          errors << "notification_email_recipients is required when enable_email_notifications is true"
+        end
 
-      if enable_discord_notifications && (discord_webhook_url.nil? || discord_webhook_url.strip.empty?)
-        errors << "discord_webhook_url is required when enable_discord_notifications is true"
-      end
+        if enable_discord_notifications && (discord_webhook_url.nil? || discord_webhook_url.strip.empty?)
+          errors << "discord_webhook_url is required when enable_discord_notifications is true"
+        end
 
-      if enable_pagerduty_notifications && (pagerduty_integration_key.nil? || pagerduty_integration_key.strip.empty?)
-        errors << "pagerduty_integration_key is required when enable_pagerduty_notifications is true"
-      end
+        if enable_pagerduty_notifications && (pagerduty_integration_key.nil? || pagerduty_integration_key.strip.empty?)
+          errors << "pagerduty_integration_key is required when enable_pagerduty_notifications is true"
+        end
 
-      if enable_webhook_notifications && webhook_urls.empty?
-        errors << "webhook_urls is required when enable_webhook_notifications is true"
+        if enable_webhook_notifications && webhook_urls.empty?
+          errors << "webhook_urls is required when enable_webhook_notifications is true"
+        end
       end
 
       # Validate separate database configuration

data/lib/rails_error_dashboard/engine.rb

@@ -61,6 +61,16 @@ module RailsErrorDashboard
 
     # Subscribe to Rails error reporter
     config.after_initialize do
+      # Skip all runtime features during Docker asset precompilation.
+      # SECRET_KEY_BASE_DUMMY=1 signals a build environment — no database,
+      # no credentials, no external services are available. Activating
+      # TracePoint hooks, error subscribers, or background jobs here causes
+      # infinite retry loops and connection failures (issues #1-5).
+      if ENV["SECRET_KEY_BASE_DUMMY"].present?
+        Rails.logger.info "[Rails Error Dashboard] Build environment detected (SECRET_KEY_BASE_DUMMY) — skipping runtime features."
+        next
+      end
+
       if RailsErrorDashboard.configuration.enable_error_subscriber
         Rails.error.subscribe(RailsErrorDashboard::ErrorReporter.new)
       end

data/lib/rails_error_dashboard/error_reporter.rb

@@ -24,6 +24,32 @@ module RailsErrorDashboard
 
       # CRITICAL: Wrap entire process in rescue to ensure failures don't break the app
       begin
+        # Enrich context with request data from Thread.current when available.
+        # Rails internals (ActionDispatch::Executor) report errors with
+        # source: "application.action_dispatch" but pass NO request object,
+        # resulting in placeholder values ("Rails Application", "{}", etc.).
+        # Our middleware stores the Rack env in Thread.current so we can
+        # build a proper request here — fixing issue #106.
+        if context[:request].nil? && Thread.current[:rails_error_dashboard_request_env]
+          env = Thread.current[:rails_error_dashboard_request_env]
+          context = context.merge(request: ActionDispatch::Request.new(env))
+        end
+
+        # Skip duplicate reports from our own middleware when the subscriber
+        # already captured this error with full request context above.
+        # Without this, async logging enqueues two jobs for one exception —
+        # and non-deterministic job ordering can overwrite good data.
+        if source == "rack.middleware" &&
+           Thread.current[:rails_error_dashboard_reported_errors]&.include?(error.object_id)
+          return
+        end
+
+        # Track that we've reported this error (for dedup with middleware)
+        if Thread.current[:rails_error_dashboard_request_env]
+          Thread.current[:rails_error_dashboard_reported_errors] ||= Set.new
+          Thread.current[:rails_error_dashboard_reported_errors].add(error.object_id)
+        end
+
         # Extract context information
         error_context = ValueObjects::ErrorContext.new(context, source)
 

data/lib/rails_error_dashboard/middleware/error_catcher.rb

@@ -23,6 +23,11 @@ module RailsErrorDashboard
         # Record request start time for duration calculation
         env["rails_error_dashboard.request_start"] = Time.now.to_f
 
+        # Store request env in thread-local so the ErrorReporter subscriber
+        # can access request context when Rails.error.report fires from
+        # Rails internals (e.g., ActionDispatch::ShowExceptions)
+        Thread.current[:rails_error_dashboard_request_env] = env
+
         # Initialize breadcrumb buffer for this request
         if RailsErrorDashboard.configuration.enable_breadcrumbs
           RailsErrorDashboard::Services::BreadcrumbCollector.init_buffer
@@ -52,6 +57,8 @@ module RailsErrorDashboard
         raise exception
       ensure
         # CRITICAL: Always clean up thread-local storage (Puma reuses threads)
+        Thread.current[:rails_error_dashboard_request_env] = nil
+        Thread.current[:rails_error_dashboard_reported_errors] = nil
         RailsErrorDashboard::Services::BreadcrumbCollector.clear_buffer
       end
     end

data/lib/rails_error_dashboard/value_objects/error_context.rb

@@ -110,6 +110,11 @@ module RailsErrorDashboard
         # Additional context (from mobile apps, etc.)
         params.merge!(@context[:additional_context]) if @context[:additional_context]
 
+        # Pre-serialized params (from async logging or double-ErrorContext path).
+        # LogError creates a second ErrorContext from error_context.to_h which
+        # has :request_params as a JSON string but no :request object.
+        return @context[:request_params] if params.empty? && @context[:request_params].present?
+
         params.to_json
       end
 

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.5.11"
+  VERSION = "0.5.12"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.5.11
+  version: 0.5.12
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -496,7 +496,7 @@ metadata:
   funding_uri: https://github.com/sponsors/AnjanJ
 post_install_message: |
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    RED (Rails Error Dashboard) v0.5.11
+    RED (Rails Error Dashboard) v0.5.12
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   First install: