rails_error_dashboard 0.14.2 → 0.14.4

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/middleware/rate_limiter.rb

@@ -2,12 +2,11 @@
 
 module RailsErrorDashboard
   module Middleware
-    # Rate limiting middleware for Rails Error Dashboard routes
-    # Protects both dashboard UI and API endpoints from abuse
+    # Rate limiting middleware for Rails Error Dashboard routes: at most
+    # config.rate_limit_per_minute requests per IP per path, per minute.
     class RateLimiter
-      # Rate limits by endpoint type (relative to engine mount path)
-      API_LIMIT = { limit: 100, period: 60 }.freeze   # 100 req/min
-      DASHBOARD_LIMIT = { limit: 300, period: 60 }.freeze # 300 req/min
+      PERIOD = 60 # seconds
+      DEFAULT_LIMIT = 300 # requests per PERIOD, when rate_limit_per_minute isn't a positive number
 
       def initialize(app)
         @app = app
@@ -22,16 +21,14 @@ module RailsErrorDashboard
         # Only apply rate limiting to error dashboard routes
         return @app.call(env) unless error_dashboard_route?(request.path)
 
-        # Find matching rate limit configuration
-        limit_config = find_limit_config(request.path)
-        return @app.call(env) unless limit_config
+        limit_config = { limit: configured_limit, period: PERIOD }
 
         # Check rate limit
-        key = rate_limit_key(request)
+        key = rate_limit_key(request, limit_config)
         current_count = @cache.read(key).to_i
 
         if current_count >= limit_config[:limit]
-          return rate_limit_response(request, limit_config)
+          return html_rate_limit_response(limit_config)
         end
 
         # Increment counter with expiration
@@ -46,6 +43,12 @@ module RailsErrorDashboard
         RailsErrorDashboard.configuration.enable_rate_limiting
       end
 
+      # nil passes validation, and a limit of 0 would refuse every request.
+      def configured_limit
+        limit = RailsErrorDashboard.configuration.rate_limit_per_minute.to_i
+        limit.positive? ? limit : DEFAULT_LIMIT
+      end
+
       def engine_mount_path
         @engine_mount_path ||= RailsErrorDashboard.configuration.engine_mount_path
       rescue
@@ -56,45 +59,14 @@ module RailsErrorDashboard
         path.start_with?(engine_mount_path)
       end
 
-      def find_limit_config(path)
-        if path.start_with?("#{engine_mount_path}/api")
-          API_LIMIT
-        else
-          DASHBOARD_LIMIT
-        end
-      end
-
-      def rate_limit_key(request)
-        # Key format: rate_limit:IP:path_prefix:time_window
+      def rate_limit_key(request, limit_config)
+        # Key format: rate_limit:IP:path:time_window
         # Time window ensures keys expire and reset
-        limit_config = find_limit_config(request.path)
         time_window = Time.now.to_i / limit_config[:period]
 
         "rate_limit:#{request.ip}:#{request.path}:#{time_window}"
       end
 
-      def rate_limit_response(request, limit_config)
-        # Return JSON for API requests, HTML for dashboard
-        if request.path.start_with?("#{engine_mount_path}/api")
-          json_rate_limit_response(limit_config)
-        else
-          html_rate_limit_response(limit_config)
-        end
-      end
-
-      def json_rate_limit_response(limit_config)
-        [
-          429,
-          {
-            "Content-Type" => "application/json",
-            "Retry-After" => limit_config[:period].to_s,
-            "X-RateLimit-Limit" => limit_config[:limit].to_s,
-            "X-RateLimit-Period" => "#{limit_config[:period]} seconds"
-          },
-          [ { error: "Rate limit exceeded. Please try again later." }.to_json ]
-        ]
-      end
-
       def html_rate_limit_response(limit_config)
         body = <<~HTML
           <!DOCTYPE html>

data/lib/rails_error_dashboard/plugin.rb

@@ -54,12 +54,42 @@ module RailsErrorDashboard
       # Override in subclass to handle event
     end
 
