rails_error_dashboard 0.14.2 → 0.14.4

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
@@ -181,7 +186,8 @@ RailsErrorDashboard.configure do |config|
 <% if @enable_error_sampling -%>
   # Error Sampling - ENABLED
   # Samples non-critical errors to reduce storage volume.
-  # Critical and high severity errors are ALWAYS logged at 100% regardless of this setting.
+  # Critical errors are always logged, regardless of this setting. So is the first
+  # occurrence of each error in each process.
   # 0.5 = log 50% of non-critical occurrences — halves storage while keeping
   # occurrence counts meaningful and error patterns visible.
   # Tune lower (e.g. 0.1) if one error is flooding the DB; set to 1.0 to log everything.
@@ -239,7 +245,7 @@ RailsErrorDashboard.configure do |config|
   # Automatically detect when error rates exceed normal patterns
   config.enable_baseline_alerts = true
   config.baseline_alert_threshold_std_devs = 2.0  # Alert when > 2 std devs above baseline
-  config.baseline_alert_severities = [ :critical, :high ]
+  config.baseline_alert_severities = [ :critical, :high ]  # Only errors of these severities alert
   config.baseline_alert_cooldown_minutes = 120  # 2 hours between alerts
   # To disable: Set config.enable_baseline_alerts = false
 
@@ -248,7 +254,7 @@ RailsErrorDashboard.configure do |config|
   # To enable: Set config.enable_baseline_alerts = true
   config.enable_baseline_alerts = false
   # config.baseline_alert_threshold_std_devs = 2.0
-  # config.baseline_alert_severities = [ :critical, :high ]
+  # config.baseline_alert_severities = [ :critical, :high ]  # Only errors of these severities alert
   # config.baseline_alert_cooldown_minutes = 120
 
 <% end -%>
@@ -446,7 +452,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 7: Remove from Gemfile", :yellow
+        say "  Remove: gem 'rails_error_dashboard'"
+        say "  Run: bundle install"
+        say "\n"
 
-        say "Step 6: Clean up environment variables (optional)", :yellow
+        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]
 
@@ -237,13 +236,22 @@ module RailsErrorDashboard
         say "Remaining manual steps:", :cyan
         say "\n"
 
-        say "1. Remove from Gemfile:", :yellow
+        unless options[:keep_data]
+          say "1. Regenerate the schema file:", :yellow
+          say "   Run: bin/rails db:schema:dump (otherwise db:schema:load recreates the tables)"
+          say "\n"
+
+          say "2. Separate database only: remove its entry from config/database.yml", :yellow
+          say "\n"
+        end
+
+        say "#{options[:keep_data] ? 1 : 3}. Remove from Gemfile:", :yellow
         say "   Open: Gemfile"
         say "   Remove: gem 'rails_error_dashboard'"
         say "   Run: bundle install"
         say "\n"
 
-        say "2. Restart your application:", :yellow
+        say "#{options[:keep_data] ? 2 : 4}. Restart your application:", :yellow
         say "   Run: rails restart"
         say "   Or: kill and restart your server process"
         say "\n"
@@ -282,7 +290,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 +298,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/commands/log_error.rb

@@ -878,8 +878,11 @@ module RailsErrorDashboard
         # Return if no anomaly detected
         return unless anomaly[:anomaly]
 
-        # Check if severity level should trigger alert
-        return unless config.baseline_alert_severities.include?(anomaly[:level])
+        # baseline_alert_severities lists ERROR severities (critical/high/
+        # medium/low, as validated), not anomaly levels. Comparing it with
+        # anomaly[:level] (elevated/high/critical) skipped every anomaly below
+        # threshold + 1 sigma, and :medium/:low never matched at all.
+        return unless config.baseline_alert_severities.include?(error_log.severity)
 
         # Enqueue alert job (which will handle throttling)
         BaselineAlertJob.perform_later(error_log.id, anomaly, ApplicationJob.enqueue_locale)

data/lib/rails_error_dashboard/configuration.rb

@@ -8,6 +8,14 @@ module RailsErrorDashboard
     DEFAULT_DASHBOARD_USERNAME = "gandalf"
     DEFAULT_DASHBOARD_PASSWORD = "youshallnotpass"
 
+    # Settings that hold credentials. #inspect masks them, so printing the
+    # configuration in a console (IRB shows results with pp, which uses
+    # #inspect) or pasting it into an issue doesn't leak them.
+    SECRET_ATTRIBUTES = %i[
+      dashboard_password slack_webhook_url discord_webhook_url pagerduty_integration_key
+      webhook_urls issue_tracker_token issue_webhook_secret llm_api_key
+    ].freeze
+
     # Dashboard authentication (always required)
     attr_accessor :dashboard_username
     attr_accessor :dashboard_password
