rails_error_dashboard 0.14.2 → 0.14.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93c0e9e0f21298eb85db1d661793709d60158c5f2c6f85b164da36b4593525ee
-  data.tar.gz: 37bae1ddaca2d502e434e0b4e6e95f6c755619598dec20f08495ce13fd0c286a
+  metadata.gz: f96e195659bca5562fcf7c4ed02c1f8f69c058daec06f6902523958f5746a8a4
+  data.tar.gz: 2ea940fe412652bef9e0f47eb818d4da93a6d7b7cb1e32cd5820e96cf032fafe
 SHA512:
-  metadata.gz: 9c6be20b1be293c069516ed0f5f6fc19e46203224bb9aaad6be1c645f45ebb3455e03e6b3fef8d8738e4cc658dc928cd56c9f2d403d270ec6caaaa74411074b7
-  data.tar.gz: 7c1c344be4398b47faf98de6a9be675f41a86878b49404d76b73d1a5be91f046ded677c70ebb9c1f4118e8736873ea491edcfed07b6520465049b9ecb3e1066b
+  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/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/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?

data/lib/rails_error_dashboard/commands/drop_all_tables.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Commands
+    # Drops every RED table, for uninstalling. DESTRUCTIVE: all error data goes.
+    #
+    # Used by the rails_error_dashboard:db:drop task and the uninstall
+    # generator. Drops on the connection RED's models use, so a separate or
+    # shared error database is covered, in the order Queries::UninstallPlan
+    # derives from the foreign keys. Where the adapter runs DDL in a transaction
+    # (PostgreSQL, SQLite) it is all-or-nothing. Errors are raised, never
+    # swallowed: a half-finished uninstall must not report success.
+    #
+    # @example
+    #   RailsErrorDashboard::Commands::DropAllTables.call
+    #   # => ["rails_error_dashboard_error_comments", ...]
+    class DropAllTables
+      class Error < StandardError; end
+
+      # The connection RED's models use.
+      #
+      # @raise [Error] when use_separate_database is on but the engine fell back
+      #   to the primary database because database.yml has no entry for it:
+      #   dropping there would leave the real error database untouched.
+      # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter]
+      def self.connection
+        config = RailsErrorDashboard.configuration
+        record = RailsErrorDashboard::ErrorLogsRecord
+
+        if config.use_separate_database
+          expected = config.database.to_s
+          actual = record.connection_db_config&.name.to_s
+          if actual != expected
+            raise Error, "use_separate_database is on, but RED is connected to the '#{actual}' database, " \
+                         "not '#{expected}': database.yml has no '#{expected}' entry for #{Rails.env}. " \
+                         "Add it (see docs/guides/DATABASE_OPTIONS.md) and run this again, or RED's tables " \
+                         "in the error database would be left behind."
+          end
+        end
+
+        record.connection
+      end
+
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter]
+      # @return [Array<String>] the dropped tables, in drop order
+      # @raise [Error] when a host table has a foreign key into a RED table
+      def self.call(connection: self.connection)
+        tables = Queries::UninstallPlan.call(connection).map { |entry| entry[:table] }
+        return [] if tables.empty?
+
+        blocking = host_foreign_keys(connection, tables)
+        if blocking.any?
+          raise Error, "Not dropping anything: these tables have foreign keys into RED's tables. " \
+                       "Remove the foreign keys first: #{blocking.join('; ')}"
+        end
+
+        drop = -> { tables.each { |table| connection.drop_table(table, if_exists: true) } }
+        if connection.supports_ddl_transactions?
+          connection.transaction(requires_new: true) { drop.call }
+        else
+          drop.call
+        end
+
+        tables
+      end
+
+      def self.host_foreign_keys(connection, tables)
+        (connection.tables - tables).flat_map do |table|
+          connection.foreign_keys(table)
+            .select { |fk| tables.include?(fk.to_table) }
+            .map { |fk| "#{table}.#{fk.column} -> #{fk.to_table} (#{fk.name})" }
+        end
+      end
+      private_class_method :host_foreign_keys
+    end
+  end
+end

data/lib/rails_error_dashboard/configuration.rb

@@ -495,7 +495,7 @@ module RailsErrorDashboard
 
       # 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
