rails_error_dashboard 0.3.1 → 0.4.0

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

@@ -0,0 +1,126 @@
+<% content_for :page_title, "Swallowed Exceptions" %>
+
+<div class="container-fluid py-4">
+  <div class="d-flex justify-content-between align-items-center mb-4">
+    <h1 class="h3 mb-0">
+      <i class="bi bi-eye-slash me-2"></i>
+      Swallowed Exceptions
+    </h1>
+
+    <div class="btn-group" role="group">
+      <%= link_to swallowed_exceptions_errors_path(days: 7), class: "btn btn-sm #{@days == 7 ? 'btn-primary' : 'btn-outline-primary'}" do %>
+        7 Days
+      <% end %>
+      <%= link_to swallowed_exceptions_errors_path(days: 30), class: "btn btn-sm #{@days == 30 ? 'btn-primary' : 'btn-outline-primary'}" do %>
+        30 Days
+      <% end %>
+      <%= link_to swallowed_exceptions_errors_path(days: 90), class: "btn btn-sm #{@days == 90 ? 'btn-primary' : 'btn-outline-primary'}" do %>
+        90 Days
+      <% end %>
+    </div>
+  </div>
+
+  <% if @unique_count == 0 %>
+    <div class="text-center py-5">
+      <i class="bi bi-check-circle display-1 text-success mb-3"></i>
+      <h4 class="text-muted">No Swallowed Exceptions Detected</h4>
+      <p class="text-muted">
+        No exceptions with a rescue ratio above <%= (RailsErrorDashboard.configuration.swallowed_exception_threshold * 100).round %>% were detected in the last <%= @days %> days.
+      </p>
+      <div class="card mx-auto" style="max-width: 500px;">
+        <div class="card-body text-start">
+          <h6>How swallowed exceptions are detected:</h6>
+          <ul class="mb-0">
+            <li>TracePoint(:raise) counts every exception raised</li>
+            <li>TracePoint(:rescue) counts every exception rescued</li>
+            <li>High rescue/raise ratio = likely swallowed (silently rescued)</li>
+            <li>Requires Ruby 3.3+ and <code>detect_swallowed_exceptions = true</code></li>
+          </ul>
+        </div>
+      </div>
+    </div>
+  <% else %>
+    <div class="row mb-4">
+      <div class="col-md-4">
+        <div class="card text-center">
+          <div class="card-body">
+            <div class="display-6 text-danger"><%= @unique_count %></div>
+            <small class="text-muted">Swallowed Patterns</small>
+          </div>
+        </div>
+      </div>
+      <div class="col-md-4">
+        <div class="card text-center">
+          <div class="card-body">
+            <div class="display-6 text-warning"><%= number_with_delimiter(@total_rescue_count) %></div>
+            <small class="text-muted">Total Rescues</small>
+          </div>
+        </div>
+      </div>
+      <div class="col-md-4">
+        <div class="card text-center">
+          <div class="card-body">
+            <div class="display-6 text-info"><%= number_with_delimiter(@total_raise_count) %></div>
+            <small class="text-muted">Total Raises</small>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <div class="card mb-4">
+      <div class="card-header bg-white d-flex justify-content-between align-items-center">
+        <h5 class="mb-0">
+          <i class="bi bi-eye-slash text-danger me-2"></i>
+          Swallowed Exception Patterns
+          <span class="badge bg-danger"><%= @unique_count %></span>
+        </h5>
+        <small class="text-muted"><%== @pagy.info_tag %></small>
+      </div>
+      <div class="card-body p-0">
+        <div class="table-responsive">
+          <table class="table table-hover mb-0">
+            <thead class="table-light">
+              <tr>
+                <th>Exception Class</th>
+                <th width="250">Raise Location</th>
+                <th width="250">Rescue Location</th>
+                <th width="100">Raises</th>
+                <th width="100">Rescues</th>
+                <th width="100">Ratio</th>
+                <th width="140">Last Seen</th>
+              </tr>
+            </thead>
+            <tbody>
+              <% @entries.each do |entry| %>
+                <tr>
+                  <td><code style="font-size: 0.85em;"><%= entry[:exception_class] %></code></td>
+                  <td><small class="text-muted text-break"><%= entry[:raise_location] %></small></td>
+                  <td><small class="text-muted text-break"><%= entry[:rescue_location] || "Unknown" %></small></td>
+                  <td><span class="badge bg-info text-dark"><%= number_with_delimiter(entry[:raise_count]) %></span></td>
+                  <td><span class="badge bg-warning text-dark"><%= number_with_delimiter(entry[:rescue_count]) %></span></td>
+                  <td>
+                    <% ratio_pct = (entry[:rescue_ratio] * 100).round(1) %>
+                    <span class="badge <%= ratio_pct >= 99 ? 'bg-danger' : ratio_pct >= 95 ? 'bg-warning text-dark' : 'bg-secondary' %>">
+                      <%= ratio_pct %>%
+                    </span>
+                  </td>
+                  <td><%= local_time_ago(entry[:last_seen]) %></td>
+                </tr>
+              <% end %>
+            </tbody>
+          </table>
+        </div>
+      </div>
+      <div class="card-footer bg-white border-top d-flex justify-content-between align-items-center">
+        <div>
+          <small class="text-muted">
+            <i class="bi bi-lightbulb text-warning"></i> Swallowed exceptions are raised then silently rescued. They may hide real bugs.
+          </small>
+        </div>
+        <div>
+          <%== @pagy.series_nav(:bootstrap) if @pagy.pages > 1 %>
+        </div>
+      </div>
+    </div>
+  <% end %>
+</div>

