rails_error_dashboard 0.14.3 → 0.15.0

data/lib/rails_error_dashboard/plugin_registry.rb

@@ -3,6 +3,13 @@
 module RailsErrorDashboard
   # Registry for managing plugins
   # Provides plugin registration and event dispatching
+  #
+  # A plugin is host code running inside RED's own paths, so nothing it does
+  # may break them: a `name` that raises (the base class raises
+  # NotImplementedError, a ScriptError that `rescue => e` does not catch), an
+  # `on_register` that raises, or an `enabled?` that raises is logged and
+  # treated as "no", never propagated. A plugin is in the list only once
+  # registration has fully succeeded.
   class PluginRegistry
     class << self
       # Get all registered plugins
@@ -12,26 +19,41 @@ module RailsErrorDashboard
 
       # Register a plugin
       # @param plugin [Plugin] The plugin instance to register
+      # @return [Boolean] true when registered, false when skipped
+      # @raise [ArgumentError] not a Plugin, or no usable name
       def register(plugin)
         unless plugin.is_a?(Plugin)
           raise ArgumentError, "Plugin must be an instance of RailsErrorDashboard::Plugin"
         end
 
-        if plugins.any? { |p| p.name == plugin.name }
-          RailsErrorDashboard::Logger.warn("Plugin '#{plugin.name}' is already registered, skipping")
+        name = name_of(plugin)
+        if name.blank?
+          raise ArgumentError, "Plugin #{plugin.class} must implement #name and return a non-blank String"
+        end
+
+        if plugins.any? { |p| name_of(p) == name }
+          RailsErrorDashboard::Logger.warn("Plugin '#{name}' is already registered, skipping")
+          return false
+        end
+
+        begin
+          plugin.on_register
+        rescue => e
+          RailsErrorDashboard::Logger.error(
+            "[RailsErrorDashboard] Plugin '#{name}' failed in on_register: #{e.class} - #{e.message}; not registered"
+          )
           return false
         end
 
         plugins << plugin
-        plugin.on_register
-        RailsErrorDashboard::Logger.info("Registered plugin: #{plugin.name} (#{plugin.version})")
+        RailsErrorDashboard::Logger.info("Registered plugin: #{name} (#{version_of(plugin)})")
         true
       end
 
       # Unregister a plugin by name
       # @param plugin_name [String] The name of the plugin to unregister
       def unregister(plugin_name)
-        plugins.reject! { |p| p.name == plugin_name }
+        plugins.reject! { |p| name_of(p) == plugin_name }
       end
 
       # Clear all plugins (useful for testing)
@@ -43,7 +65,7 @@ module RailsErrorDashboard
       # @param plugin_name [String] The name of the plugin
       # @return [Plugin, nil] The plugin instance or nil if not found
       def find(plugin_name)
-        plugins.find { |p| p.name == plugin_name }
+        plugins.find { |p| name_of(p) == plugin_name }
       end
 
       # Dispatch an event to all registered plugins
@@ -51,7 +73,7 @@ module RailsErrorDashboard
       # @param args [Array] Arguments to pass to the event handler
       def dispatch(event_name, *args)
         plugins.each do |plugin|
-          next unless plugin.enabled?
+          next unless enabled?(plugin)
 
           plugin.safe_execute(event_name, *args)
         end
@@ -69,20 +91,47 @@ module RailsErrorDashboard
 
       # Get list of plugin names
       def names
-        plugins.map(&:name)
+        plugins.map { |p| name_of(p) }
       end
 
       # Get plugin information for debugging
       def info
         plugins.map do |plugin|
           {
-            name: plugin.name,
-            version: plugin.version,
-            description: plugin.description,
-            enabled: plugin.enabled?
+            name: name_of(plugin),
+            version: version_of(plugin),
+            description: (plugin.description rescue nil),
+            enabled: enabled?(plugin)
           }
         end
       end