+      @log_level = :silent  # Silent by default; see Logger::LOG_LEVELS for the levels
 
       # Dashboard UI
       @accent_color = :crimson  # :crimson, :ruby, :ember, :violet
@@ -554,6 +554,14 @@ module RailsErrorDashboard
         errors << "Default or blank credentials cannot be used in #{Rails.env}: #{reason}. Only development and test may run on the built-in credentials. Set ERROR_DASHBOARD_USER and ERROR_DASHBOARD_PASSWORD environment variables and make sure the initializer does not overwrite them, or use authenticate_with for custom auth."
       end
 
+      # In development the app boots on a blank credential, and the login then
+      # denies everyone: say so, or the developer is locked out with no clue
+      # why. Development only, because a test run boots on every CI job.
+      if default_credentials? && credentials_problem == :blank &&
+         defined?(Rails) && Rails.respond_to?(:env) && Rails.env.development?
+        warnings.concat(blank_credential_warnings)
+      end
+
       # Validate sampling_rate (must be between 0.0 and 1.0)
       if sampling_rate && (sampling_rate < 0.0 || sampling_rate > 1.0)
         errors << "sampling_rate must be between 0.0 and 1.0 (got: #{sampling_rate})"
@@ -786,7 +794,9 @@ module RailsErrorDashboard
 
       # Validate log level (must be valid symbol)
       if log_level
-        valid_log_levels = %i[debug info warn error fatal silent]
+        # Referenced here, not as a class-body constant: this file loads before
+        # logger.rb, and a bare Logger in the class body would be ::Logger.
+        valid_log_levels = RailsErrorDashboard::Logger::LOG_LEVELS.keys
         unless valid_log_levels.include?(log_level)
           errors << "log_level must be one of #{valid_log_levels.inspect} (got: #{log_level.inspect})"
         end
@@ -996,6 +1006,27 @@ module RailsErrorDashboard
       !Rails.env.development? && !Rails.env.test?
     end
 
+    # One warning per blank credential, naming where the blank came from: an
+    # environment variable that is set but empty, or the initializer.
+    #
+    # @return [Array<String>]
+    private def blank_credential_warnings
+      {
+        "ERROR_DASHBOARD_USER" => [ :dashboard_username, dashboard_username ],
+        "ERROR_DASHBOARD_PASSWORD" => [ :dashboard_password, dashboard_password ]
+      }.filter_map do |variable, (setting, value)|
+        next unless self.class.blank_credential?(value)
+
+        if ENV.key?(variable) && ENV[variable].to_s == value.to_s
+          "#{variable} is set but empty, so every dashboard login will be denied. " \
+            "Unset it to use the development default, or give it a value."
+        else
+          "config.#{setting} is blank, so every dashboard login will be denied. " \
+            "Remove that line from the initializer to use the development default, or give it a value."
+        end
+      end
+    end
+
     # Resolve the effective issue tracker provider (auto-detect from git_repository_url).
     # Linear is never auto-detected (it is not a git forge) — set issue_tracker_provider
     # explicitly.

data/lib/rails_error_dashboard/logger.rb

@@ -18,12 +18,17 @@ module RailsErrorDashboard
   #     config.log_level = :error
   #   end
   module Logger
+    # The levels Configuration#validate! accepts: it reads this hash, so the two
+    # can't drift apart again (validate! once accepted :fatal while this hash
+    # lacked it, and every log call raised). RED emits nothing at :fatal, so it
+    # logs nothing, as with Ruby's Logger.
     LOG_LEVELS = {
       debug: 0,
       info: 1,
       warn: 2,
       error: 3,
-      silent: 4
+      fatal: 4,
+      silent: 5
     }.freeze
 
     class << self
@@ -89,8 +94,11 @@ module RailsErrorDashboard
       # @param level [Symbol] The log level to check (:debug, :info, :warn, :error)
       # @return [Boolean]
       def log_level_enabled?(level)
-        config_level = RailsErrorDashboard.configuration.log_level || :silent
-        LOG_LEVELS[level] >= LOG_LEVELS[config_level]
+        config_level = RailsErrorDashboard.configuration.log_level.to_s.to_sym
+        LOG_LEVELS.fetch(level) >= LOG_LEVELS.fetch(config_level, LOG_LEVELS[:silent])
+      rescue StandardError
+        # The logger runs inside rescue blocks on the capture path; it must never raise.
+        false
       end
 
       # Format message with gem prefix