data/config/routes.rb

@@ -27,6 +27,10 @@ RailsErrorDashboard::Engine.routes.draw do
       get :cache_health_summary
       get :job_health_summary
       get :database_health_summary
+      get :swallowed_exceptions
+      get :rack_attack_summary
+      get :diagnostic_dumps
+      post :create_diagnostic_dump
       post :batch_action
     end
   end

data/db/migrate/20251223000000_create_rails_error_dashboard_complete_schema.rb

@@ -89,6 +89,12 @@ class CreateRailsErrorDashboardCompleteSchema < ActiveRecord::Migration[7.0]
       # System health snapshot (from 20260304000001)
       t.text :system_health
 
+      # Local variable capture (from 20260306000001)
+      t.text :local_variables
+
+      # Instance variable capture (from 20260306000002)
+      t.text :instance_variables
+
       t.timestamps
     end
 
@@ -191,6 +197,32 @@ class CreateRailsErrorDashboardCompleteSchema < ActiveRecord::Migration[7.0]
     add_index :rails_error_dashboard_error_comments, :error_log_id
     add_index :rails_error_dashboard_error_comments, [ :error_log_id, :created_at ], name: "index_error_comments_on_error_and_time"
 
+    # Create swallowed_exceptions table (from 20260306000003)
+    create_table :rails_error_dashboard_swallowed_exceptions do |t|
+      t.string   :exception_class,  null: false
+      t.string   :raise_location,   null: false, limit: 500
+      t.string   :rescue_location,  limit: 500
+      t.datetime :period_hour,      null: false
+      t.integer  :raise_count,      null: false, default: 0
+      t.integer  :rescue_count,     null: false, default: 0
+      t.datetime :last_seen_at
+      t.bigint   :application_id
+      t.timestamps
+    end
+    add_index :rails_error_dashboard_swallowed_exceptions,
+              [ :exception_class, :period_hour ],
+              name: "index_swallowed_exceptions_on_class_and_hour"
+    add_index :rails_error_dashboard_swallowed_exceptions,
+              :period_hour,
+              name: "index_swallowed_exceptions_on_period_hour"
+    add_index :rails_error_dashboard_swallowed_exceptions,
+              [ :application_id, :period_hour ],
+              name: "index_swallowed_exceptions_on_app_and_hour"
+    add_index :rails_error_dashboard_swallowed_exceptions,
+              [ :exception_class, :raise_location, :rescue_location, :period_hour, :application_id ],
+              unique: true,
+              name: "index_swallowed_exceptions_upsert_key"
+
     # PostgreSQL-specific indexes (BRIN + functional for time-series optimization)
     if ActiveRecord::Base.connection.adapter_name.downcase == "postgresql"
       execute <<-SQL