+
+      private
+
+      # A plugin's name, or nil when #name is missing or raises.
+      def name_of(plugin)
+        value = plugin.name
+        value.is_a?(String) ? value : value&.to_s
+      rescue StandardError, NotImplementedError
+        nil
+      end
+
+      def version_of(plugin)
+        plugin.version.to_s
+      rescue StandardError, NotImplementedError
+        "unknown"
+      end
+
+      # enabled? is host code too. A raise is logged once per dispatch and
+      # read as disabled, so the other plugins still run.
+      def enabled?(plugin)
+        plugin.enabled? ? true : false
+      rescue => e
+        RailsErrorDashboard::Logger.error(
+          "[RailsErrorDashboard] Plugin '#{name_of(plugin) || plugin.class}' failed in enabled?: #{e.class} - #{e.message}; treated as disabled"
+        )
+        false
+      end
     end
   end
 end

data/lib/rails_error_dashboard/queries/boot_errors.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: the crashes that happened while the process was still booting.
+    #
+    # A boot crash (a Zeitwerk::NameError from eager loading, a SyntaxError in
+    # a model, an initializer that raised) is imported by CrashCapture with
+    # platform "boot_crash" and the file and constant it names, when it names
+    # them, in environment_info.boot. One entry per error row, most recent
+    # first: the question is "what stopped the last deploy", not a frequency
+    # ranking.
+    class BootErrors
+      PLATFORM = "boot_crash"
+
+      def self.call(days = 30, application_id: nil)
+        new(days, application_id: application_id).call
+      end
+
+      def initialize(days = 30, application_id: nil)
+        @days = days
+        @application_id = application_id
+        @start_date = days.days.ago
+      end
+
+      # @return [Hash] entries: [{id:, error_type:, message:, file:, constant:,
+      #   count:, first_seen:, last_seen:, resolved:}], unresolved_count: Integer
+      def call
+        rows = base_query
+          .order(last_seen_at: :desc, id: :desc)
+          .pluck(:id, :error_type, :message, :environment_info, :occurrence_count,
+                 :first_seen_at, :last_seen_at, :resolved)
+
+        entries = rows.map do |id, error_type, message, env_info, count, first_seen, last_seen, resolved|
+          boot = boot_detail(env_info)
+          {
+            id: id,
+            error_type: error_type.to_s,
+            message: message.to_s,
+            file: boot["file"].presence,
+            constant: boot["constant"].presence,
+            count: [ count.to_i, 1 ].max,
+            first_seen: first_seen,
+            last_seen: last_seen,
+            resolved: resolved ? true : false
+          }
+        end
+
+        { entries: entries, unresolved_count: entries.count { |e| !e[:resolved] } }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] BootErrors query failed: #{e.class}: #{e.message}")
+        { entries: [], unresolved_count: 0 }
+      end
+
+      private
+
+      def base_query
+        scope = ErrorLog.where(platform: PLATFORM).where("last_seen_at >= ?", @start_date)
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
+      end
+
+      # environment_info is JSON text; the boot detail is optional and the
+      # column may hold anything an older row wrote, so every step is guarded.
+      def boot_detail(env_info)
+        return {} if env_info.blank?
+
+        parsed = env_info.is_a?(String) ? JSON.parse(env_info) : env_info
+        boot = parsed.is_a?(Hash) ? parsed["boot"] : nil
+        boot.is_a?(Hash) ? boot : {}
+      rescue JSON::ParserError, TypeError
+        {}
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/dashboard_stats.rb

@@ -305,19 +305,11 @@ module RailsErrorDashboard
       # breakdown makes them agree by construction instead of by luck --
       # asserted by spec/queries/dashboard_breakdowns_event_volume_spec.rb.
       def errors_by_severity_7d