data/lib/rails_error_dashboard/queries/uninstall_plan.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Every RED table on a connection, in an order that can be dropped.
+    #
+    # The tables are discovered rather than listed by hand: a hand-kept list
+    # knew 5 of 13 tables, so uninstall left the rest behind (rack_attack_events
+    # among them, which holds IP addresses). The order comes from the real
+    # foreign keys: a table that references another is dropped first.
+    #
+    # Uses the raw connection only, never the models, so no model's schema
+    # cache ever records a table as dropped.
+    #
+    # @example
+    #   UninstallPlan.call(RailsErrorDashboard::ErrorLogsRecord.connection)
+    #   # => [{ table: "rails_error_dashboard_error_comments", rows: 12 }, ...]
+    class UninstallPlan
+      PREFIX = "rails_error_dashboard_"
+
+      class CycleError < StandardError; end
+
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter]
+      # @return [Array<Hash>] { table: String, rows: Integer or nil } in drop order
+      def self.call(connection)
+        tables = connection.tables.select { |table| table.start_with?(PREFIX) }
+        references = tables.to_h do |table|
+          [ table, connection.foreign_keys(table).map(&:to_table) & tables ]
+        end
+
+        order(references).map { |table| { table: table, rows: row_count(connection, table) } }
+      end
+
+      # @param references [Hash{String => Array<String>}] each table and the tables it references
+      # @return [Array<String>] every table, each before the tables it references
+      # @raise [CycleError] when the foreign keys form a cycle
+      def self.order(references)
+        remaining = references.keys.sort
+        ordered = []
+
+        until remaining.empty?
+          # Droppable once no other remaining table references it.
+          droppable = remaining.reject do |table|
+            remaining.any? { |other| other != table && references.fetch(other, []).include?(table) }
+          end
+          raise CycleError, "foreign-key cycle among: #{remaining.join(', ')}" if droppable.empty?
+
+          ordered.concat(droppable)
+          remaining -= droppable
+        end
+
+        ordered
+      end
+
+      def self.row_count(connection, table)
+        connection.select_value("SELECT COUNT(*) FROM #{connection.quote_table_name(table)}").to_i
+      rescue ActiveRecord::ActiveRecordError
+        nil
+      end
+      private_class_method :row_count
+    end
+  end
+end