@@ -221,6 +253,7 @@ class CreateRailsErrorDashboardCompleteSchema < ActiveRecord::Migration[7.0]
   end
 
   def down
+    drop_table :rails_error_dashboard_swallowed_exceptions, if_exists: true
     drop_table :rails_error_dashboard_error_comments, if_exists: true
     drop_table :rails_error_dashboard_cascade_patterns, if_exists: true
     drop_table :rails_error_dashboard_error_baselines, if_exists: true

data/db/migrate/20260306000001_add_local_variables_to_error_logs.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class AddLocalVariablesToErrorLogs < ActiveRecord::Migration[7.0]
+  def up
+    return if column_exists?(:rails_error_dashboard_error_logs, :local_variables)
+
+    add_column :rails_error_dashboard_error_logs, :local_variables, :text
+  end
+
+  def down
+    remove_column :rails_error_dashboard_error_logs, :local_variables if column_exists?(:rails_error_dashboard_error_logs, :local_variables)
+  end
+end

data/db/migrate/20260306000002_add_instance_variables_to_error_logs.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddInstanceVariablesToErrorLogs < ActiveRecord::Migration[7.0]
+  def change
+    add_column :rails_error_dashboard_error_logs, :instance_variables, :text
+  end
+end

data/db/migrate/20260306000003_create_rails_error_dashboard_swallowed_exceptions.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class CreateRailsErrorDashboardSwallowedExceptions < ActiveRecord::Migration[7.0]
+  def change
+    create_table :rails_error_dashboard_swallowed_exceptions do |t|
+      t.string   :exception_class,  null: false
+      t.string   :raise_location,   null: false, limit: 500
+      t.string   :rescue_location,  limit: 500
+      t.datetime :period_hour,      null: false
+      t.integer  :raise_count,      null: false, default: 0
+      t.integer  :rescue_count,     null: false, default: 0
+      t.datetime :last_seen_at
+      t.bigint   :application_id
+      t.timestamps
+    end
+
+    add_index :rails_error_dashboard_swallowed_exceptions,
+              [ :exception_class, :period_hour ],
+              name: "index_swallowed_exceptions_on_class_and_hour"
+
+    add_index :rails_error_dashboard_swallowed_exceptions,
+              :period_hour,
+              name: "index_swallowed_exceptions_on_period_hour"
+
+    add_index :rails_error_dashboard_swallowed_exceptions,
+              [ :application_id, :period_hour ],
+              name: "index_swallowed_exceptions_on_app_and_hour"
+
+    add_index :rails_error_dashboard_swallowed_exceptions,
+              [ :exception_class, :raise_location, :rescue_location, :period_hour, :application_id ],
+              unique: true,
+              name: "index_swallowed_exceptions_upsert_key"
+  end
+end

data/db/migrate/20260307000001_create_rails_error_dashboard_diagnostic_dumps.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class CreateRailsErrorDashboardDiagnosticDumps < ActiveRecord::Migration[7.0]
+  def change
+    create_table :rails_error_dashboard_diagnostic_dumps do |t|
+      t.references :application, null: false,
+        foreign_key: { to_table: :rails_error_dashboard_applications }
+      t.text :dump_data, null: false
+      t.string :note
+      t.datetime :captured_at, null: false
+      t.timestamps
+    end
+
+    add_index :rails_error_dashboard_diagnostic_dumps, :captured_at,
+              name: "index_diagnostic_dumps_on_captured_at"
+  end
+end

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

