rails_error_dashboard 0.1.38 → 0.2.1

data/db/migrate/20251226020100_create_error_comments.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class CreateErrorComments < ActiveRecord::Migration[8.0]
+class CreateErrorComments < ActiveRecord::Migration[7.0]
   def change
     # Skip if squashed migration already created this table
     return if table_exists?(:rails_error_dashboard_error_comments)

data/db/migrate/20251230075315_cleanup_orphaned_migrations.rb

@@ -1,4 +1,4 @@
-class CleanupOrphanedMigrations < ActiveRecord::Migration[8.0]
+class CleanupOrphanedMigrations < ActiveRecord::Migration[7.0]
   def change
   end
 end

data/db/migrate/20260220000001_add_exception_cause_to_error_logs.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class AddExceptionCauseToErrorLogs < ActiveRecord::Migration[7.0]
+  def change
+    unless column_exists?(:rails_error_dashboard_error_logs, :exception_cause)
+      add_column :rails_error_dashboard_error_logs, :exception_cause, :text
+    end
+  end
+end

data/db/migrate/20260220000002_add_enriched_context_to_error_logs.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AddEnrichedContextToErrorLogs < ActiveRecord::Migration[7.0]
+  def change
+    unless column_exists?(:rails_error_dashboard_error_logs, :http_method)
+      add_column :rails_error_dashboard_error_logs, :http_method, :string, limit: 10
+      add_column :rails_error_dashboard_error_logs, :hostname, :string, limit: 255
+      add_column :rails_error_dashboard_error_logs, :content_type, :string, limit: 100
+      add_column :rails_error_dashboard_error_logs, :request_duration_ms, :integer
+    end
+  end
+end

data/db/migrate/20260220000003_add_time_series_indexes_to_error_logs.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# Tier 0 time-series optimization: BRIN and functional indexes
+#
+# BRIN (Block Range Index) on occurred_at:
+# - 99.9% smaller than B-tree (72KB vs 676MB on 100M rows)
+# - Nearly identical query performance for time-range scans
+# - Perfect for INSERT-heavy tables with naturally ordered timestamps
+#
+# Functional indexes for Groupdate:
+# - Pre-compute DATE_TRUNC expressions used by group_by_day/group_by_hour
+# - Up to 70x speedup on analytics dashboard queries
+#
+# All PostgreSQL-specific — gracefully skipped on SQLite/MySQL.
+class AddTimeSeriesIndexesToErrorLogs < ActiveRecord::Migration[7.0]
+  disable_ddl_transaction!
+
+  def up
+    return unless postgresql?
+
+    # BRIN index on occurred_at for time-range scans
+    # Replaces expensive B-tree sequential scans on large tables
+    unless index_exists?(:rails_error_dashboard_error_logs, :occurred_at, name: "index_error_logs_on_occurred_at_brin")
+      execute <<-SQL
+        CREATE INDEX CONCURRENTLY index_error_logs_on_occurred_at_brin
+        ON rails_error_dashboard_error_logs
+        USING brin (occurred_at)
+      SQL
+    end
+
+    # Functional index for daily grouping (used by group_by_day)
+    unless index_exists_by_name?("index_error_logs_on_occurred_at_day")
+      execute <<-SQL
+        CREATE INDEX CONCURRENTLY index_error_logs_on_occurred_at_day
+        ON rails_error_dashboard_error_logs
+        (DATE_TRUNC('day', occurred_at))
+      SQL
+    end
+
+    # Functional index for hourly grouping (used by group_by_hour)
+    unless index_exists_by_name?("index_error_logs_on_occurred_at_hour")
+      execute <<-SQL
+        CREATE INDEX CONCURRENTLY index_error_logs_on_occurred_at_hour
+        ON rails_error_dashboard_error_logs
+        (DATE_TRUNC('hour', occurred_at))
+      SQL
+    end
+  end
+
+  def down
+    return unless postgresql?
+
+    execute "DROP INDEX IF EXISTS index_error_logs_on_occurred_at_brin"
+    execute "DROP INDEX IF EXISTS index_error_logs_on_occurred_at_day"
+    execute "DROP INDEX IF EXISTS index_error_logs_on_occurred_at_hour"
+  end
+
+  private
+
+  def postgresql?
+    ActiveRecord::Base.connection.adapter_name.downcase == "postgresql"
+  end
+
+  def index_exists_by_name?(name)
+    ActiveRecord::Base.connection.execute(
+      "SELECT 1 FROM pg_indexes WHERE indexname = '#{name}'"
+    ).any?
+  end
+end

data/db/migrate/20260221000001_add_environment_info_to_error_logs.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class AddEnvironmentInfoToErrorLogs < ActiveRecord::Migration[7.0]
+  def change
+    unless column_exists?(:rails_error_dashboard_error_logs, :environment_info)
+      add_column :rails_error_dashboard_error_logs, :environment_info, :text
+    end
+  end
+end

data/db/migrate/20260221000002_add_reopened_at_to_error_logs.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class AddReopenedAtToErrorLogs < ActiveRecord::Migration[7.0]
+  def change
+    unless column_exists?(:rails_error_dashboard_error_logs, :reopened_at)
+      add_column :rails_error_dashboard_error_logs, :reopened_at, :datetime
+    end
+  end
+end

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"))