data/lib/rails_error_dashboard/services/solid_queue_config_check.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module RailsErrorDashboard
+  module Services
+    # Pure algorithm: what in a Solid Queue config would stop jobs from running
+    #
+    # Mirrors Solid Queue 1.7.0's own rules, so it reports exactly what Solid
+    # Queue would do with the file:
+    # - SolidQueue::Configuration reads the section for the environment, or the
+    #   whole file when there is none, keeps workers/dispatchers/scheduler, and
+    #   only falls back to its defaults (a "*" worker and a dispatcher) when
+    #   none of the three is there. A section with workers and no dispatchers
+    #   therefore runs NO dispatcher: nothing scheduled ever becomes ready, so
+    #   no `retry_on wait:` or `perform_later(wait:)` runs, the host app's own
+    #   jobs included. That is what the retired rails_error_dashboard:solid_queue
+    #   generator wrote.
+    # - SolidQueue::QueueSelector treats a worker without queues as "*", "*" as
+    #   every queue, and a trailing "*" as a prefix.
+    #
+    # @example
+    #   path = SolidQueueConfigCheck.config_path(Rails.root)
+    #   SolidQueueConfigCheck.call(path, environments: %w[development production])
+    #   # => { problems: ["production: workers but no dispatcher ..."], skipped: nil }
+    class SolidQueueConfigCheck
+      DEFAULT_CONFIG_FILE = "config/queue.yml"
+      PROCESS_KEYS = %i[workers dispatchers scheduler].freeze
+      # Before 1.4.0, scheduler: was not a process key: a section with only a
+      # scheduler fell back to the defaults, a "*" worker and a dispatcher.
+      SCHEDULER_KEY_SINCE = Gem::Version.new("1.4.0")
+      GUIDE_URL = "https://anjanj.github.io/rails_error_dashboard/docs/guides/solid-queue-setup/#what-red-needs-from-solid-queue"
+
+      # The fix printed with a reported problem. It is never Solid Queue's
+      # installer: whoever sees this already uses Solid Queue, and its 1.7.0
+      # installer also rewrites production.rb to use a separate queue database.
+      FIX = [
+        "Fix: edit the file. Give each environment a dispatchers: block and a worker",
+        "for RED's queues (a \"*\" worker covers them). Guide: #{GUIDE_URL}"
+      ].freeze
+
+      # The config file Solid Queue reads, honouring SOLID_QUEUE_CONFIG as it does.
+      #
+      # @param root [Pathname, String] the application root
+      # @return [Pathname]
+      def self.config_path(root)
+        Pathname(root.to_s).join(ENV["SOLID_QUEUE_CONFIG"].presence || DEFAULT_CONFIG_FILE)
+      end
+
+      # The environments an app defines, from config/environments/*.rb.
+      #
+      # @param root [Pathname, String] the application root
+      # @return [Array<String>]
+      def self.app_environments(root)
+        Dir[Pathname(root.to_s).join("config", "environments", "*.rb").to_s]
+          .map { |file| File.basename(file, ".rb") }
+          .sort
+      end
+
+      # The queues RED's jobs are enqueued on, as this app names them
+      # (queue_name_prefix included).
+      #
+      # @return [Array<String>]
+      def self.red_queue_names
+        [ RailsErrorDashboard::AsyncErrorLoggingJob, RailsErrorDashboard::SlackErrorNotificationJob ]
+          .map { |job| job.queue_name.to_s }
+          .uniq
+      rescue => e
+        RailsErrorDashboard::Logger.debug("SolidQueueConfigCheck could not read queue names: #{e.class}: #{e.message}")
+        %w[default error_notifications]
+      end
+
+      # Read the file the way Solid Queue does (ERB, then YAML with aliases) and
+      # check each environment. Never raises: an unreadable file is reported as
+      # skipped.
+      #
+      # @param path [Pathname, String]
+      # @param environments [Array<String>]
+      # @param queue_names [Array<String>]
+      # @return [Hash] { problems: Array<String>, skipped: String or nil }
+      def self.call(path, environments:, queue_names: red_queue_names)
+        { problems: check(parse(path), environments: environments, queue_names: queue_names), skipped: nil }
+      rescue StandardError, ScriptError => e # ScriptError: ERB in the file that doesn't compile
+        { problems: [], skipped: "could not read #{path}: #{e.class}: #{e.message.lines.first.to_s.strip}" }
+      end
+
+      # @param path [Pathname, String]
+      # @return [Hash] the parsed file, symbolized keys, as Solid Queue reads it
+      def self.parse(path)
+        ActiveSupport::ConfigurationFile.parse(Pathname(path.to_s)).deep_symbolize_keys
+      end
+
+      # @param config [Hash] the parsed file, symbolized keys
+      # @param environments [Array<String>]
+      # @param queue_names [Array<String>]
+      # @return [Array<String>] one line per problem, prefixed with the environment
+      def self.check(config, environments:, queue_names:)
+        environments.flat_map do |env|
+          facts = processes_for(config, environment: env, queue_names: queue_names)
+          problems_in(facts, queue_names).map { |problem| "#{env}: #{problem}" }
+        end
+      end
+
+      # What Solid Queue would start for one environment. The contract spec
+      # compares this with the real SolidQueue::Configuration and QueueSelector.
+      #
+      # @param config [Hash] the parsed file, symbolized keys
+      # @param environment [String]
+      # @param queue_names [Array<String>]
+      # @param solid_queue_version [String, nil] the rules to follow; the loaded
+      #   Solid Queue's by default, the newest when none is loaded
+      # @return [Hash] { dispatchers: Integer, workers: Integer,
+      #   processed: Array<String> (the queue_names a worker picks up), error: String or nil }
+      def self.processes_for(config, environment:, queue_names:, solid_queue_version: loaded_solid_queue_version)
+        section = section_for(config, environment)
+        return cannot_start("the #{environment} section is not a set of settings") unless section.is_a?(Hash)
+
+        section = section.slice(*process_keys(solid_queue_version))
+        # Empty: Solid Queue runs its defaults, a "*" worker and a dispatcher.
+        return { dispatchers: 1, workers: 1, processed: queue_names.dup, error: nil } if section.empty?
+
+        error = shape_error(section)
+        return cannot_start(error) if error
+
+        # bin/jobs runs in fork mode: each worker entry starts `processes` of them.
+        workers = section.fetch(:workers, []).select { |worker| worker.fetch(:processes, 1).positive? }
+        {
+          dispatchers: section.fetch(:dispatchers, []).size,
+          workers: workers.sum { |worker| worker.fetch(:processes, 1) },
+          processed: queue_names.select { |name| workers.any? { |worker| processes?(worker, name) } },
+          error: nil
+        }
+      end
+
+      def self.loaded_solid_queue_version
+        ::SolidQueue::VERSION if defined?(::SolidQueue::VERSION)
+      end
+
+      def self.process_keys(solid_queue_version)
+        return PROCESS_KEYS if solid_queue_version.nil? || Gem::Version.new(solid_queue_version) >= SCHEDULER_KEY_SINCE
+
+        PROCESS_KEYS - [ :scheduler ]
+      rescue ArgumentError # a version string Gem::Version can't read
+        PROCESS_KEYS
+      end
+      private_class_method :process_keys
+
+      # SolidQueue::Configuration#config_from: the environment's section when
+      # present, else the whole file.
+      def self.section_for(config, env)
+        config[env.to_sym] ? config[env.to_sym] : config
+      end
+      private_class_method :section_for
+
+      # Settings Solid Queue raises on while it builds its processes, so
+      # bin/jobs can't start: a key present with no value, a map where a list
+      # belongs, a list entry that isn't a set of settings, or processes that
+      # isn't a whole number.
+      def self.shape_error(section)
+        %i[workers dispatchers].each do |key|
+          next unless section.key?(key)
+
+          list = section[key]
+          return "#{key}: must be a list, each entry starting with \"- \"" unless list.is_a?(Array)
+          return "every entry under #{key}: must be a set of settings" unless list.all?(Hash)
+        end
+
+        if section.fetch(:workers, []).any? { |worker| worker.key?(:processes) && !worker[:processes].is_a?(Integer) }
+          return "a worker's processes: must be a whole number"
+        end
+
+        nil
+      end
+      private_class_method :shape_error
+
+      def self.cannot_start(reason)
+        { dispatchers: 0, workers: 0, processed: [], error: reason }
+      end
+      private_class_method :cannot_start
+
+      def self.problems_in(facts, queue_names)
+        return [ "Solid Queue can't start with this config: #{facts[:error]}" ] if facts[:error]
+
+        dispatchers = facts[:dispatchers]
+        workers = facts[:workers]
+        return [ "no worker and no dispatcher, so no job ever runs" ] if workers.zero? && dispatchers.zero?
+        return [ "no worker process starts (no workers, or processes: 0), so no job is ever performed" ] if workers.zero?
+
+        problems = []
+        if dispatchers.zero?
+          problems << "workers but no dispatcher, so scheduled jobs and retries " \
+                      "(retry_on wait:, perform_later(wait:)) never run, the app's own jobs included"
+        end
+
+        uncovered = queue_names - facts[:processed]
+        problems << "no worker processes #{uncovered.join(' or ')}" if uncovered.any?
+        problems
+      end
+      private_class_method :problems_in
+
+      # SolidQueue::QueueSelector: no queues means "*"; "*" is every queue; a
+      # trailing "*" is a prefix.
+      def self.processes?(worker, queue_name)
+        queues = worker.is_a?(Hash) ? Array(worker[:queues]).map { |queue| queue.to_s.strip } : []
+        queues = [ "*" ] if queues.empty?
+
+        queues.any? do |queue|
+          queue == "*" || queue == queue_name || (queue.end_with?("*") && queue_name.start_with?(queue.delete_suffix("*")))
+        end
+      end
+      private_class_method :processes?
+    end
+  end
+end

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.14.2"
+  VERSION = "0.14.3"
 end