+    # Called when a resolved error occurs again and is reopened
+    # @param error_log [ErrorLog] The reopened error log
+    def on_error_reopened(error_log)
+      # Override in subclass to handle event
+    end
+
     # Called when an error is resolved
     # @param error_log [ErrorLog] The resolved error log
     def on_error_resolved(error_log)
       # Override in subclass to handle event
     end
 
+    # Called when an error is muted
+    # @param error_log [ErrorLog] The muted error log
+    def on_error_muted(error_log)
+      # Override in subclass to handle event
+    end
+
+    # Called when an error is unmuted
+    # @param error_log [ErrorLog] The unmuted error log
+    def on_error_unmuted(error_log)
+      # Override in subclass to handle event
+    end
+
+    # Called when errors are batch muted
+    # @param error_logs [Array<ErrorLog>] The muted error logs
+    def on_errors_batch_muted(error_logs)
+      # Override in subclass to handle event
+    end
+
+    # Called when errors are batch unmuted
+    # @param error_logs [Array<ErrorLog>] The unmuted error logs
+    def on_errors_batch_unmuted(error_logs)
+      # Override in subclass to handle event
+    end
+
     # Called when errors are batch resolved
     # @param error_logs [Array<ErrorLog>] The resolved error logs
     def on_errors_batch_resolved(error_logs)

data/lib/rails_error_dashboard/queries/errors_list.rb

@@ -150,8 +150,10 @@ module RailsErrorDashboard
         end
       end
 
+      # RED's own connection: with a separate error database, the main
+      # database can use a different adapter.
       def postgresql?
-        ActiveRecord::Base.connection.adapter_name.downcase == "postgresql"
+        ErrorLogsRecord.connection.adapter_name.downcase == "postgresql"
       end
 
       def filter_by_severity(query)

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/exception_filter.rb

@@ -28,7 +28,8 @@ module RailsErrorDashboard
       end
 
       # Check if exception is in the ignored exceptions list
-      # Supports both string class names and regex patterns
+      # Supports class-name strings and Class/Module objects (both match
+      # subclasses), and regex patterns (matched against the class name)
       # @param exception [Exception] The exception to check
       # @return [Boolean] true if the exception should be ignored
       def self.ignored?(exception)
@@ -41,6 +42,8 @@ module RailsErrorDashboard
           case ignored
           when String
             exception.is_a?(ignored.constantize)
+          when Module
+            exception.is_a?(ignored)
           when Regexp
             exception_class_name.match?(ignored)
           else

data/lib/rails_error_dashboard/services/solid_queue_config_check.rb

@@ -0,0 +1,261 @@
+# 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 running app's verdict: the problems that would stop RED's jobs in
+      # this environment, or [] when Solid Queue doesn't run them or there is
+      # no config file. Worked out once per process (it reads and parses a
+      # file); the dashboard banner and the boot log line both ask. Never raises.
+      #
+      # @return [Array<String>]
+      def self.current_problems
+        return @current_problems if defined?(@current_problems)
+
+        @current_problems = compute_current_problems.freeze
+      end
+
+      # One error-level line at boot when there is a problem.
+      #
+      # @param logger [Logger]
+      # @return [void]
+      def self.log_current_problems(logger = Rails.logger)
+        problems = current_problems
+        return if problems.empty?
+
+        logger.error(
+          "[Rails Error Dashboard] Solid Queue won't run RED's jobs in #{problems.join('; ')}. " \
+          "Errors captured in the background and notifications wait in the queue until " \
+          "config/queue.yml is fixed: bin/rails error_dashboard:verify shows how. Guide: #{GUIDE_URL}"
+        )
+      rescue StandardError
+        nil
+      end
+
+      # For specs.
+      def self.reset_current_problems!
+        remove_instance_variable(:@current_problems) if defined?(@current_problems)
+      end
+
+      def self.compute_current_problems
+        return [] unless RailsErrorDashboard::ApplicationJob.queue_adapter_name.to_s == "solid_queue"
+
+        path = config_path(Rails.root)
+        return [] unless path.exist?
+
+        result = call(path, environments: [ Rails.env.to_s ])
+        result[:skipped] ? [] : result[:problems]
+      rescue StandardError, ScriptError
+        []
+      end
+      private_class_method :compute_current_problems
+
+      # 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.4"
 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.