rails_error_dashboard 0.14.1 → 0.14.3

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

@@ -2,6 +2,12 @@
 
 module RailsErrorDashboard
   class Configuration
+    # The built-in Basic auth credentials. They are published (README, demo,
+    # gemspec), so outside development and test they are refused unless
+    # ERROR_DASHBOARD_PASSWORD explicitly supplies the password.
+    DEFAULT_DASHBOARD_USERNAME = "gandalf"
+    DEFAULT_DASHBOARD_PASSWORD = "youshallnotpass"
+
     # Dashboard authentication (always required)
     attr_accessor :dashboard_username
     attr_accessor :dashboard_password
@@ -269,8 +275,8 @@ module RailsErrorDashboard
 
     def initialize
       # Default values - Authentication is ALWAYS required
-      @dashboard_username = ENV.fetch("ERROR_DASHBOARD_USER", "gandalf")
-      @dashboard_password = ENV.fetch("ERROR_DASHBOARD_PASSWORD", "youshallnotpass")
+      @dashboard_username = ENV.fetch("ERROR_DASHBOARD_USER", DEFAULT_DASHBOARD_USERNAME)
+      @dashboard_password = ENV.fetch("ERROR_DASHBOARD_PASSWORD", DEFAULT_DASHBOARD_PASSWORD)
       @authenticate_with = nil
 
       @user_model = nil  # Auto-detect if not set
@@ -489,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
@@ -536,12 +542,24 @@ module RailsErrorDashboard
       # (GHSA-qhgm-3pxf-mvc6). Every future environment name a team invents is
       # now refused by default and has to be added here on purpose.
       #
-      # Skip during asset precompilation (SECRET_KEY_BASE_DUMMY=1) — ENV vars aren't available at build time
-      if default_credentials? &&
-         defined?(Rails) && Rails.respond_to?(:env) &&
-         !Rails.env.development? && !Rails.env.test? &&
-         ENV["SECRET_KEY_BASE_DUMMY"].blank?
-        errors << "Default or blank credentials cannot be used in #{Rails.env}. Only development and test may run on the built-in credentials. Set ERROR_DASHBOARD_USER and ERROR_DASHBOARD_PASSWORD environment variables, or use authenticate_with for custom auth."
+      # Skip during asset precompilation (SECRET_KEY_BASE_DUMMY=1) — ENV vars aren't available at build time.
+      # The login refuses the same credentials on its own, so SECRET_KEY_BASE_DUMMY
+      # left set at runtime does not reopen them.
+      if refuse_default_credentials? && ENV["SECRET_KEY_BASE_DUMMY"].blank?
+        reason = if credentials_problem == :blank
+          "the dashboard username or password is blank"
+        else
+          "the dashboard password is the published default and was not set by ERROR_DASHBOARD_PASSWORD"
+        end
+        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)
@@ -776,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
@@ -925,23 +945,86 @@ module RailsErrorDashboard
       list.empty? ? nil : list
     end
 
-    # Check if using default or blank demo credentials with basic auth
+    # Why the Basic auth credentials cannot be trusted outside development and
+    # test, or nil when they can.
     #
-    # Returns false if the user explicitly set ENV vars (even to the same default values),
-    # because that's a deliberate choice. Only blocks when credentials are untouched defaults
-    # or blank.
+    # - :blank - the username or password is empty or whitespace. An explicitly
+    #   empty variable is not a choice: a compose file passing an unset variable
+    #   through produces exactly that, and "" would match an empty login.
+    # - :published_password - the password is the published default and did not
+    #   come from ERROR_DASHBOARD_PASSWORD. Setting that variable, even to the
+    #   default, is a deliberate choice (the live demo runs that way). It has to
+    #   be THAT variable: setting only ERROR_DASHBOARD_USER used to leave the
+    #   password on the published default, and an initializer can hardcode it.
     #
-    # @return [Boolean] true if basic auth is active with untouched default or blank credentials
+    # Both compare values the way the login does, with to_s: a Symbol holding the
+    # published password logs in just the same.
+    #
+    # @return [Symbol, nil]
+    def credentials_problem
+      return :blank if self.class.blank_credential?(dashboard_username) ||
+                       self.class.blank_credential?(dashboard_password)
+
+      if dashboard_password.to_s == DEFAULT_DASHBOARD_PASSWORD &&
+         ENV["ERROR_DASHBOARD_PASSWORD"] != DEFAULT_DASHBOARD_PASSWORD
+        return :published_password
+      end
+
+      nil
+    end
+
+    # True for a credential that cannot be a secret: nil, empty, or only
+    # whitespace, including Unicode whitespace such as a no-break space, which
+    # String#strip leaves in place. The boot check and the login both use it.
+    #
+    # @return [Boolean]
+    def self.blank_credential?(value)
+      value.to_s.blank?
+    end
+
+    # Check if basic auth is active with blank credentials or the published
+    # default password (see #credentials_problem)
+    #
+    # Basic auth is active whenever authenticate_with is falsy, not only nil:
+    # the login falls back to it for `false` too, which is what
+    # `Rails.env.production? && -> { ... }` evaluates to in staging.
+    #
+    # @return [Boolean]
     def default_credentials?
-      return false unless authenticate_with.nil?
+      !authenticate_with && !credentials_problem.nil?
+    end
 
-      # If user explicitly set ENV vars, respect their choice
-      return false if ENV.key?("ERROR_DASHBOARD_USER") || ENV.key?("ERROR_DASHBOARD_PASSWORD")
+    # True where default_credentials? has to stop the dashboard: anywhere that is
+    # not local development or test. The boot check and the login both use it,
+    # so the login still refuses when the boot check was skipped.
+    #
+    # @return [Boolean]
+    def refuse_default_credentials?
+      return false unless default_credentials?
+      return false unless defined?(Rails) && Rails.respond_to?(:env)
 
-      default = dashboard_username == "gandalf" && dashboard_password == "youshallnotpass"
-      blank = dashboard_username.to_s.strip.empty? || dashboard_password.to_s.strip.empty?
+      !Rails.env.development? && !Rails.env.test?
+    end
 
-      default || blank
+    # 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).

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.1"
+  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

@@ -171,19 +171,53 @@ namespace :error_dashboard do
     if config.authenticate_with
       puts "OK (custom authentication)"
       checks_passed += 1
-    elsif config.dashboard_username == "gandalf" && config.dashboard_password == "youshallnotpass"
-      if Rails.env.production?
-        puts "WARNING - using default credentials in production!"
+    elsif (problem = config.credentials_problem)
+      # Same rule and environment allowlist as the boot check in validate!
+      label = problem == :blank ? "blank credentials" : "default credentials"
+      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 (default credentials - 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
+      puts "OK (the published default password, set explicitly by ERROR_DASHBOARD_PASSWORD)"
+      warnings += 1
     else
       puts "OK (custom credentials)"
       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"
@@ -448,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"
@@ -458,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)