data/lib/rails_error_dashboard.rb

@@ -57,6 +57,7 @@ require "rails_error_dashboard/services/statistical_classifier"
 require "rails_error_dashboard/services/source_code_reader"
 require "rails_error_dashboard/services/git_blame_reader"
 require "rails_error_dashboard/services/git_head_reader"
+require "rails_error_dashboard/services/solid_queue_config_check"
 require "rails_error_dashboard/services/github_link_generator"
 require "rails_error_dashboard/services/cause_chain_extractor"
 require "rails_error_dashboard/services/environment_snapshot"
@@ -137,6 +138,8 @@ require "rails_error_dashboard/commands/flush_swallowed_exceptions"
 require "rails_error_dashboard/commands/flush_rack_attack_events"
 require "rails_error_dashboard/commands/scrub_invalid_encoding"
 require "rails_error_dashboard/commands/backfill_resolved_at"
+require "rails_error_dashboard/queries/uninstall_plan"
+require "rails_error_dashboard/commands/drop_all_tables"
 require "rails_error_dashboard/queries/errors_list"
 # Before the queries that use it: window volume is shared by dashboard and
 # analytics, and both would otherwise rescue a NameError into a silent zero.

data/lib/tasks/error_dashboard.rake

@@ -177,8 +177,12 @@ namespace :error_dashboard do
       if config.refuse_default_credentials?
         puts "WARNING - #{label} outside development and test!"
         checks_failed += 1