-        critical = Services::SeverityClassifier::CRITICAL_ERROR_TYPES
-        high     = Services::SeverityClassifier::HIGH_SEVERITY_ERROR_TYPES
-        medium   = Services::SeverityClassifier::MEDIUM_SEVERITY_ERROR_TYPES
-
         totals = { critical: 0, high: 0, medium: 0, low: 0 }
         weekly_volume.by_group_attribute(:error_type).each do |error_type, count|
-          bucket =
-            if critical.include?(error_type) then :critical
-            elsif high.include?(error_type)  then :high
-            elsif medium.include?(error_type) then :medium
-            else :low
-            end
-          totals[bucket] += count
+          # classify honours custom_severity_rules; the bare constants did not.
+          bucket = Services::SeverityClassifier.classify(error_type)
+          totals[totals.key?(bucket) ? bucket : :low] += count
         end
         totals
       end

data/lib/rails_error_dashboard/queries/errors_list.rb

@@ -150,33 +150,27 @@ 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)
         return query unless @filters[:severity].present?
 
-        # Map severity levels to error types
-        error_types = case @filters[:severity].to_sym
-        when :critical
-          Services::SeverityClassifier::CRITICAL_ERROR_TYPES
-        when :high
-          Services::SeverityClassifier::HIGH_SEVERITY_ERROR_TYPES
-        when :medium
-          Services::SeverityClassifier::MEDIUM_SEVERITY_ERROR_TYPES
+        # Severity is not a column: it is classified from error_type, built-in
+        # lists plus config.custom_severity_rules. The classifier owns both, so
+        # the filter agrees with the badges by construction.
+        case @filters[:severity].to_sym
+        when :critical, :high, :medium
+          query.where(error_type: Services::SeverityClassifier.error_types_for(@filters[:severity]))
         when :low
           # Low severity = everything NOT in the other categories
-          all_categorized = Services::SeverityClassifier::CRITICAL_ERROR_TYPES +
-                           Services::SeverityClassifier::HIGH_SEVERITY_ERROR_TYPES +
-                           Services::SeverityClassifier::MEDIUM_SEVERITY_ERROR_TYPES
-          # Use NOT IN to filter out categorized errors
-          return query.where.not(error_type: all_categorized)
+          query.where.not(error_type: Services::SeverityClassifier.categorized_error_types)
         else
-          return query
+          query
         end
-
-        query.where(error_type: error_types)
       end
 
       # Phase 3: Workflow filter methods

