rails_error_dashboard 0.1.37 → 0.2.0

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

@@ -56,6 +56,7 @@ module RailsErrorDashboard
         @selected_features = {}
 
         # Feature definitions with descriptions - organized by category
+        # Note: separate_database is handled separately via select_database_mode
         features = [
           # === NOTIFICATIONS ===
           {
@@ -102,12 +103,6 @@ module RailsErrorDashboard
             description: "Log only % of non-critical errors (reduce volume)",
             category: "Performance"
           },
-          {
-            key: :separate_database,
-            name: "Separate Error Database",
-            description: "Store errors in dedicated database",
-            category: "Performance"
-          },
 
           # === ADVANCED ANALYTICS ===
           {
@@ -191,6 +186,55 @@ module RailsErrorDashboard
         say "\n"
       end
 
+      def select_database_mode
+        # Skip if not interactive or if --separate_database was passed via CLI
+        if options[:separate_database]
+          @database_mode = :separate
+          @database_name = options[:database] || "error_dashboard"
+          @application_name = detect_application_name
+          return
+        end
+
+        return unless options[:interactive] && behavior == :invoke
+        return unless $stdin.tty?
+
+        say "-" * 70
+        say "  Database Setup", :cyan
+        say "-" * 70
+        say "\n"
+        say "  How do you want to store error data?\n", :white
+        say "  1) Same database (default) - store errors in your app's primary database", :white
+        say "  2) Separate database       - dedicated database for error data (recommended for production)", :white
+        say "  3) Shared database          - connect to an existing error database shared by multiple apps", :white
+        say "\n"
+
+        response = ask("  Choose (1/2/3):", :yellow, limited_to: [ "1", "2", "3", "" ])
+
+        case response
+        when "2"
+          @database_mode = :separate
+          @database_name = "error_dashboard"
+          @application_name = detect_application_name
+
+          say "\n  Database key: error_dashboard", :green
+          say "  Application name: #{@application_name}", :green
+          say "\n"
+        when "3"
+          @database_mode = :multi_app
+          @database_name = "error_dashboard"
+          @application_name = detect_application_name
+
+          say "\n  Database key: error_dashboard", :green
+          say "  Application name: #{@application_name}", :green
+          say "  This app will share the error database with your other apps.", :white
+          say "\n"
+        else
+          @database_mode = :same
+          @database_name = nil
+          @application_name = detect_application_name
+        end
+      end
+
       def create_initializer_file
         # Notifications
         @enable_slack = @selected_features&.dig(:slack) || options[:slack]
@@ -202,8 +246,12 @@ module RailsErrorDashboard
         # Performance
         @enable_async_logging = @selected_features&.dig(:async_logging) || options[:async_logging]
         @enable_error_sampling = @selected_features&.dig(:error_sampling) || options[:error_sampling]
-        @enable_separate_database = @selected_features&.dig(:separate_database) || options[:separate_database]
-        @database_name = options[:database]
+
+        # Database mode (set by select_database_mode or CLI flags)
+        @database_mode ||= :same
+        @enable_separate_database = @database_mode == :separate || @database_mode == :multi_app
+        @enable_multi_app = @database_mode == :multi_app
+        # @database_name and @application_name are set by select_database_mode
 
         # Advanced Analytics
         @enable_baseline_alerts = @selected_features&.dig(:baseline_alerts) || options[:baseline_alerts]
@@ -234,7 +282,7 @@ module RailsErrorDashboard
 
         say "\n"
         say "=" * 70
-        say "  ✓ Installation Complete!", :green
+        say "  Installation Complete!", :green
         say "=" * 70
         say "\n"
 
@@ -309,28 +357,40 @@ module RailsErrorDashboard
         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
+
+        # Database-specific instructions
         if @enable_separate_database
-          if @database_name
-            say "  → Configure '#{@database_name}' database in database.yml", :yellow
-          else
-            say "  → Configure database in database.yml and set config.database", :yellow
-          end
-          say "    See docs/guides/DATABASE_OPTIONS.md for details", :yellow
+          show_database_setup_instructions
         end
 
         say "\n"
         say "Next Steps:", :cyan
-        say "  1. Run: rails db:migrate"
-        say "  2. Update credentials in config/initializers/rails_error_dashboard.rb"
-        say "  3. Restart your Rails server"
-        say "  4. Visit http://localhost:3000/error_dashboard"
+        if @enable_separate_database
+          say "  1. Add the database.yml entry shown above"
+          say "  2. Run: rails db:create:error_dashboard"
+          if @enable_multi_app
+            say "  3. Run migrations (only needed on the FIRST app):"
+            say "     rails db:migrate:error_dashboard"
+          else
+            say "  3. Run: rails db:migrate:error_dashboard"
+          end
+          say "  4. Update credentials in config/initializers/rails_error_dashboard.rb"
+          say "  5. Restart your Rails server"
+          say "  6. Visit http://localhost:3000/error_dashboard"
+          say "  7. Verify: rails error_dashboard:verify"
+        else
+          say "  1. Run: rails db:migrate"
+          say "  2. Update credentials in config/initializers/rails_error_dashboard.rb"
+          say "  3. Restart your Rails server"
+          say "  4. Visit http://localhost:3000/error_dashboard"
+        end
         say "\n"
-        say "📖 Documentation:", :white
-        say "   • Quick Start: docs/QUICKSTART.md", :white
-        say "   • Complete Feature Guide: docs/FEATURES.md", :white
-        say "   • All Docs: docs/README.md", :white
+        say "Documentation:", :white
+        say "   Quick Start: docs/QUICKSTART.md", :white
+        say "   Database Setup: docs/guides/DATABASE_OPTIONS.md", :white
+        say "   Complete Feature Guide: docs/FEATURES.md", :white
         say "\n"
-        say "⚙️  To enable/disable features later:", :white
+        say "To enable/disable features later:", :white
         say "   Edit config/initializers/rails_error_dashboard.rb", :white
         say "\n"
       end
@@ -338,6 +398,67 @@ module RailsErrorDashboard
       def show_readme
         # Skip the old README display since we have the new summary
       end
+
+      private
+
+      def detect_application_name
+        if defined?(Rails) && Rails.application
+          Rails.application.class.module_parent_name
+        else
+          "MyApp"
+        end
+      end
+
+      def show_database_setup_instructions
+        app_name_snake = @application_name.to_s.underscore
+
+        say "\n"
+        say "-" * 70
+        say "  Database Setup Required", :yellow
+        say "-" * 70
+        say "\n"
+        say "  Add this to your config/database.yml:\n", :white
+
+        if @enable_multi_app
+          say "  # Shared error database (same physical DB across all your apps)", :white
+        else
+          say "  # Separate error database", :white
+        end
+
+        say "\n  development:", :cyan
+        say "    primary:", :white
+        say "      <<: *default", :white
+        say "      database: #{app_name_snake}_development", :white
+        say "    error_dashboard:", :white
+        say "      <<: *default", :white
+        if @enable_multi_app
+          say "      database: shared_errors_development", :white
+        else
+          say "      database: #{app_name_snake}_errors_development", :white
+        end
+        say "      migrations_paths: db/error_dashboard_migrate", :white
+
+        say "\n  production:", :cyan
+        say "    primary:", :white
+        say "      <<: *default", :white
+        say "      database: #{app_name_snake}_production", :white
+        say "    error_dashboard:", :white
+        say "      <<: *default", :white
+        if @enable_multi_app
+          say "      database: shared_errors_production", :white
+        else
+          say "      database: #{app_name_snake}_errors_production", :white
+        end
+        say "      migrations_paths: db/error_dashboard_migrate", :white
+        say "\n"
+
+        if @enable_multi_app
+          say "  For multi-app: all apps must point to the same physical database.", :yellow
+          say "  Only the FIRST app needs to run migrations.", :yellow
+          say "  Other apps just need the database.yml entry and 'rails error_dashboard:verify'.", :yellow
+          say "\n"
+        end
+      end
     end
   end
 end

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

@@ -151,22 +151,26 @@ RailsErrorDashboard.configure do |config|
 
 <% if @enable_separate_database -%>
   # Separate Error Database - ENABLED
-  # Errors will be stored in a dedicated database
-  # See docs/guides/DATABASE_OPTIONS.md for setup instructions
+  # Errors are stored in a dedicated database for isolation and scalability.
+  # See docs/guides/DATABASE_OPTIONS.md for setup instructions.
   config.use_separate_database = true
-<% if @database_name -%>
-  config.database = :<%= @database_name %>
-<% else -%>
-  # config.database = :error_dashboard  # Uncomment and set your database name
+  config.database = :<%= @database_name || "error_dashboard" %>
+<% if @enable_multi_app -%>
+
+  # Multi-app mode: multiple Rails apps share this error database.
+  # Each app is identified by its application_name.
+  # Auto-detected from Rails.application.class.module_parent_name if not set.
+  config.application_name = "<%= @application_name %>"
 <% end -%>
   # To disable: Set config.use_separate_database = false
 
 <% else -%>
   # Separate Error Database - DISABLED
-  # Errors are stored in your main application database
+  # Errors are stored in your main application database.
   # To enable: Set config.use_separate_database = true and configure database.yml
+  # See docs/guides/DATABASE_OPTIONS.md for setup instructions.
   config.use_separate_database = false
-  # config.database = :error_dashboard  # Database name when using separate database
+  # config.database = :error_dashboard
 
 <% end -%>
   # ============================================================================

data/lib/rails_error_dashboard/commands/find_or_increment_error.rb

@@ -4,8 +4,11 @@ module RailsErrorDashboard
   module Commands
     # Command: Find an existing error by hash or create a new one
     # Uses pessimistic locking to prevent race conditions in multi-app scenarios.
-    # If an unresolved error with the same hash exists within 24 hours, increments
-    # its occurrence count. Otherwise creates a new error record.
+    #
+    # Search order:
+    # 1. Unresolved errors with same hash within 24 hours → increment occurrence count
+    # 2. Resolved/wont_fix errors with same hash (any age) → reopen and increment
+    # 3. No match → create new error record
     class FindOrIncrementError
       def self.call(error_hash, attributes = {})
         new(error_hash, attributes).call
@@ -17,18 +20,21 @@ module RailsErrorDashboard
       end
 
       def call
-        existing = find_existing
+        # Priority 1: Find unresolved match (existing behavior)
+        existing = find_unresolved
+        return increment_existing(existing) if existing
 
-        if existing
-          increment_existing(existing)
-        else
-          create_new_or_retry
-        end
+        # Priority 2: Find resolved/wont_fix match → reopen
+        resolved = find_resolved
+        return reopen_existing(resolved) if resolved
+
+        # Priority 3: Create new record
+        create_new_or_retry
       end
 
       private
 
-      def find_existing
+      def find_unresolved
         ErrorLog.unresolved
           .where(error_hash: @error_hash)
           .where(application_id: @attributes[:application_id])
@@ -38,6 +44,16 @@ module RailsErrorDashboard
           .first
       end
 
+      def find_resolved
+        ErrorLog
+          .where(error_hash: @error_hash)
+          .where(application_id: @attributes[:application_id])
+          .where(status: %w[resolved wont_fix])
+          .lock
+          .order(last_seen_at: :desc)
+          .first
+      end
+
       def increment_existing(error)
         error.update!(
           occurrence_count: error.occurrence_count + 1,
@@ -51,9 +67,29 @@ module RailsErrorDashboard
         error
       end
 
+      def reopen_existing(error)
+        attrs = {
+          resolved: false,
+          status: "new",
+          resolved_at: nil,
+          occurrence_count: error.occurrence_count + 1,
+          last_seen_at: Time.current,
+          user_id: @attributes[:user_id] || error.user_id,
+          request_url: @attributes[:request_url] || error.request_url,
+          request_params: @attributes[:request_params] || error.request_params,
+          user_agent: @attributes[:user_agent] || error.user_agent,
+          ip_address: @attributes[:ip_address] || error.ip_address
+        }
+        attrs[:reopened_at] = Time.current if ErrorLog.column_names.include?("reopened_at")
+        error.update!(attrs)
+        error.just_reopened = true
+        error
+      end
+
       def create_new_or_retry
         ErrorLog.create!(@attributes.reverse_merge(resolved: false))
       rescue ActiveRecord::RecordNotUnique
+        # Race condition: another process created the same error
         retry_existing = ErrorLog.unresolved
           .where(error_hash: @error_hash)
           .where(application_id: @attributes[:application_id])
@@ -68,7 +104,19 @@ module RailsErrorDashboard
           )
           retry_existing
         else
-          raise
+          # Also check resolved in race condition path
+          retry_resolved = ErrorLog
+            .where(error_hash: @error_hash)
+            .where(application_id: @attributes[:application_id])
+            .where(status: %w[resolved wont_fix])
+            .lock
+            .first
+
+          if retry_resolved
+            reopen_existing(retry_resolved)
+          else
+            raise
+          end
         end
       end
     end

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -23,7 +23,8 @@ module RailsErrorDashboard
         exception_data = {
           class_name: exception.class.name,
           message: exception.message,
-          backtrace: exception.backtrace
+          backtrace: exception.backtrace,
+          cause_chain: serialize_cause_chain(exception)
         }
 
         # Enqueue the async job using ActiveJob
@@ -31,6 +32,37 @@ module RailsErrorDashboard
         AsyncErrorLoggingJob.perform_later(exception_data, context)
       end
 
+      # Serialize cause chain for async job serialization
+      # Returns an array of hashes (not JSON string) for ActiveJob compatibility
+      def self.serialize_cause_chain(exception)
+        return nil unless exception.respond_to?(:cause) && exception.cause
+
+        chain = []
+        current = exception.cause
+        seen = Set.new
+        depth = 0
+
+        while current && depth < 5
+          break if seen.include?(current.object_id)
+          seen.add(current.object_id)
+
+          chain << {
+            class_name: current.class.name,
+            message: current.message&.to_s,
+            backtrace: current.backtrace&.first(20)
+          }
+
+          current = current.respond_to?(:cause) ? current.cause : nil
+          depth += 1
+        end
+
+        chain.empty? ? nil : chain
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Cause chain serialization failed: #{e.message}")
+        nil
+      end
+      private_class_method :serialize_cause_chain
+
       def initialize(exception, context = {})
         @exception = exception
         @context = context
@@ -63,17 +95,32 @@ module RailsErrorDashboard
           occurred_at: Time.current
         }
 
+        # Enriched request context (if columns exist)
+        enrich_with_request_context(attributes, error_context)
+
+        # Extract exception cause chain (if column exists)
+        if ErrorLog.column_names.include?("exception_cause")
+          cause_json = Services::CauseChainExtractor.call(@exception)
+          # Fall back to pre-serialized cause chain from async job context
+          cause_json ||= build_cause_json_from_context
+          attributes[:exception_cause] = cause_json
+        end
+
         # Generate error hash for deduplication (including controller/action context and application)
         error_hash = Services::ErrorHashGenerator.call(
           @exception,
           controller_name: error_context.controller_name,
           action_name: error_context.action_name,
-          application_id: application.id
+          application_id: application.id,
+          context: @context
         )
 
         #  Calculate backtrace signature for fuzzy matching (if column exists)
         if ErrorLog.column_names.include?("backtrace_signature")
-          attributes[:backtrace_signature] = Services::BacktraceProcessor.calculate_signature(truncated_backtrace)
+          attributes[:backtrace_signature] = Services::BacktraceProcessor.calculate_signature(
+            truncated_backtrace,
+            locations: @exception.backtrace_locations
+          )
         end
 
         #  Add git/release info if columns exist
@@ -91,6 +138,14 @@ module RailsErrorDashboard
                                       detect_version_from_file
         end
 
+        # Add environment snapshot (if column exists)
+        if ErrorLog.column_names.include?("environment_info")
+          attributes[:environment_info] = Services::EnvironmentSnapshot.snapshot.to_json
+        end
+
+        # Apply sensitive data filtering (on by default)
+        attributes = Services::SensitiveDataFilter.filter_attributes(attributes)
+
         # Find existing error or create new one
         # This ensures accurate occurrence tracking
         error_log = ErrorLog.find_or_increment_by_hash(error_hash, attributes.merge(error_hash: error_hash))
@@ -110,18 +165,31 @@ module RailsErrorDashboard
           end
         end
 
-        # Send notifications only for new errors (not increments)
-        # Check if this is first occurrence or error was just created
+        # Send notifications for new errors and reopened errors (with throttling)
         if error_log.occurrence_count == 1
-          Services::ErrorNotificationDispatcher.call(error_log)
-          # Dispatch plugin event for new error
+          # Brand new error — notify if severity meets minimum
+          if Services::NotificationThrottler.severity_meets_minimum?(error_log)
+            Services::ErrorNotificationDispatcher.call(error_log)
+            Services::NotificationThrottler.record_notification(error_log)
+          end
           PluginRegistry.dispatch(:on_error_logged, error_log)
-          # Trigger notification callbacks
           trigger_callbacks(error_log)
-          # Emit ActiveSupport::Notifications instrumentation events
+          emit_instrumentation_events(error_log)
+        elsif error_log.just_reopened
+          # Reopened error — notify if meets severity + not in cooldown
+          if Services::NotificationThrottler.should_notify?(error_log)
+            Services::ErrorNotificationDispatcher.call(error_log)
+            Services::NotificationThrottler.record_notification(error_log)
+          end
+          PluginRegistry.dispatch(:on_error_reopened, error_log)
+          trigger_callbacks(error_log)
           emit_instrumentation_events(error_log)
         else
-          # Dispatch plugin event for error recurrence
+          # Recurring unresolved error — check threshold milestones
+          if Services::NotificationThrottler.threshold_reached?(error_log)
+            Services::ErrorNotificationDispatcher.call(error_log)
+            Services::NotificationThrottler.record_notification(error_log)
+          end
           PluginRegistry.dispatch(:on_error_recurred, error_log)
         end
 
@@ -226,6 +294,37 @@ module RailsErrorDashboard
         RailsErrorDashboard::Logger.error("Failed to check baseline anomaly: #{e.message}")
       end
 
+      # Add enriched request context fields if columns exist
+      def enrich_with_request_context(attributes, error_context)
+        column_names = ErrorLog.column_names
+
+        attributes[:http_method] = error_context.http_method if column_names.include?("http_method")
+        attributes[:hostname] = error_context.hostname if column_names.include?("hostname")
+        attributes[:content_type] = error_context.content_type if column_names.include?("content_type")
+        attributes[:request_duration_ms] = error_context.request_duration_ms if column_names.include?("request_duration_ms")
+      end
+
+      # Build cause chain JSON from pre-serialized async job context
+      # Used when exception was reconstructed and has no Ruby cause
+      def build_cause_json_from_context
+        serialized = @context[:_serialized_cause_chain]
+        return nil unless serialized.is_a?(Array) && serialized.any?
+
+        chain = serialized.map do |entry|
+          entry = entry.symbolize_keys if entry.respond_to?(:symbolize_keys)
+          {
+            class_name: entry[:class_name],
+            message: entry[:message]&.to_s&.slice(0, 1000),
+            backtrace: entry[:backtrace]&.first(20)
+          }
+        end
+
+        chain.to_json
+      rescue => e
+        RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Failed to build cause JSON from context: #{e.message}")
+        nil
+      end
+
       # Detect git SHA from git command (fallback)
       def detect_git_sha_from_command
         return nil unless File.exist?(Rails.root.join(".git"))

data/lib/rails_error_dashboard/configuration.rb

@@ -52,6 +52,12 @@ module RailsErrorDashboard
     # Exceptions to ignore (array of strings, regexes, or classes)
     attr_accessor :ignored_exceptions
 
+    # Custom fingerprint lambda for error deduplication
+    # When set, overrides the default ErrorHashGenerator logic.
+    # Receives (exception, context) and must return a String.
+    # Example: ->(exception, context) { "#{exception.class.name}:#{context[:controller_name]}" }
+    attr_accessor :custom_fingerprint
+
     # Sampling rate for non-critical errors (0.0 to 1.0, default 1.0 = 100%)
     attr_accessor :sampling_rate
 
@@ -96,6 +102,18 @@ module RailsErrorDashboard
     attr_accessor :only_show_app_code_source       # Hide gems/stdlib (default: true)
     attr_accessor :git_branch_strategy             # :commit_sha, :current_branch, :main (default: :commit_sha)
 
+    # Sensitive data filtering (on by default)
+    # Redacts passwords, tokens, credit cards, SSNs, etc. before storage.
+    # Uses built-in defaults + Rails' filter_parameters + custom patterns.
+    # Set to false if you want raw data stored (you own your database).
+    attr_accessor :filter_sensitive_data
+    attr_accessor :sensitive_data_patterns # Additional patterns beyond Rails' filter_parameters
+
+    # Notification throttling (prevents alert fatigue)
+    attr_accessor :notification_minimum_severity   # Minimum severity to notify (default: :low = notify all)
+    attr_accessor :notification_cooldown_minutes    # Per-error cooldown in minutes (default: 5, 0 = disabled)
+    attr_accessor :notification_threshold_alerts    # Occurrence milestones that trigger notification (default: [10, 50, 100, 500, 1000])
+
     # Notification callbacks (managed via helper methods, not set directly)
     attr_reader :notification_callbacks
 
@@ -146,6 +164,7 @@ module RailsErrorDashboard
       # Advanced configuration defaults
       @custom_severity_rules = {}
       @ignored_exceptions = []
+      @custom_fingerprint = nil # Lambda: ->(exception, context) { "custom_key" }
       @sampling_rate = 1.0 # 100% by default
       @async_logging = false
       @async_adapter = :sidekiq # Battle-tested default
@@ -183,6 +202,15 @@ module RailsErrorDashboard
       @only_show_app_code_source = true  # Hide gem/vendor code for security
       @git_branch_strategy = :commit_sha  # Use error's git_sha (most accurate)
 
+      # Sensitive data filtering defaults - ON by default (filters passwords, tokens, credit cards, etc.)
+      @filter_sensitive_data = true
+      @sensitive_data_patterns = []
+
+      # Notification throttling defaults
+      @notification_minimum_severity = :low  # Notify on all severities (current behavior)
+      @notification_cooldown_minutes = 5     # 5 min cooldown per error_hash (0 = disabled)
+      @notification_threshold_alerts = [ 10, 50, 100, 500, 1000 ] # Occurrence milestones
+
       # Internal logging defaults - SILENT by default
       @enable_internal_logging = false  # Opt-in for debugging
       @log_level = :silent  # Silent by default, use :debug, :info, :warn, :error, or :silent
@@ -255,6 +283,11 @@ module RailsErrorDashboard
         end
       end
 
+      # Validate custom_fingerprint (must respond to .call if set)
+      if custom_fingerprint && !custom_fingerprint.respond_to?(:call)
+        errors << "custom_fingerprint must respond to .call (lambda, proc, or object with .call method)"
+      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"
@@ -294,6 +327,25 @@ module RailsErrorDashboard
         errors << "total_users_for_impact must be at least 1 (got: #{total_users_for_impact})"
       end
 
+      # Validate notification_minimum_severity (must be valid symbol)
+      if notification_minimum_severity
+        valid_notification_severities = %i[critical high medium low]
+        unless valid_notification_severities.include?(notification_minimum_severity)
+          errors << "notification_minimum_severity must be one of #{valid_notification_severities.inspect} " \
+                    "(got: #{notification_minimum_severity.inspect})"
+        end
+      end
+
+      # Validate notification_cooldown_minutes (must be non-negative if set)
+      if notification_cooldown_minutes && notification_cooldown_minutes < 0
+        errors << "notification_cooldown_minutes must be 0 or greater (got: #{notification_cooldown_minutes})"
+      end
+
+      # Validate notification_threshold_alerts (must be array of positive integers if set)
+      if notification_threshold_alerts && !notification_threshold_alerts.is_a?(Array)
+        errors << "notification_threshold_alerts must be an Array (got: #{notification_threshold_alerts.class})"
+      end
+
       # Raise exception if any errors found
       raise ConfigurationError, errors if errors.any?
 

data/lib/rails_error_dashboard/manual_error_reporter.rb

@@ -136,6 +136,18 @@ module RailsErrorDashboard
         @backtrace = backtrace
       end
 
+      # SyntheticExceptions don't have real backtrace_locations (Ruby Thread::Backtrace::Location objects).
+      # LogError calls this for backtrace_signature calculation — returning nil is safe.
+      def backtrace_locations
+        nil
+      end
+
+      # SyntheticExceptions don't have a cause chain.
+      # LogError calls this for CauseChainExtractor — returning nil skips extraction.
+      def cause
+        nil
+      end
+
       # Returns a mock class object that represents the error type
       # @return [Object] A class-like object with the error type as its name
       def class

data/lib/rails_error_dashboard/middleware/error_catcher.rb

@@ -20,6 +20,9 @@ module RailsErrorDashboard
       end
 
       def call(env)
+        # Record request start time for duration calculation
+        env["rails_error_dashboard.request_start"] = Time.now.to_f
+
         @app.call(env)
       rescue => exception
         # Report to Rails.error (will be logged by our ErrorReporter)