+      elsif problem == :blank
+        # The login denies everyone on a blank credential, in every environment.
+        puts "WARNING - #{label}: every login is denied"
+        warnings += 1
       else
-        puts "OK (#{label} - change before production)"
+        puts "OK (#{label} - set ERROR_DASHBOARD_USER and ERROR_DASHBOARD_PASSWORD before deploying)"
         warnings += 1
       end
     elsif config.dashboard_password == RailsErrorDashboard::Configuration::DEFAULT_DASHBOARD_PASSWORD
@@ -189,6 +193,31 @@ namespace :error_dashboard do
       checks_passed += 1
     end
 
+    # 9. Solid Queue config. A section with workers and no dispatchers runs no
+    # dispatcher, so no delayed job ever runs, the app's own included; the
+    # retired rails_error_dashboard:solid_queue generator wrote exactly that.
+    # Checked whenever Solid Queue is loaded, not only when it is the current
+    # adapter: Rails 8 sets it in production only, and verify usually runs locally.
+    queue_check = RailsErrorDashboard::Services::SolidQueueConfigCheck
+    queue_config = queue_check.config_path(Rails.root)
+    if defined?(SolidQueue) && queue_config.exist?
+      print "  Solid Queue config... "
+      environments = queue_check.app_environments(Rails.root).presence || [ Rails.env.to_s ]
+      result = queue_check.call(queue_config, environments: environments)
+      if result[:skipped]
+        puts "SKIPPED (#{result[:skipped]})"
+        warnings += 1
+      elsif result[:problems].any?
+        puts "FAILED"
+        result[:problems].each { |problem| puts "    - #{problem}" }
+        queue_check::FIX.each { |line| puts "    #{line}" }
+        checks_failed += 1
+      else
+        puts "OK"
+        checks_passed += 1
+      end
+    end
+
     # Summary
     puts "\n" + "-" * 70
     puts "  Results: #{checks_passed} passed, #{checks_failed} failed, #{warnings} warnings"
@@ -453,7 +482,7 @@ namespace :error_dashboard do
 
     # Confirm before proceeding
     print "\nProceed with deletion? (y/N): "
-    confirmation = $stdin.gets.chomp.downcase
+    confirmation = $stdin.gets.to_s.chomp.downcase
 
     unless confirmation == "y" || confirmation == "yes"
       puts "\n✗ Cleanup cancelled"
@@ -463,7 +492,9 @@ namespace :error_dashboard do
 
     puts "\nDeleting errors..."
     start_time = Time.current
-    deleted = scope.delete_all
+    # Dependents first, in batches: occurrences, comments and cascade patterns
+    # hold foreign keys to the log, so a plain delete_all failed on them.
+    deleted = RailsErrorDashboard::RetentionCleanupJob.delete_with_dependents(scope)
     # delete_all skips callbacks, and the stat cards are cached.
     RailsErrorDashboard::Services::AnalyticsCacheManager.clear
     elapsed = (Time.current - start_time).round(2)

data/lib/tasks/rails_error_dashboard_tasks.rake

@@ -16,75 +16,69 @@ namespace :rails_error_dashboard do
       puts "=" * 80
       puts "\n"
 