data/lib/rails_error_dashboard/queries/health_status.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: is the error dashboard itself able to do its job right now?
+    #
+    # "Who watches the watchmen": if the error database is unreachable, or the
+    # async queue that carries captures is misconfigured, no error ever reaches
+    # the dashboard and nothing else will say so. GET /health answers that
+    # question for an uptime monitor.
+    #
+    # Four checks, each individually rescued so one failing probe never hides
+    # the others:
+    #
+    #   database         SELECT 1 on the ERROR database (ErrorLogsRecord's
+    #                    pool, so use_separate_database is honoured), plus
+    #                    "are RED's tables there". The one check that can make
+    #                    the whole answer "down".
+    #   errors           last capture time and the last-24h count: cheap,
+    #                    both served by the occurred_at index.
+    #   queue            the Active Job adapter RED's jobs run on, whether
+    #                    captures are async, and the Solid Queue config
+    #                    problems the boot check found (memoised per process).
+    #   storm_protection the circuit breaker's current state.
+    #   active_storage   one existence check against the host's configured
+    #                    storage service (Services::ActiveStorageProbe).
+    #                    Storage is the app's dependency, not RED's, so a
+    #                    failure here degrades the answer rather than taking
+    #                    it down; "skipped" when ActiveStorage is not set up.
+    #
+    # Budget: one DB round trip plus two indexed queries. No COUNT(*) over the
+    # whole table (unbounded on a large install), no file reads (the Solid
+    # Queue check is memoised), nothing external. Never raises.
+    class HealthStatus
+      OK = "ok"
+      DEGRADED = "degraded"
+      DOWN = "down"
+      # A check that does not apply to this host: neutral for the overall answer.
+      SKIPPED = "skipped"
+
+      def self.call
+        new.call
+      end
+
+      def call
+        started = monotonic_now
+
+        database = check_database
+        checks = {
+          database: database,
+          # Skipped when the database is down: the queries would only fail
+          # again, slower, against a server that is not answering.
+          errors: database[:status] == DOWN ? skipped("database unreachable") : check_errors,
+          queue: check_queue,
+          storm_protection: check_storm_protection,
+          active_storage: check_active_storage
+        }
+
+        {
+          status: overall_status(checks),
+          version: RailsErrorDashboard::VERSION,
+          timestamp: Time.current.utc.iso8601,
+          checks: checks,
+          duration_ms: elapsed_ms(started)
+        }
+      rescue StandardError => e
+        # Last line of defence: the controller must always have something to
+        # render, and a health endpoint that 500s is the wrong kind of alarm.
+        {
+          status: DOWN,
+          version: RailsErrorDashboard::VERSION,
+          timestamp: Time.current.utc.iso8601,
+          checks: {},
+          error: e.class.name
+        }
+      end
+
+      # The HTTP status the controller should answer with.
+      def self.http_status_for(result)
+        result[:status] == DOWN ? 503 : 200
+      end
+
+      private
+
+      def check_database
+        config = RailsErrorDashboard.configuration
+        started = monotonic_now
+
+        adapter = nil
+        ErrorLogsRecord.connection_pool.with_connection do |connection|
+          adapter = connection.adapter_name
+          connection.select_value("SELECT 1")
+        end
+
+        tables_present = ErrorLog.table_exists?
+
+        {
+          status: tables_present ? OK : DOWN,
+          adapter: adapter,
+          separate_database: config.use_separate_database ? true : false,
+          tables_present: tables_present,
+          latency_ms: elapsed_ms(started)
+        }.tap do |check|
+          check[:reason] = "missing_tables" unless tables_present
+        end
+      rescue StandardError => e
+        {
+          status: DOWN,
+          separate_database: RailsErrorDashboard.configuration.use_separate_database ? true : false,
+          # Class only: the message can carry a host name or a connection string.
+          error: e.class.name
+        }
+      end
+
+      def check_errors
+        last = ErrorLog.maximum(:occurred_at)
+        {
+          status: OK,
+          last_error_at: last&.utc&.iso8601,
+          last_24h: ErrorLog.where("occurred_at >= ?", 24.hours.ago).count
+        }
+      rescue StandardError => e
+        { status: DEGRADED, error: e.class.name }
+      end
+
+      def check_queue
+        config = RailsErrorDashboard.configuration
+        problems = Services::SolidQueueConfigCheck.current_problems
+
+        {
+          status: problems.empty? ? OK : DEGRADED,
+          async_logging: config.async_logging ? true : false,
+          adapter: ApplicationJob.queue_adapter_name.to_s,
+          problems: problems
+        }
+      rescue StandardError => e
+        { status: DEGRADED, error: e.class.name }
+      end
+
+      def check_storm_protection
+        enabled = RailsErrorDashboard.configuration.enable_storm_protection ? true : false
+        state = enabled ? Services::StormProtection::Gate.state.to_s : "closed"
+
+        {
+          # Any state but closed means captures are being shed or merely
+          # counted: the dashboard is lagging reality by design, and a monitor
+          # should know.
+          status: state == "closed" ? OK : DEGRADED,
+          enabled: enabled,
+          state: state
+        }
+      rescue StandardError => e
+        { status: DEGRADED, error: e.class.name }
+      end
+
+      def check_active_storage
+        probe = Services::ActiveStorageProbe.call
+        case probe[:status]
+        when Services::ActiveStorageProbe::OK
+          { status: OK, service: probe[:service], latency_ms: probe[:latency_ms] }
+        when Services::ActiveStorageProbe::SKIPPED
+          { status: SKIPPED, reason: probe[:reason] }
+        else
+          { status: DEGRADED, service: probe[:service], error: probe[:error] }
+        end
+      rescue StandardError => e
+        { status: DEGRADED, error: e.class.name }
+      end
+
+      def skipped(reason)
+        { status: DEGRADED, skipped: reason }
+      end
+
+      def overall_status(checks)
+        statuses = checks.values.map { |c| c[:status] }
+        return DOWN if statuses.include?(DOWN)
+        return DEGRADED if statuses.include?(DEGRADED)
+
+        OK
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def elapsed_ms(started)
+        ((monotonic_now - started) * 1000).round(2)
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/missing_translation_summary.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: the host app's missing translation keys, most-missed first.
+    #
+    # Reads the missing_translations table (indexed SQL, no JSON parsing) for
+    # rows last seen inside the window. One entry per (locale, key): the same
+    # key missing in two locales is two rows, because fixing one locale file
+    # does not fix the other.
+    class MissingTranslationSummary
+      def self.call(days = 30, application_id: nil)
+        new(days, application_id: application_id).call
+      end
+
+      def initialize(days = 30, application_id: nil)
+        @days = days
+        @application_id = application_id
+        @start_date = days.days.ago
+      end
+
+      # @return [Hash] entries: [{locale:, key:, source:, count:, first_seen:, last_seen:}],
+      #   overflow_count: Integer, locales: [String]
+      # One pluck of every in-window row; entries, the locale set and the
+      # overflow total all come out of it, so a page view is two statements
+      # (table_exists? and this) whatever the row count.
+      def call
+        return empty unless MissingTranslation.table_exists?
+
+        merged = {}
+        overflow = 0
+
+        base_query.pluck(:locale, :translation_key, :source, :miss_count, :first_seen_at, :last_seen_at)
+          .each do |locale, key, source, count, first_seen, last_seen|
+            # Misses the tracker could not attribute to a key because its
+            # buffer was full: kept out of the listing (they belong to no
+            # key) but totalled, so the page never silently understates.
+            if key == MissingTranslation::OVERFLOW_KEY
+              overflow += count.to_i
+              next
+            end
+
+            # Merged by (locale, key) rather than trusted to be unique: the
+            # upsert index includes application_id, and a NULL there (no
+            # application_name configured) lets two threads' first writes of
+            # the same key both land, on every database. Two rows for one key
+            # would read as two problems; summing them reads as one.
+            entry = merged[[ locale.to_s, key.to_s ]] ||= {
+              locale: locale.to_s, key: key.to_s, source: nil, count: 0, first_seen: nil, last_seen: nil
+            }
+            entry[:count] += count.to_i
+            entry[:source] ||= source.presence
+            entry[:first_seen] = [ entry[:first_seen], first_seen ].compact.min
+            entry[:last_seen] = [ entry[:last_seen], last_seen ].compact.max
+          end
+
+        entries = merged.values.sort_by { |e| [ -e[:count], -(e[:last_seen]&.to_f || 0) ] }
+
+        {
+          entries: entries,
+          overflow_count: overflow,
+          locales: entries.map { |e| e[:locale] }.uniq.sort
+        }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] MissingTranslationSummary query failed: #{e.class}: #{e.message}")
+        empty
+      end
+
+      private
+
+      def empty
+        { entries: [], overflow_count: 0, locales: [] }
+      end
+
+      def base_query
+        scope = MissingTranslation.seen_since(@start_date)
+        scope = scope.for_application(@application_id) if @application_id.present?
+        scope
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/active_storage_probe.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Is the host's ActiveStorage service reachable right now?
+    #
+    # One existence check for a key that is never stored. The answer itself
+    # (false) is irrelevant; the round trip is the test: Disk stats a path,
+    # S3/GCS/Azure make one HEAD-style request. A raise (credentials, DNS, a
+    # bucket that no longer exists, a disk that is not mounted) means the
+    # service is down for the app too, which is what an operator wants to
+    # know before the upload errors start.
+    #
+    # Read by the /health endpoint and the ActiveStorage Health page, both
+    # on demand: nothing here runs on the capture path. Never raises.
+    class ActiveStorageProbe
+      # Namespaced so it cannot collide with a real blob key, which are
+      # 28-character base36 tokens.
+      PROBE_KEY = "rails_error_dashboard/health-probe"
+
+      OK = "ok"
+      DOWN = "down"
+      SKIPPED = "skipped"
+
+      def self.call
+        new.call
+      end
+
+      def call
+        return skipped("active_storage_not_loaded") unless defined?(::ActiveStorage)
+        # Checked before ActiveStorage::Blob is touched: loading that class
+        # reads config/storage.yml and raises when the file is missing, which
+        # on a host that never set storage up is "not configured", not "down".
+        return skipped("no_service_configured") unless configured?
+
+        service = storage_service
+        return skipped("no_service_configured") if service.nil?
+
+        started = monotonic_now
+        service.exist?(PROBE_KEY)
+
+        { status: OK, service: service_name(service), latency_ms: elapsed_ms(started) }
+      rescue => e
+        # Class only: the message can carry a bucket name, a host or a path.
+        { status: DOWN, service: safe_service_name(service), error: e.class.name }
+      end
+
+      private
+
+      def skipped(reason)
+        { status: SKIPPED, reason: reason }
+      end
+
+      # The configured service object. A seam: specs replace it with a double
+      # rather than stubbing ActiveStorage::Blob, whose class load reads the
+      # blobs table's schema (absent in the dummy app).
+      def storage_service
+        ::ActiveStorage::Blob.service
+      end
+
+      # config.active_storage.service names the service chosen for this
+      # environment; nil when the app never configured storage.
+      def configured?
+        ::Rails.application.config.active_storage.service.present?
+      rescue
+        false
+      end
+
+      # The name from config/storage.yml ("amazon", "local"), which is what
+      # the operator recognises; the class otherwise.
+      def service_name(service)
+        name = service.respond_to?(:name) ? service.name : nil
+        name.presence&.to_s || service.class.name.to_s.demodulize.delete_suffix("Service").downcase
+      end
+
+      def safe_service_name(service)
+        service ? service_name(service) : nil
+      rescue
+        nil
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def elapsed_ms(started)
+        ((monotonic_now - started) * 1000).round(2)
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/backtrace_parser.rb

