rails_error_dashboard 0.14.1 → 0.14.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8dc068309c56704b429f7798ce4c3c83b628853179ebc2695c50fa684d2fae9
-  data.tar.gz: 64e3a06e8b60ce8f4c3fe649ca750f228a16e64405b7e239b8440f53e74e536d
+  metadata.gz: f96e195659bca5562fcf7c4ed02c1f8f69c058daec06f6902523958f5746a8a4
+  data.tar.gz: 2ea940fe412652bef9e0f47eb818d4da93a6d7b7cb1e32cd5820e96cf032fafe
 SHA512:
-  metadata.gz: b8605107393952d4e308ebb23f5c1a58ac88dafc9a9664c2429ddb83777a450cb148c1890b25495166a51238d954320bdfcba4b2ef265fe63e8ffea960fb91df
-  data.tar.gz: 4ab62e966ce41257abefdb37e6e3f14a6ae732754cac9ef6c4a4ed37af14982f825e90dac17e8681274959d11ec74bf403458a96ee3069af5919def63b7d77e5
+  metadata.gz: b7b8a36c5ffde9bcd71a0649a0d2df111345625717ec67a997e4bd4929215700408efd95844b41506e3a48aa47fc7179cd1df140aa1274451a1a8760a5f32db7
+  data.tar.gz: d6b3722433ce12451ef44242874dfe98620441832626368d0e8ce9d852396d8e4b00b5cc5773f04a348d48f64254fc763cd4fae4a1580d5b399cb4aab21f3de3

data/README.md

@@ -635,9 +635,9 @@ The installer guides you through optional feature selection — notifications, p
 http://localhost:3000/red
 ```
 
-Default credentials: `gandalf` / `youshallnotpass`
+Default credentials: `gandalf` / `youshallnotpass`, for development and test only.
 
-**Change these before production!** Edit `config/initializers/rails_error_dashboard.rb`
+**Before you deploy anywhere else**, set `ERROR_DASHBOARD_USER` and `ERROR_DASHBOARD_PASSWORD` in that environment. Outside development and test, the app refuses to boot on the defaults. See [Dashboard Credentials](docs/guides/CONFIGURATION.md#dashboard-credentials).
 
 ### 4. Test it out
 
@@ -654,11 +654,8 @@ raise "Test error from Rails Error Dashboard!"
 
 ```ruby
 RailsErrorDashboard.configure do |config|
-  # Authentication
-  config.dashboard_username = ENV.fetch('ERROR_DASHBOARD_USER', 'gandalf')
-  config.dashboard_password = ENV.fetch('ERROR_DASHBOARD_PASSWORD', 'youshallnotpass')
-
-  # Or use your existing auth (Devise, Warden, etc.):
+  # Dashboard login: set ERROR_DASHBOARD_USER and ERROR_DASHBOARD_PASSWORD outside
+  # development and test (the gem reads them itself). Or use your existing auth:
   # config.authenticate_with = -> { warden.authenticated? }
 
   # Optional features — enable as needed

data/app/controllers/rails_error_dashboard/application_controller.rb

@@ -314,6 +314,15 @@ module RailsErrorDashboard
         expected_password = RailsErrorDashboard.configuration.dashboard_password
         next false if expected_username.nil? || expected_password.nil?
 
+        # A blank credential must deny everyone too: "" would equal an empty login.
+        next false if RailsErrorDashboard::Configuration.blank_credential?(expected_username) ||
+                      RailsErrorDashboard::Configuration.blank_credential?(expected_password)
+
+        # The boot check refuses the published credentials outside development
+        # and test, but it is skipped while SECRET_KEY_BASE_DUMMY is set. Refuse
+        # them here as well, so that variable left set at runtime reopens nothing.
+        next false if RailsErrorDashboard.configuration.refuse_default_credentials?
+
         # Non-short-circuit & on purpose: both comparisons always run, so the
         # response time does not reveal which half was wrong.
         ActiveSupport::SecurityUtils.secure_compare(username.to_s, expected_username.to_s) &