-      # List tables that will be dropped
-      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"
-      ]
+      # The connection RED's models use: the separate or shared error database
+      # when there is one. Raises if the engine fell back to the primary one.
+      connection = RailsErrorDashboard::Commands::DropAllTables.connection
+      database = connection.pool.db_config.name
+      plan = RailsErrorDashboard::Queries::UninstallPlan.call(connection)
 
-      existing_tables = tables_to_drop.select do |table|
-        ActiveRecord::Base.connection.table_exists?(table)
-      end
-
-      if existing_tables.empty?
-        puts "No Rails Error Dashboard tables found in the database."
+      if plan.empty?
+        puts "No Rails Error Dashboard tables found in the '#{database}' database."
         puts "\n"
-        exit 0
+        next
       end
 
-      puts "The following tables will be PERMANENTLY DELETED:"
-      existing_tables.each do |table|
-        record_count = ActiveRecord::Base.connection.execute("SELECT COUNT(*) FROM #{table}").first.values.first rescue 0
-        puts "  • #{table} (#{record_count} records)"
+      puts "The following tables in the '#{database}' database will be PERMANENTLY DELETED:"
+      plan.each do |entry|
+        puts "  • #{entry[:table]} (#{entry[:rows] || '?'} records)"
       end
       puts "\n"
+
+      if plan.any? { |entry| entry[:table] == "rails_error_dashboard_applications" }
+        names = connection.select_values("SELECT name FROM #{connection.quote_table_name('rails_error_dashboard_applications')} ORDER BY name")
+        if names.size > 1
+          puts "⚠️  This database holds errors for #{names.size} applications, and ALL of them will be deleted:"
+          names.each { |name| puts "  • #{name}" }
+          puts "\n"
+        end
+      end
+
       puts "⚠️  This action CANNOT be undone!"
       puts "\n"
 
-      # Ask for confirmation
       print "Type 'DELETE ALL DATA' to confirm: "
-      confirmation = $stdin.gets.chomp
+      confirmation = $stdin.gets.to_s.chomp
 
       if confirmation != "DELETE ALL DATA"
         puts "\n"
         puts "Cancelled. No tables were dropped."
         puts "\n"
-        exit 0
+        next
       end
 
       puts "\n"
       puts "Dropping tables..."
-
-      # Drop tables in reverse order (respects foreign keys)
-      dropped_count = 0
-      existing_tables.reverse.each do |table|
-        begin
-          ActiveRecord::Base.connection.drop_table(table, if_exists: true)
-          puts "  ✓ Dropped #{table}"
-          dropped_count += 1
-        rescue => e
-          puts "  ✗ Failed to drop #{table}: #{e.message}"
-        end
-      end
+      dropped = RailsErrorDashboard::Commands::DropAllTables.call(connection: connection)
+      dropped.each { |table| puts "  ✓ Dropped #{table}" }
 
       puts "\n"
       puts "=" * 80
-      puts "  ✅ Successfully dropped #{dropped_count} table(s)"
+      puts "  ✅ Successfully dropped #{dropped.size} table(s)"
       puts "=" * 80
       puts "\n"
       puts "Next steps:"
-      puts "  1. Remove gem 'rails_error_dashboard' from Gemfile"
-      puts "  2. Run: bundle install"
-      puts "  3. Remove initializer: config/initializers/rails_error_dashboard.rb"
-      puts "  4. Remove route from config/routes.rb"
-      puts "  5. Delete migration files: db/migrate/*rails_error_dashboard*.rb"
-      puts "  6. Restart your Rails server"
+      puts "  1. Remove the initializer: config/initializers/rails_error_dashboard.rb"
+      puts "  2. Remove the route from config/routes.rb (mount RailsErrorDashboard::Engine)"
+      puts "  3. Delete RED's migrations: db/migrate/*rails_error_dashboard*.rb"
+      puts "     (and db/error_dashboard_migrate/ with a separate database)"
+      puts "  4. Separate database: remove its entry from config/database.yml"
+      puts "  5. Regenerate the schema file: bin/rails db:schema:dump"
+      puts "     (otherwise db:schema:load recreates these tables)"
+      puts "  6. Remove gem 'rails_error_dashboard' from the Gemfile and run: bundle install"
+      puts "  7. Restart your Rails server"
       puts "\n"