@@ -32,6 +32,9 @@ module RailsErrorDashboard
       class_option :git_blame, type: :boolean, default: false, desc: "Enable git blame integration (NEW!)"
       class_option :breadcrumbs, type: :boolean, default: false, desc: "Enable breadcrumbs (request activity trail)"
       class_option :system_health, type: :boolean, default: false, desc: "Enable system health snapshot at error time"
+      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"
 
       def welcome_message
         say "\n"
@@ -174,6 +177,24 @@ module RailsErrorDashboard
             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"
           }
         ]
 
@@ -195,6 +216,11 @@ module RailsErrorDashboard
               say "    ✗ Disabled", :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
+          end
         end
 
         say "\n"
@@ -303,6 +329,9 @@ module RailsErrorDashboard
         @enable_git_blame = @selected_features&.dig(:git_blame) || options[:git_blame]
         @enable_breadcrumbs = @selected_features&.dig(:breadcrumbs) || options[:breadcrumbs]
         @enable_system_health = @selected_features&.dig(:system_health) || options[:system_health]
+        @enable_swallowed_exceptions = @selected_features&.dig(:swallowed_exceptions) || options[:swallowed_exceptions]
+        @enable_crash_capture = @selected_features&.dig(:crash_capture) || options[:crash_capture]
+        @enable_diagnostic_dump = @selected_features&.dig(:diagnostic_dump) || options[:diagnostic_dump]
 
         template "initializer.rb", "config/initializers/rails_error_dashboard.rb"
       end
@@ -405,6 +434,9 @@ module RailsErrorDashboard
         developer_tools_features << "Git Blame" if @enable_git_blame
         developer_tools_features << "Breadcrumbs" if @enable_breadcrumbs
         developer_tools_features << "System Health" if @enable_system_health
+        developer_tools_features << "Swallowed Exception Detection" if @enable_swallowed_exceptions
+        developer_tools_features << "Process Crash Capture" if @enable_crash_capture
+        developer_tools_features << "Diagnostic Dump" if @enable_diagnostic_dump
 
         if developer_tools_features.any?
           say "\nDeveloper Tools:", :cyan

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

@@ -356,7 +356,54 @@ RailsErrorDashboard.configure do |config|
   config.enable_system_health = false
 
 <% end -%>
+<% if @enable_swallowed_exceptions -%>
+  # Swallowed Exception Detection - ENABLED
+  # Requires Ruby 3.3+ — detects exceptions that are raised then silently rescued
+  # Uses TracePoint(:rescue), which was added in Ruby 3.3 (Feature #19572)
+  config.detect_swallowed_exceptions = true
+  config.swallowed_exception_threshold = 0.95       # Rescue ratio to flag (95%+)
+  # config.swallowed_exception_flush_interval = 60   # Seconds between DB flushes
+  # config.swallowed_exception_max_cache_size = 1000  # Max entries per thread
+  # config.swallowed_exception_ignore_classes = []    # App-specific exceptions to skip
+  # To disable: Set config.detect_swallowed_exceptions = false
 
+<% else -%>
+  # Swallowed Exception Detection - DISABLED
+  # Requires Ruby 3.3+ (TracePoint(:rescue) not available before 3.3)
+  # To enable: Set config.detect_swallowed_exceptions = true
+  config.detect_swallowed_exceptions = false
+  # config.swallowed_exception_threshold = 0.95
+
+<% end -%>
+<% if @enable_diagnostic_dump -%>
+  # Diagnostic Dump - ENABLED
+  # On-demand system state snapshot via rake task or dashboard button
+  config.enable_diagnostic_dump = true
+  # To disable: Set config.enable_diagnostic_dump = false
+
+<% else -%>
+  # Diagnostic Dump - DISABLED
+  # On-demand system state snapshot (rake task + dashboard page)
+  # To enable: Set config.enable_diagnostic_dump = true
+  config.enable_diagnostic_dump = false
+
+<% end -%>
+<% if @enable_crash_capture -%>
+  # Process Crash Capture - ENABLED
+  # Captures fatal crashes via at_exit hook. Crash data is written to disk as JSON
+  # and imported into the database on next boot. Zero runtime overhead.
+  config.enable_crash_capture = true
+  # config.crash_capture_path = "/tmp/my_app_crashes"  # Default: Dir.tmpdir
+  # To disable: Set config.enable_crash_capture = false
+
+<% else -%>
+  # Process Crash Capture - DISABLED
+  # Captures fatal crashes via at_exit hook (written to disk, imported on next boot)
+  # To enable: Set config.enable_crash_capture = true
+  config.enable_crash_capture = false
+  # config.crash_capture_path = "/tmp/my_app_crashes"
+
+<% end -%>
   # Repository settings (auto-detected from git remote, optional override)
   # config.repository_url = ENV["REPOSITORY_URL"]  # e.g., "https://github.com/user/repo"
   # config.repository_branch = ENV.fetch("REPOSITORY_BRANCH", "main")  # Default branch