data/app/jobs/rails_error_dashboard/retention_cleanup_job.rb

@@ -33,6 +33,32 @@ module RailsErrorDashboard
       )
     end
 
+    # Deletes error logs and everything that references them: dependents first,
+    # all in batches. Occurrences, comments and cascade patterns hold foreign
+    # keys to the log, so deleting the logs first fails, and one unbounded
+    # DELETE would lock the table. Public because error_dashboard:cleanup_resolved
+    # deletes the same way.
+    #
+    # @param scope [ActiveRecord::Relation] the ErrorLog rows to delete
+    # @return [Integer] number of error logs deleted
+    def self.delete_with_dependents(scope)
+      ids = scope.select(:id)
+
+      ErrorOccurrence.where(error_log_id: ids).in_batches(of: 1000).delete_all
+      # Hour buckets for storm-shed events. Listed explicitly because delete_all
+      # does not fire the has_many :dependent callback on ErrorLog -- without
+      # this line the buckets outlive the group they describe, forever.
+      EventCount.where(error_log_id: ids).in_batches(of: 1000).delete_all if EventCount.table_exists?
+      ErrorComment.where(error_log_id: ids).in_batches(of: 1000).delete_all
+      CascadePattern.where(parent_error_id: ids)
+                    .or(CascadePattern.where(child_error_id: ids))
+                    .in_batches(of: 1000).delete_all
+
+      deleted = 0
+      scope.in_batches(of: 1000) { |batch| deleted += batch.delete_all }
+      deleted
+    end
+
     # @return [Integer] number of errors deleted
     def perform
       retention_days = RailsErrorDashboard.configuration.retention_days
@@ -52,29 +78,7 @@ module RailsErrorDashboard
       expired_scope = self.class.expired_scope(cutoff)
       return 0 if expired_scope.none?
 
-      deleted_count = 0
-
-      # Delete dependents first, then errors — all in batches to prevent table locks
-      expired_ids_scope = expired_scope.select(:id)
-
-      # Batch delete dependent records (occurrences, comments, cascade patterns)
-      ErrorOccurrence.where(error_log_id: expired_ids_scope).in_batches(of: 1000).delete_all
-      # Hour buckets for storm-shed events. Listed explicitly because this job
-      # deletes with delete_all, which does not fire the has_many :dependent
-      # callback on ErrorLog -- without this line the buckets outlive the group
-      # they describe, forever. The migration's own comment promised this
-      # pruning before the code existed.
-      EventCount.where(error_log_id: expired_ids_scope).in_batches(of: 1000).delete_all if EventCount.table_exists?
-      ErrorComment.where(error_log_id: expired_ids_scope).in_batches(of: 1000).delete_all
-      CascadePattern.where(parent_error_id: expired_ids_scope)
-                    .or(CascadePattern.where(child_error_id: expired_ids_scope))
-                    .in_batches(of: 1000).delete_all
-
-      # Now batch delete the error logs themselves
-      expired_scope.in_batches(of: 1000) do |batch|
-        batch_size = batch.delete_all
-        deleted_count += batch_size
-      end
+      deleted_count = self.class.delete_with_dependents(expired_scope)
 
       # delete_all skips callbacks, and the stat cards are cached.
       Services::AnalyticsCacheManager.clear if deleted_count > 0

data/config/locales/ja.yml

@@ -23,7 +23,7 @@ ja:
         '30': 30日間
         '90': 90日間
       frame_category:
-        app: 自分のコード
+        app: アプリケーションコード
         gem: Gem
         framework: Rails フレームワーク
         ruby_core: Ruby コア
@@ -520,7 +520,7 @@ ja:
         user_agent: 'User Agent:'
         ip_address: 'IP アドレス:'
         replay: 'リクエストの再現:'
-        raw_user_agent: User Agent の生データ
+        raw_user_agent: User Agent 文字列
         duration_seconds: "%{value}秒"
         duration_ms: "%{value}ミリ秒"
         copy_curl: curl としてコピー