-      puts "Or use the automated uninstaller:"
-      puts "  rails generate rails_error_dashboard:uninstall"
+      puts "Or use the automated uninstaller, before removing the gem:"
+      puts "  bin/rails generate rails_error_dashboard:uninstall"
       puts "\n"
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.14.2
+  version: 0.14.3
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -429,7 +429,6 @@ files:
 - lib/generators/rails_error_dashboard/install/templates/README
 - lib/generators/rails_error_dashboard/install/templates/initializer.rb
 - lib/generators/rails_error_dashboard/solid_queue/solid_queue_generator.rb
-- lib/generators/rails_error_dashboard/solid_queue/templates/queue.yml
 - lib/generators/rails_error_dashboard/uninstall/uninstall_generator.rb
 - lib/rails_error_dashboard.rb
 - lib/rails_error_dashboard/commands/add_error_comment.rb
@@ -442,6 +441,7 @@ files:
 - lib/rails_error_dashboard/commands/batch_unmute_errors.rb
 - lib/rails_error_dashboard/commands/calculate_cascade_probability.rb
 - lib/rails_error_dashboard/commands/create_issue.rb
+- lib/rails_error_dashboard/commands/drop_all_tables.rb
 - lib/rails_error_dashboard/commands/find_or_create_application.rb
 - lib/rails_error_dashboard/commands/find_or_increment_error.rb
 - lib/rails_error_dashboard/commands/flush_rack_attack_events.rb
@@ -508,6 +508,7 @@ files:
 - lib/rails_error_dashboard/queries/similar_errors.rb
 - lib/rails_error_dashboard/queries/storm_history.rb
 - lib/rails_error_dashboard/queries/swallowed_exception_summary.rb
+- lib/rails_error_dashboard/queries/uninstall_plan.rb
 - lib/rails_error_dashboard/queries/user_impact_summary.rb
 - lib/rails_error_dashboard/services/ai_agent_classifier.rb
 - lib/rails_error_dashboard/services/analytics_cache_manager.rb
@@ -563,6 +564,7 @@ files:
 - lib/rails_error_dashboard/services/severity_classifier.rb
 - lib/rails_error_dashboard/services/similarity_calculator.rb
 - lib/rails_error_dashboard/services/slack_payload_builder.rb
+- lib/rails_error_dashboard/services/solid_queue_config_check.rb
 - lib/rails_error_dashboard/services/source_code_reader.rb
 - lib/rails_error_dashboard/services/statistical_classifier.rb
 - lib/rails_error_dashboard/services/storm_protection/circuit_breaker.rb
@@ -599,7 +601,7 @@ metadata:
   funding_uri: https://github.com/sponsors/AnjanJ
 post_install_message: |
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    RED (Rails Error Dashboard) v0.14.2
+    RED (Rails Error Dashboard) v0.14.3
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   First install:

data/lib/generators/rails_error_dashboard/solid_queue/templates/queue.yml

@@ -1,55 +0,0 @@
-# Solid Queue configuration for RailsErrorDashboard
-#
-# This file configures workers for error logging and notifications.
-# Adjust threads and processes based on your application's needs.
-
-# Development environment - optimized for low resource usage
-development:
-  workers:
-    # Error notifications (Slack, Email, Discord, PagerDuty, Webhooks)
-    - queues: error_notifications
-      threads: 2
-      processes: 1
-      polling_interval: 1
-
-    # Default queue (includes async error logging)
-    - queues: default
-      threads: 3
-      processes: 1
-      polling_interval: 1
-
-# Test environment - minimal configuration
-test:
-  workers:
-    - queues: "*"
-      threads: 1
-      processes: 1
-      polling_interval: 0.1
-
-# Production environment - optimized for throughput
-production:
-  workers:
-    # Error notifications - lower concurrency (external API calls)
-    - queues: error_notifications
-      threads: 3
-      processes: 1
-      polling_interval: 0.5
-
-    # Default queue - higher concurrency (database operations)
-    - queues: default
-      threads: 5
-      processes: 2
-      polling_interval: 0.5
-
-# Staging environment - similar to production but scaled down
-staging:
-  workers:
-    - queues: error_notifications
-      threads: 2
-      processes: 1
-      polling_interval: 0.5
-
-    - queues: default
-      threads: 3
-      processes: 1
-      polling_interval: 0.5