data/lib/rails_error_dashboard/commands/flush_swallowed_exceptions.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Commands
+    # Command: Upsert swallowed exception raise/rescue counts into the database.
+    #
+    # Receives snapshot hashes from SwallowedExceptionTracker and merges them
+    # into hourly-bucketed rows. Uses find_or_initialize_by + increment for
+    # cross-database compatibility (no raw SQL upsert).
+    #
+    # raise_counts keys: "ClassName|path:line"
+    # rescue_counts keys: "ClassName|raise_path:line->rescue_path:line"
+    class FlushSwallowedExceptions
+      def self.call(raise_counts:, rescue_counts:)
+        new(raise_counts: raise_counts, rescue_counts: rescue_counts).call
+      end
+
+      def initialize(raise_counts:, rescue_counts:)
+        @raise_counts = raise_counts
+        @rescue_counts = rescue_counts
+      end
+
+      def call
+        period = Time.current.beginning_of_hour
+        app_id = current_application_id
+
+        # Process raise counts
+        @raise_counts.each do |key, count|
+          class_name, location = key.split("|", 2)
+          next if class_name.blank? || location.blank?
+
+          upsert_raise(class_name, location, period, app_id, count)
+        end
+
+        # Process rescue counts
+        @rescue_counts.each do |key, count|
+          class_name, locations = key.split("|", 2)
+          next if class_name.blank? || locations.blank?
+
+          raise_loc, rescue_loc = locations.split("->", 2)
+          next if raise_loc.blank?
+
+          upsert_rescue(class_name, raise_loc, rescue_loc, period, app_id, count)
+        end
+      rescue => e
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] FlushSwallowedExceptions failed: #{e.class} - #{e.message}"
+        )
+      end
+
+      private
+
+      def upsert_raise(class_name, location, period, app_id, count)
+        record = SwallowedException.find_or_initialize_by(
+          exception_class: truncate(class_name, 255),
+          raise_location: truncate(location, 500),
+          rescue_location: nil,
+          period_hour: period,
+          application_id: app_id
+        )
+
+        record.raise_count = (record.raise_count || 0) + count
+        record.last_seen_at = Time.current
+        record.save!
+      rescue => e
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] FlushSwallowedExceptions.upsert_raise failed for #{class_name}: #{e.message}"
+        )
+      end
+
+      def upsert_rescue(class_name, raise_loc, rescue_loc, period, app_id, count)
+        record = SwallowedException.find_or_initialize_by(
+          exception_class: truncate(class_name, 255),
+          raise_location: truncate(raise_loc, 500),
+          rescue_location: rescue_loc.present? ? truncate(rescue_loc, 500) : nil,
+          period_hour: period,
+          application_id: app_id
+        )
+
+        record.rescue_count = (record.rescue_count || 0) + count
+        record.last_seen_at = Time.current
+        record.save!
+      rescue => e
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] FlushSwallowedExceptions.upsert_rescue failed for #{class_name}: #{e.message}"
+        )
+      end
+
+      def current_application_id
+        app_name = RailsErrorDashboard.configuration.application_name
+        return nil unless app_name.present?
+
+        Application.find_by(name: app_name)&.id
+      rescue => e
+        nil
+      end
+
+      def truncate(str, max)
+        str.to_s.truncate(max, omission: "")
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -37,6 +37,34 @@ module RailsErrorDashboard
           context = context.merge(_serialized_system_health: Services::SystemHealthSnapshot.capture)
         end
 