@@ -530,7 +530,7 @@ ja:
         snapshot: 'スナップショット:'
         snapshot_captured_html: '%{time} に取得'
         snapshot_stale: より前の発生から取得 — それ以降の発生はコンテキストを伴いませんでした
-        snapshot_fidelity_lite: 縮小された取得 (storm 保護によりコンテキストの payload が破棄されました)
+        snapshot_fidelity_lite: 限定的な情報取得（storm 保護によりコンテキストの payload を省略）
         snapshot_fidelity_minimal: storm 中にカウントされました — コンテキストは取得されていません
         snapshot_fidelity_partial: 混在したスナップショット — 一部のフィールドは以前の発生時のものです
         snapshot_unknown: RED がスナップショットの出所を記録する前に取得されました
@@ -667,10 +667,10 @@ ja:
           backtrace: Backtrace
         backtrace:
           label: 'Backtrace:'
-          frame_counts: "(自分のコード%{app}件、フレームワーク/gem %{framework}件)"
+          frame_counts: "(アプリケーションコード%{app}件、フレームワーク/gem %{framework}件)"
           copy_full: Backtrace 全体をコピー
           copy_full_title: Backtrace 全体をコピー
-          your_code: 自分のコード
+          your_code: アプリケーションコード
           framework_code: フレームワーク・gem のコード
           frames:
             other: "%{count}フレーム"

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: true, desc: "Enable async error logging (default: true, uses Rails :async adapter — no extra infrastructure needed)"
+      class_option :async_logging, type: :boolean, default: true, desc: "Enable async error logging (default: true; jobs run on your app's Active Job adapter, so production needs a worker)"
       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')"
@@ -383,7 +383,7 @@ module RailsErrorDashboard
           return
         end
 
-        route "mount RailsErrorDashboard::Engine => '/red'  # RED (Rails Error Dashboard) — also works at /error_dashboard"
+        route "mount RailsErrorDashboard::Engine => '/red'  # RED (Rails Error Dashboard)"
       end
 
       def show_feature_summary
@@ -400,7 +400,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
+        say "  ✓ Async Logging (runs on your app's Active Job adapter)", :green
 
         # Count optional features enabled
         enabled_count = 0
@@ -477,14 +477,11 @@ module RailsErrorDashboard
         say "  → Set PAGERDUTY_INTEGRATION_KEY in .env", :yellow if @enable_pagerduty
         say "  → Set WEBHOOK_URLS in .env", :yellow if @enable_webhooks
         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
+          # RED's jobs run on the app's own Active Job adapter; async_adapter only
+          # feeds validation and the Settings page. Rails 8 production uses Solid
+          # Queue, which needs a worker, so don't promise that none is needed.
+          say "  → Async logging enqueues on your app's config.active_job.queue_adapter.", :yellow
+          say "    Run a worker for the default and error_notifications queues, or set config.async_logging = false.", :yellow
         end
 
         # Database-specific instructions
@@ -503,21 +500,22 @@ module RailsErrorDashboard
           else
             say "  3. Run: rails db:migrate:error_dashboard"
           end
-          say "  4. Update credentials in config/initializers/rails_error_dashboard.rb"
+          say "  4. Before deploying: set ERROR_DASHBOARD_USER and ERROR_DASHBOARD_PASSWORD there"
           say "  5. Restart your Rails server"
           say "  6. Visit http://localhost:3000/red"
           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 "  2. Before deploying: set ERROR_DASHBOARD_USER and ERROR_DASHBOARD_PASSWORD there"
           say "  3. Restart your Rails server"
           say "  4. Visit http://localhost:3000/red"
         end
         say "Authentication:", :cyan
-        say "  Default: HTTP Basic Auth (gandalf/youshallnotpass)", :white
+        say "  Default: HTTP Basic Auth, gandalf/youshallnotpass in development and test only", :white
+        say "  Elsewhere: set ERROR_DASHBOARD_USER and ERROR_DASHBOARD_PASSWORD, or the app won't boot", :white
         say "  Devise/Warden: config.authenticate_with = -> { warden.authenticated? }", :white
         say "  Session-based: config.authenticate_with = -> { session[:admin] == true }", :white