@@ -94,15 +94,21 @@ module RailsErrorDashboard
       end
 
       def app_code?(file_path)
-        # Match /app/ or app/ (shortened paths start without leading /)
-        return true if file_path.include?("/app/") || file_path.start_with?("app/")
+        # A gem's own app/ or lib/ (an engine's models, a gem's lib) is not
+        # the host's code: it got the View Source button and a link into the
+        # host's repository for a file that is not there.
+        return false if gem_code?(file_path) || ruby_code?(file_path)
 
-        # Match /lib/ or lib/ but exclude gems and ruby stdlib
-        lib_path = file_path.include?("/lib/") || file_path.start_with?("lib/")
-        return false unless lib_path
+        # Match /app/ or app/ (shortened paths start without leading /), and
+        # the other host directories a Rails.root-relative frame can start with
+        return true if file_path.include?("/app/") || file_path.start_with?("app/", "config/", "db/")
 
-        !file_path.include?("/gems/") && !file_path.include?("/ruby/") &&
-          !file_path.start_with?("gems/") && !file_path.start_with?("ruby/")
+        # Match /lib/ or lib/ (the host's lib/, gems and stdlib excluded above)
+        file_path.include?("/lib/") || file_path.start_with?("lib/")
+      end
+
+      def ruby_code?(file_path)
+        file_path.include?("/ruby/") || file_path.start_with?("ruby/")
       end
 
       def gem_code?(file_path)