+        # Capture local variables NOW (TracePoint attaches to exception, must extract before job dispatch)
+        if RailsErrorDashboard.configuration.enable_local_variables
+          begin
+            raw_locals = Services::LocalVariableCapturer.extract(exception)
+            if raw_locals.is_a?(Hash) && raw_locals.any?
+              context = context.merge(_serialized_local_variables: Services::VariableSerializer.call(raw_locals))
+            end
+          rescue => e
+            RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Async local variable serialization failed: #{e.message}")
+          end
+        end
+
+        # Capture instance variables NOW (same reason — attached to exception object)
+        if RailsErrorDashboard.configuration.enable_instance_variables
+          begin
+            raw_ivars = Services::LocalVariableCapturer.extract_instance_vars(exception)
+            if raw_ivars.is_a?(Hash) && raw_ivars.any?
+              context = context.merge(_serialized_instance_variables: Services::VariableSerializer.call(
+                raw_ivars,
+                max_count: RailsErrorDashboard.configuration.instance_variable_max_count,
+                additional_filter_patterns: RailsErrorDashboard.configuration.instance_variable_filter_patterns
+              ))
+            end
+          rescue => e
+            RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Async instance variable serialization failed: #{e.message}")
+          end
+        end
+
         # Enqueue the async job using ActiveJob
         # The queue adapter (:sidekiq, :solid_queue, :async) is configured separately
         AsyncErrorLoggingJob.perform_later(exception_data, context)
@@ -179,6 +207,46 @@ module RailsErrorDashboard
           attributes[:system_health] = health_data.to_json
         end
 
+        # Capture local variables (if enabled and column exists)
+        if ErrorLog.column_names.include?("local_variables") && RailsErrorDashboard.configuration.enable_local_variables
+          begin
+            # Sync path: extract from exception ivar
+            raw_locals = Services::LocalVariableCapturer.extract(@exception)
+            # Async path fallback: use pre-serialized locals from call_async context
+            raw_locals ||= @context[:_serialized_local_variables]
+            if raw_locals.is_a?(Hash) && raw_locals.any?
+              serialized = raw_locals == @context[:_serialized_local_variables] ? raw_locals : Services::VariableSerializer.call(raw_locals)
+              attributes[:local_variables] = serialized.to_json
+            end
+          rescue => e
+            RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Local variable serialization failed: #{e.message}")
+          end
+        end
+
+        # Capture instance variables (if enabled and column exists)
+        if ErrorLog.column_names.include?("instance_variables") && RailsErrorDashboard.configuration.enable_instance_variables
+          begin
+            # Sync path: extract from exception ivar
+            raw_ivars = Services::LocalVariableCapturer.extract_instance_vars(@exception)
+            # Async path fallback: use pre-serialized ivars from call_async context
+            raw_ivars ||= @context[:_serialized_instance_variables]
+            if raw_ivars.is_a?(Hash) && raw_ivars.any?
+              serialized = if raw_ivars == @context[:_serialized_instance_variables]
+                raw_ivars
+              else
+                Services::VariableSerializer.call(
+                  raw_ivars,
+                  max_count: RailsErrorDashboard.configuration.instance_variable_max_count,
+                  additional_filter_patterns: RailsErrorDashboard.configuration.instance_variable_filter_patterns
+                )
+              end
+              attributes[:instance_variables] = serialized.to_json
+            end
+          rescue => e
+            RailsErrorDashboard::Logger.debug("[RailsErrorDashboard] Instance variable serialization failed: #{e.message}")
+          end
+        end
+
         # 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))