-        say "  See: https://github.com/AnjanJ/rails_error_dashboard/blob/main/docs/guides/CONFIGURATION.md#custom-authentication", :white
+        say "  See: https://github.com/AnjanJ/rails_error_dashboard/blob/main/docs/guides/CONFIGURATION.md#dashboard-credentials", :white
         say "\n"
         say "Issue Tracking (optional):", :cyan
         say "  Create a dedicated RED (Rails Error Dashboard) bot account on your platform:", :white
@@ -549,7 +547,7 @@ module RailsErrorDashboard
 
       def build_quick_defaults
         {
-          # Async ON (built-in Rails :async adapter, zero infrastructure)
+          # Async ON (runs on the app's Active Job adapter)
           async_logging: true,
           # All analytics ON — run at query/background time, zero request-path overhead
           baseline_alerts: true,

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

@@ -5,9 +5,12 @@ RailsErrorDashboard.configure do |config|
   # AUTHENTICATION (Always Required - Cannot Be Disabled)
   # ============================================================================
 
-  # Dashboard authentication credentials
-  # ⚠️ CHANGE THESE BEFORE PRODUCTION! ⚠️
-  # Authentication is ALWAYS enforced in ALL environments (production, development, test)
+  # Dashboard login (HTTP Basic Auth). Always enforced, in every environment.
+  # gandalf / youshallnotpass work in development and test only. Everywhere
+  # else, set ERROR_DASHBOARD_USER and ERROR_DASHBOARD_PASSWORD in the
+  # environment, or the app refuses to boot. Don't replace the fallback values
+  # below with a real password: it would end up in source control.
+  # https://github.com/AnjanJ/rails_error_dashboard/blob/main/docs/guides/CONFIGURATION.md#dashboard-credentials
   config.dashboard_username = ENV.fetch("ERROR_DASHBOARD_USER", "gandalf")
   config.dashboard_password = ENV.fetch("ERROR_DASHBOARD_PASSWORD", "youshallnotpass")
 
@@ -160,9 +163,11 @@ RailsErrorDashboard.configure do |config|
 
 <% if @enable_async_logging -%>
   # Async Error Logging - ENABLED
-  # 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.
+  # Errors are logged in background jobs, off the request path. The jobs run on
+  # your app's Active Job adapter (config.active_job.queue_adapter), so in
+  # production a worker must process the default and error_notifications queues
+  # (Rails 8: bin/jobs for Solid Queue). async_adapter below is only validated
+  # and shown on the Settings page; it does not choose the backend.
   config.async_logging = true
   config.async_adapter = :async  # Options: :async (built-in), :sidekiq, :solid_queue
   # To disable: Set config.async_logging = false
@@ -446,7 +451,8 @@ RailsErrorDashboard.configure do |config|
   config.enable_internal_logging = false
 
   # Log level (default: :silent)
-  # Options: :debug, :info, :warn, :error, :silent
+  # Options: :debug, :info, :warn, :error, :fatal, :silent
+  # (RED has no fatal-level messages, so :fatal logs nothing, like :silent)
   config.log_level = :silent
 
   # Example: Enable verbose logging for debugging

data/lib/generators/rails_error_dashboard/solid_queue/solid_queue_generator.rb

@@ -2,34 +2,54 @@
 
 module RailsErrorDashboard
   module Generators
-    # Generator for Solid Queue configuration
+    # Deprecated: checks the app's Solid Queue config for RED. Writes nothing.
     # Usage: rails generate rails_error_dashboard:solid_queue
+    #
+    # It used to write a config/queue.yml with workers and no dispatchers.
+    # Solid Queue only falls back to its default dispatcher when a section has
+    # neither, so that file ran no dispatcher: no delayed job ran, the host
+    # app's own included. A Solid Queue config with a "*" worker and a
+    # dispatcher already processes RED's queues, so this generator now only
+    # checks the file the app has. It never writes Solid Queue's files or
+    # points at Solid Queue's installer (decision 0001). To be removed in a
+    # later minor release.
     class SolidQueueGenerator < Rails::Generators::Base
-      source_root File.expand_path("templates", __dir__)
+      desc "Deprecated: checks config/queue.yml for problems that stop RED's jobs. Writes nothing."
 
-      desc "Creates Solid Queue configuration for RailsErrorDashboard"
+      def check_queue_config
+        say "\nrails_error_dashboard:solid_queue is deprecated and no longer writes config/queue.yml.", :yellow
+        say "A Solid Queue config with a \"*\" worker and a dispatcher already processes RED's queues.\n\n"
 
-      def create_queue_config
-        template "queue.yml", "config/queue.yml"
+        check = RailsErrorDashboard::Services::SolidQueueConfigCheck
+        path = check.config_path(destination_root)
+        relative = path.relative_path_from(Pathname(destination_root)).to_s
+
+        unless path.exist?
+          say "No #{relative}: Solid Queue runs its defaults (a \"*\" worker and a dispatcher), which process RED's queues.", :green
+          return
+        end
+
+        environments = check.app_environments(destination_root)
+        environments = [ Rails.env.to_s ] if environments.empty?
+        result = check.call(path, environments: environments)
+
+        if result[:skipped]
+          say "Could not check #{relative}: #{result[:skipped]}", :yellow
+        elsif result[:problems].any?
+          say "#{relative} has problems that stop jobs from running:", :red
+          result[:problems].each { |problem| say "  - #{problem}", :red }
+          say ""
+          check::FIX.each { |line| say line, :yellow }
+        else
+          say "#{relative} processes RED's queues (#{check.red_queue_names.join(', ')}) and runs a dispatcher.", :green
+        end
       end
 
       def show_instructions
-        say "\n" + "=" * 80, :green
-        say "Solid Queue configuration created!", :green
-        say "=" * 80, :green
-        say "\nNext steps:", :yellow
-        say "  1. Install Solid Queue gem (if not already):", :cyan
-        say "     bundle add solid_queue", :white
-        say "\n  2. Run Solid Queue migrations:", :cyan
-        say "     bin/rails solid_queue:install", :white
-        say "\n  3. Set ActiveJob adapter in config/application.rb:", :cyan
-        say "     config.active_job.queue_adapter = :solid_queue", :white
-        say "\n  4. Start Solid Queue worker:", :cyan
-        say "     bin/jobs", :white
-        say "\n  5. Enable async logging in config/initializers/rails_error_dashboard.rb:", :cyan
-        say "     config.async_logging = true", :white
-        say "     config.async_adapter = :solid_queue", :white
-        say "\n" + "=" * 80, :green
+        say "\nTo run RED's jobs with Solid Queue:", :cyan
+        say "  config.active_job.queue_adapter = :solid_queue   (config/environments/production.rb)", :white
+        say "  Run a worker: bin/jobs, or SOLID_QUEUE_IN_PUMA=1 with Puma's solid_queue plugin", :white
+        say "  Check anytime: bin/rails error_dashboard:verify\n", :white
       end
     end
   end

data/lib/generators/rails_error_dashboard/uninstall/uninstall_generator.rb

@@ -5,6 +5,11 @@ module RailsErrorDashboard
     class UninstallGenerator < Rails::Generators::Base
       desc "Uninstalls Rails Error Dashboard and removes all associated files and data"
 
+      MIGRATION_GLOBS = [
+        "db/migrate/*rails_error_dashboard*.rb",
+        "db/error_dashboard_migrate/*rails_error_dashboard*.rb"
+      ].freeze
+
       class_option :keep_data, type: :boolean, default: false, desc: "Keep error data in database (don't drop tables)"
       class_option :skip_confirmation, type: :boolean, default: false, desc: "Skip confirmation prompts"
       class_option :manual_only, type: :boolean, default: false, desc: "Show manual instructions only, don't perform automated uninstall"
@@ -35,6 +40,15 @@ module RailsErrorDashboard
         say "  #{status_icon(@components[:migrations])} Migrations (#{migration_count} files)"
         say "  #{status_icon(@components[:tables])} Database tables (#{table_count} tables)"
         say "\n"
+
+        # Couldn't see the error database (no database.yml entry for it, or the
+        # server is down). Carrying on would remove the initializer and leave
+        # every table behind, with nothing left that knows where they are.
+        if @database_error && !options[:keep_data] && !options[:manual_only]
+          raise Thor::Error, "Can't reach the error database, so nothing was removed: #{@database_error}\n" \
+                             "Fix config/database.yml (or start the database) and run this again, " \
+                             "or pass --keep-data to remove only the files."
+        end
       end
 
       def show_manual_instructions
@@ -42,13 +56,16 @@ module RailsErrorDashboard
         say "  📖 Manual Uninstall Instructions", :cyan
         say "=" * 80
         say "\n"
-
-        say "Step 1: Remove from Gemfile", :yellow
-        say "  Open: Gemfile"
-        say "  Remove: gem 'rails_error_dashboard'"
-        say "  Run: bundle install"
+        say "Do these in order: the table drop needs the gem, so the Gemfile comes last.", :yellow
         say "\n"
 
+        if @components[:tables]
+          say "Step 1: Drop database tables (⚠️  DESTRUCTIVE - will delete all error data)", :yellow
+          say "  Run: bin/rails rails_error_dashboard:db:drop"
+          say "  It drops every RED table in foreign-key order, on the error database if you use one."
+          say "\n"
+        end
+
         if @components[:initializer]
           say "Step 2: Remove initializer", :yellow
           say "  Delete: config/initializers/rails_error_dashboard.rb"
@@ -58,33 +75,31 @@ module RailsErrorDashboard
         if @components[:route]
           say "Step 3: Remove route", :yellow
           say "  Open: config/routes.rb"
-          say "  Remove: mount RailsErrorDashboard::Engine => '/error_dashboard'"
+          say "  Remove the line: mount RailsErrorDashboard::Engine => ..."
           say "\n"
         end
 
         if @components[:migrations]
           say "Step 4: Remove migrations", :yellow
-          say "  Delete migration files from db/migrate/:"
           migration_files.each do |file|
-            say "    - #{File.basename(file)}", :white
+            say "    - #{file}", :white
           end
           say "\n"
         end
 
-        if @components[:tables]
-          say "Step 5: Drop database tables (⚠️  DESTRUCTIVE - will delete all error data)", :yellow
-          say "  Run: rails rails_error_dashboard:db:drop"
-          say "  Or manually in rails console:"
-          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_error_logs')", :white
-          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_error_occurrences')", :white
-          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_cascade_patterns')", :white
-          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_error_baselines')", :white
-          say "    ActiveRecord::Base.connection.execute('DROP TABLE rails_error_dashboard_error_comments')", :white
-          say "    ActiveRecord::Migration.drop_table(:rails_error_dashboard_error_logs) rescue nil", :white
-          say "\n"
-        end
+        say "Step 5: Separate database only: remove its entry from config/database.yml", :yellow
+        say "\n"
+
+        say "Step 6: Regenerate the schema file", :yellow
+        say "  Run: bin/rails db:schema:dump (otherwise db:schema:load recreates the tables)"
+        say "\n"
 
-        say "Step 6: Clean up environment variables (optional)", :yellow
+        say "Step 7: Remove from Gemfile", :yellow
+        say "  Remove: gem 'rails_error_dashboard'"
+        say "  Run: bundle install"
+        say "\n"
+
+        say "Step 8: Clean up environment variables (optional)", :yellow
         say "  Remove from .env or environment:"
         say "    - ERROR_DASHBOARD_USER"
         say "    - ERROR_DASHBOARD_PASSWORD"
@@ -96,8 +111,7 @@ module RailsErrorDashboard
         say "    - DASHBOARD_BASE_URL"
         say "\n"
 
-        say "Step 7: Restart your application", :yellow
-        say "  Run: rails restart (or restart your server)"
+        say "Step 9: Restart your application", :yellow
         say "\n"
 
         say "=" * 80
@@ -165,6 +179,20 @@ module RailsErrorDashboard
         say "\n"
       end
 
+      # Before any file is removed: if the drop fails, the app still boots with
+      # its initializer and can reach the error database to try again.
+      def drop_database_tables
+        return if options[:manual_only]
+        return if options[:keep_data]
+        return unless @components[:tables]
+
+        say "  Dropping database tables...", :yellow
+        dropped = RailsErrorDashboard::Commands::DropAllTables.call(connection: drop_connection)
+        say "  ✓ Dropped #{dropped.size} database table(s)", :green
+      rescue => e
+        raise Thor::Error, "Could not drop RED's tables, so no files were removed: #{e.message}"
+      end
+
       def remove_initializer
         return if options[:manual_only]
         return unless @components[:initializer]
@@ -182,7 +210,7 @@ module RailsErrorDashboard
           say "  ✓ Removed route", :green
         rescue => e
           say "  ⚠️  Could not automatically remove route: #{e.message}", :yellow
-          say "  Please manually remove: mount RailsErrorDashboard::Engine => '/error_dashboard'", :yellow
+          say "  Please remove the mount RailsErrorDashboard::Engine line from config/routes.rb", :yellow
         end
       end
 
@@ -196,35 +224,6 @@ module RailsErrorDashboard
         say "  ✓ Removed #{migration_count} migration file(s)", :green
       end
 
-      def drop_database_tables
-        return if options[:manual_only]
-        return if options[:keep_data]
-        return unless @components[:tables]
-
-        say "  Dropping database tables...", :yellow
-
-        # Drop tables in reverse order (to respect foreign keys)
-        tables_to_drop = [
-          "rails_error_dashboard_error_comments",
-          "rails_error_dashboard_error_occurrences",
-          "rails_error_dashboard_cascade_patterns",
-          "rails_error_dashboard_error_baselines",
-          "rails_error_dashboard_error_logs"
-        ]
-
-        dropped_count = 0
-        tables_to_drop.each do |table|
-          if ActiveRecord::Base.connection.table_exists?(table)
-            ActiveRecord::Base.connection.drop_table(table, if_exists: true)
-            dropped_count += 1
-          end
-        rescue => e
-          say "  ⚠️  Could not drop table #{table}: #{e.message}", :yellow
-        end
-
-        say "  ✓ Dropped #{dropped_count} database table(s)", :green
-      end
-
       def show_completion_message
         return if options[:manual_only]
 
@@ -282,7 +281,7 @@ module RailsErrorDashboard
       end
 
       def migration_files
-        Dir.glob("db/migrate/*rails_error_dashboard*.rb")
+        Dir.glob(MIGRATION_GLOBS)
       end
 
       def migration_count
@@ -290,22 +289,27 @@ module RailsErrorDashboard
       end
 
       def tables_exist?
-        return false unless defined?(ActiveRecord::Base)
-        table_names.any? { |table| ActiveRecord::Base.connection.table_exists?(table) rescue false }
+        table_names.any?
       end
 
+      # The tables Queries::UninstallPlan finds on the error database, in drop
+      # order. Empty (with the reason shown) when that database can't be reached.
       def table_names
-        [
-          "rails_error_dashboard_error_logs",
-          "rails_error_dashboard_error_occurrences",
-          "rails_error_dashboard_cascade_patterns",
-          "rails_error_dashboard_error_baselines",
-          "rails_error_dashboard_error_comments"
-        ]
+        @table_names ||= begin
+          RailsErrorDashboard::Queries::UninstallPlan.call(drop_connection).map { |entry| entry[:table] }
+        rescue => e
+          @database_error = e.message
+          say "  ⚠️  Could not inspect the error database: #{e.message}", :yellow
+          []
+        end
+      end
+
+      def drop_connection
+        RailsErrorDashboard::Commands::DropAllTables.connection
       end
 
       def table_count
-        table_names.count { |table| ActiveRecord::Base.connection.table_exists?(table) rescue false }
+        table_names.count
       end
 
       def gemfile_includes_gem?