@@ -351,7 +359,7 @@ module RailsErrorDashboard
 
       # Rate limiting defaults
       @enable_rate_limiting = false # OFF by default (opt-in)
-      @rate_limit_per_minute = 100  # Requests per minute per IP for API endpoints
+      @rate_limit_per_minute = 300  # Requests per minute per IP, per dashboard path
 
       # Enhanced metrics defaults
       @app_version = ENV["APP_VERSION"]
@@ -380,7 +388,7 @@ module RailsErrorDashboard
       # Baseline alert defaults
       @enable_baseline_alerts = false  # OFF by default (opt-in)
       @baseline_alert_threshold_std_devs = ENV.fetch("BASELINE_ALERT_THRESHOLD", "2.0").to_f
-      @baseline_alert_severities = [ :critical, :high ] # Alert on critical and high severity anomalies
+      @baseline_alert_severities = [ :critical, :high ] # Alert only for errors of these severities
       @baseline_alert_cooldown_minutes = ENV.fetch("BASELINE_ALERT_COOLDOWN", "120").to_i
 
       # Source code integration defaults - OFF by default (opt-in)
@@ -495,7 +503,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
@@ -522,6 +530,30 @@ module RailsErrorDashboard
       initialize
     end
 
+    # Whether config/database.yml has the entry config.database names for this
+    # environment. Without it the engine skips connects_to and RED uses the
+    # main database, where its tables usually don't exist, so nothing is
+    # recorded. The engine and error_dashboard:verify both ask this.
+    #
+    # @param env_name [String] the Rails environment
+    # @return [Boolean]
+    def separate_database_entry?(env_name = Rails.env)
+      name = (database || :error_dashboard).to_s
+      ActiveRecord::Base.configurations.configs_for(env_name: env_name.to_s).any? { |config| config.name == name }
+    end
+
+    # Like Object#inspect, with every credential in SECRET_ATTRIBUTES replaced
+    # by [FILTERED] when set. Unset ones still show nil or [], which is useful
+    # when checking why a channel stays off.
+    def inspect
+      attributes = instance_variables.map do |ivar|
+        value = instance_variable_get(ivar)
+        secret = SECRET_ATTRIBUTES.include?(ivar.to_s.delete_prefix("@").to_sym) && value.present?
+        "#{ivar}=#{secret ? '[FILTERED]' : value.inspect}"
+      end
+      "#<#{self.class.name} #{attributes.join(', ')}>"
+    end
+
     # Validate configuration values
     # Raises ConfigurationError if any validation fails
     # Logs warnings for non-fatal issues (e.g., Ruby version incompatibilities)
@@ -554,6 +586,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 +826,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 +1038,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/engine.rb

@@ -11,10 +11,11 @@ module RailsErrorDashboard
 
           # Guard: skip connects_to if the database config doesn't exist yet in database.yml.
           # This happens during `rails generate` when the initializer was just created but
-          # the user hasn't added the database.yml entry yet.
-          db_configs = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env)
-          unless db_configs.any? { |c| c.name == database_name.to_s }
-            Rails.logger.warn "[Rails Error Dashboard] Separate database '#{database_name}' is not configured in database.yml for the '#{Rails.env}' environment. Skipping connects_to. See https://github.com/AnjanJ/rails_error_dashboard/blob/main/docs/guides/DATABASE_OPTIONS.md"
+          # the user hasn't added the database.yml entry yet. Logged at error level:
+          # RED then uses the main database, and unless that has RED's tables no
+          # error is recorded. error_dashboard:verify reports it as FAILED.
+          unless RailsErrorDashboard.configuration.separate_database_entry?
+            Rails.logger.error "[Rails Error Dashboard] Separate database '#{database_name}' is not configured in database.yml for the '#{Rails.env}' environment. Skipping connects_to: errors are not recorded until it is added. See https://github.com/AnjanJ/rails_error_dashboard/blob/main/docs/guides/DATABASE_OPTIONS.md"
             next
           end
 
@@ -76,6 +77,11 @@ module RailsErrorDashboard
       # configured: then it is never consulted.
       RailsErrorDashboard.detected_git_sha if RailsErrorDashboard.configuration.git_sha.blank?
 
+      # One error-level line if Solid Queue runs RED's jobs with a
+      # config/queue.yml that never would (no dispatcher, no worker for RED's
+      # queues). Reads the file once; never raises. The dashboard shows a banner.
+      RailsErrorDashboard::Services::SolidQueueConfigCheck.log_current_problems
+
       if RailsErrorDashboard.configuration.enable_error_subscriber
         Rails.error.subscribe(RailsErrorDashboard::ErrorReporter.new)
       end