rails_error_dashboard 0.14.4 → 0.15.0

data/lib/generators/rails_error_dashboard/install/templates/initializer.rb

@@ -127,6 +127,21 @@ RailsErrorDashboard.configure do |config|
   config.enable_discord_notifications = false
   # config.discord_webhook_url = ENV["DISCORD_WEBHOOK_URL"]
 
+<% end -%>
+<% if @enable_telegram -%>
+  # Telegram Notifications - ENABLED
+  config.enable_telegram_notifications = true
+  config.telegram_bot_token = ENV["TELEGRAM_BOT_TOKEN"]
+  config.telegram_chat_id = ENV["TELEGRAM_CHAT_ID"]
+  # To disable: Set config.enable_telegram_notifications = false
+
+<% else -%>
+  # Telegram Notifications - DISABLED
+  # To enable: Set config.enable_telegram_notifications = true and configure a bot token and chat id
+  config.enable_telegram_notifications = false
+  # config.telegram_bot_token = ENV["TELEGRAM_BOT_TOKEN"]
+  # config.telegram_chat_id = ENV["TELEGRAM_CHAT_ID"]
+
 <% end -%>
 <% if @enable_pagerduty -%>
   # PagerDuty Integration - ENABLED (critical errors only)
@@ -145,6 +160,9 @@ RailsErrorDashboard.configure do |config|
   # Generic Webhook Notifications - ENABLED
   config.enable_webhook_notifications = true
   config.webhook_urls = ENV.fetch("WEBHOOK_URLS", "").split(",").map(&:strip).reject(&:empty?)
+  # Sign every webhook (HMAC-SHA256 over timestamp + body) so receivers can
+  # verify it came from this app. Generate with: ruby -rsecurerandom -e 'puts SecureRandom.hex(32)'
+  # config.webhook_signing_secret = ENV["WEBHOOK_SIGNING_SECRET"]
   # To disable: Set config.enable_webhook_notifications = false
 
 <% else -%>
@@ -152,6 +170,7 @@ RailsErrorDashboard.configure do |config|
   # To enable: Set config.enable_webhook_notifications = true and configure webhook URLs
   config.enable_webhook_notifications = false
   # config.webhook_urls = ENV.fetch("WEBHOOK_URLS", "").split(",").map(&:strip).reject(&:empty?)
+  # config.webhook_signing_secret = ENV["WEBHOOK_SIGNING_SECRET"]  # HMAC-SHA256 signature headers
 
 <% end -%>
   # Dashboard base URL (used in notification links)
@@ -408,6 +427,14 @@ RailsErrorDashboard.configure do |config|
   # config.swallowed_exception_threshold = 0.95
 
 <% end -%>
+  # Missing-Translation Tracking - DISABLED
+  # Counts every I18n key your app looked up and did not have, by locale, with
+  # the first call site, on its own dashboard page (/errors/missing_translations).
+  # Wraps I18n.exception_handler and delegates to the handler you already had —
+  # the one place RED touches global I18n state, which is why it is opt-in.
+  # To enable: Set config.enable_missing_translation_tracking = true
+  config.enable_missing_translation_tracking = false
+
 <% if @enable_diagnostic_dump -%>
   # Diagnostic Dump - ENABLED
   # On-demand system state snapshot via rake task or dashboard button

data/lib/rails_error_dashboard/commands/assign_error.rb

@@ -29,10 +29,33 @@ module RailsErrorDashboard
         error.update!(
           assigned_to: assignee.truncate(MAX_ASSIGNEE_LENGTH, omission: ""),
           assigned_at: Time.current,
-          status: "in_progress" # Auto-transition to in_progress when assigned
+          **status_attributes(error)
         )
+        # The stat cards are cached; a reopened error must show up at once.
+        Services::AnalyticsCacheManager.clear if error.saved_change_to_resolved?
+
         { success: true, error: error }
       end
+
+      private
+
+      # Assigning means someone is working on it, so the error moves to
+      # in_progress. Doing that to a resolved error used to leave
+      # resolved: true and resolved_at behind: a row that was in_progress to
+      # the eye, resolved to the scopes, and matched by neither the unresolved
+      # nor the resolved lookup, so its next recurrence opened a new row.
+      # Assigning a resolved error reopens it. wont_fix is sticky (H-6): the
+      # assignee is recorded and the status stays.
+      def status_attributes(error)
+        return {} if error.status == "wont_fix"
+
+        attrs = { status: "in_progress" }
+        if error.resolved? || error.status == "resolved"
+          attrs[:resolved] = false
+          attrs[:resolved_at] = nil
+        end
+        attrs
+      end
     end
   end
 end

data/lib/rails_error_dashboard/commands/batch_resolve_errors.rb

@@ -44,11 +44,19 @@ module RailsErrorDashboard
           end
         end
 
-        # Dispatch plugin event for batch resolved errors
         Services::AnalyticsCacheManager.clear if resolved_count.positive?
 
+        # Dispatch plugin event for batch resolved errors
         PluginRegistry.dispatch(:on_errors_batch_resolved, resolved_errors) if resolved_errors.any?
 
+        # Each error resolved here is as resolved as one resolved on its own
+        # page: the host's error_resolved callbacks (the issue tracker closes
+        # the linked issue from one) and the instrumentation event fire per
+        # error. Only the plugin event is batch-shaped, by design.
+        resolved_errors.each do |error|
+          Services::ResolutionCallbacks.call(error, resolved_by: @resolved_by_name)
+        end
+
         {
           success: failed_ids.empty?,
           count: resolved_count,

data/lib/rails_error_dashboard/commands/flush_missing_translations.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Commands
+    # Command: upsert a snapshot of buffered missing-translation counts.
+    #
+    # Receives { "locale\x1Fkey" => [count, source] } from
+    # MissingTranslationTracker and adds each count to its (locale, key,
+    # application) row, creating the row on first sight. find_or_initialize_by
+    # + save! rather than a raw upsert, for cross-database compatibility; a
+    # concurrent first insert of the same key is retried once as a read.
+    #
+    # Runs off the request path (executor to_complete, at_exit). Never raises:
+    # a failed row is logged at debug and the rest of the snapshot still lands.
+    class FlushMissingTranslations
+      def self.call(counts:)
+        new(counts: counts).call
+      end
+
+      def initialize(counts:)
+        @counts = counts || {}
+      end
+
+      def call
+        return if @counts.empty?
+        return unless MissingTranslation.table_exists?
+
+        now = Time.current
+        app_id = current_application_id
+
+        @counts.each do |buffer_key, (count, source)|
+          # A key can be built from user input, so invalid bytes are possible.
+          locale, translation_key = Services::MissingTranslationTracker.parse_key(
+            Services::EncodingSanitizer.scrub(buffer_key.to_s)
+          )
+          next if locale.blank? || translation_key.blank? || count.to_i <= 0
+
+          upsert(locale: locale, translation_key: translation_key,
+                 source: source, count: count.to_i, app_id: app_id, now: now)
+        end
+      rescue => e
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] FlushMissingTranslations failed: #{e.class} - #{e.message}"
+        )
+      end
+
+      private
+
+      # Insert on first sight; otherwise an atomic SQL increment. A
+      # read-modify-write (load miss_count, add, save) would lose increments
+      # when two threads flush the same hot key at once, and with per-thread
+      # buffers flushing every few seconds that is the common case, not a race
+      # worth ignoring.
+      def upsert(locale:, translation_key:, source:, count:, app_id:, now:)
+        identity = { locale: locale, translation_key: translation_key, application_id: app_id }
+        clean_source = Services::EncodingSanitizer.scrub(source.to_s).presence
+
+        record = MissingTranslation.find_by(identity)
+        if record
+          increment(record, count: count, source: clean_source, now: now)
+        else
+          begin
+            MissingTranslation.create!(identity.merge(
+              miss_count: count, source: clean_source, first_seen_at: now, last_seen_at: now
+            ))
+          rescue ActiveRecord::RecordNotUnique
+            # Another thread inserted the row between our read and our insert:
+            # it exists now, so add to it. A NULL application_id lets both
+            # inserts through on every database; the query merges those rows.
+            record = MissingTranslation.find_by(identity)
+            raise unless record
+
+            increment(record, count: count, source: clean_source, now: now)
+          end
+        end
+      rescue => e
+        RailsErrorDashboard::Logger.debug(
+          "[RailsErrorDashboard] FlushMissingTranslations.upsert failed for #{locale}.#{translation_key}: #{e.class} - #{e.message}"
+        )
+      end
+
+      def increment(record, count:, source:, now:)
+        updates = [ "miss_count = miss_count + ?, last_seen_at = ?", count, now ]
+        # First-write-wins: the first call site seen is the one worth showing,
+        # and overwriting it on every flush would make the column flicker
+        # between callers of the same key. Filled in only while still blank.
+        if record.source.blank? && source
+          updates = [ "miss_count = miss_count + ?, last_seen_at = ?, source = ?", count, now, source ]
+        end
+        MissingTranslation.where(id: record.id).update_all(updates)
+      end
+
+      def current_application_id
+        app_name = RailsErrorDashboard.configuration.application_name
+        return nil unless app_name.present?
+
+        Application.find_by(name: app_name)&.id
+      rescue => e
+        nil
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -433,7 +433,7 @@ module RailsErrorDashboard
           error_type: reported_error_type || @exception.class.name,
           message: @exception.message,
           backtrace: truncated_backtrace,
-          user_id: error_context.user_id,
+          user_id: ErrorLog.storable_user_id(error_context.user_id),
           request_url: error_context.request_url,
           request_params: error_context.request_params,
           user_agent: error_context.user_agent,

data/lib/rails_error_dashboard/commands/resolve_error.rb

@@ -31,21 +31,8 @@ module RailsErrorDashboard
         # Dispatch plugin event for resolved error
         PluginRegistry.dispatch(:on_error_resolved, error)
 
-        # Trigger notification callbacks
-        RailsErrorDashboard.configuration.notification_callbacks[:error_resolved].each do |callback|
-          callback.call(error)
-        rescue => e
-          RailsErrorDashboard::Logger.error("Error in error_resolved callback: #{e.message}")
-        end
-
-        # Emit ActiveSupport::Notifications instrumentation event
-        ActiveSupport::Notifications.instrument("error_resolved.rails_error_dashboard", {
-          error_log: error,
-          error_id: error.id,
-          error_type: error.error_type,
-          resolved_by: @resolution_data[:resolved_by_name],
-          resolved_at: error.resolved_at
-        })
+        # Host callbacks (issue-tracker close) and the instrumentation event.
+        Services::ResolutionCallbacks.call(error, resolved_by: @resolution_data[:resolved_by_name])
 
         error
       end

data/lib/rails_error_dashboard/commands/update_error_status.rb

@@ -44,6 +44,13 @@ module RailsErrorDashboard
         # The stat cards are cached; a user action must show up at once.
         Services::AnalyticsCacheManager.clear
 
+        # Moving to "resolved" through the dropdown is a resolution like any
+        # other: the linked issue closes and subscribers hear about it.
+        if @status == "resolved"
+          PluginRegistry.dispatch(:on_error_resolved, error)
+          Services::ResolutionCallbacks.call(error, resolved_by: error.assigned_to)
+        end
+
         { success: true, error: error }
       end
 

data/lib/rails_error_dashboard/configuration.rb

@@ -13,7 +13,8 @@ module RailsErrorDashboard
     # #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
+      webhook_urls webhook_signing_secret issue_tracker_token issue_webhook_secret llm_api_key
+      telegram_bot_token
     ].freeze
 
     # Dashboard authentication (always required)
@@ -46,6 +47,14 @@ module RailsErrorDashboard
     attr_accessor :discord_webhook_url
     attr_accessor :enable_discord_notifications
 
+    # Telegram (Bot API: a bot token from @BotFather and the chat, group or
+    # channel the bot posts to). telegram_api_base_url exists for a local Bot
+    # API server or a proxy; nearly every install leaves it alone.
+    attr_accessor :enable_telegram_notifications
+    attr_accessor :telegram_bot_token
+    attr_accessor :telegram_chat_id
+    attr_accessor :telegram_api_base_url
+
     # PagerDuty notifications (critical errors only)
     attr_accessor :pagerduty_integration_key
     attr_accessor :enable_pagerduty_notifications
@@ -53,6 +62,9 @@ module RailsErrorDashboard
     # Generic webhook notifications
     attr_accessor :webhook_urls
     attr_accessor :enable_webhook_notifications
+    # When set, every POST to webhook_urls carries an HMAC-SHA256 signature
+    # (X-Error-Dashboard-Signature-256) and a timestamp the receiver can verify.
+    attr_accessor :webhook_signing_secret
 
     # Scheduled digests (daily/weekly summary emails)
     attr_accessor :enable_scheduled_digests         # Master switch (default: false)
@@ -231,6 +243,12 @@ module RailsErrorDashboard
     attr_accessor :rack_attack_max_cache_size           # Max buffered keys per thread (default: 1000)
     attr_accessor :rack_attack_flush_interval           # Seconds between DB flushes (default: 5)
 
+    # Missing-translation tracking — counts the HOST app's I18n misses by
+    # locale and key in their own table. Wraps I18n.exception_handler
+    # (delegating to the handler the app already had); the one place RED
+    # touches global I18n state, so it is opt-in.
+    attr_accessor :enable_missing_translation_tracking  # Master switch (default: false)
+
     # ActionCable event tracking (requires enable_breadcrumbs = true)
     attr_accessor :enable_actioncable_tracking          # Master switch (default: false)
     # ActiveStorage event tracking (requires enable_breadcrumbs = true)
@@ -309,6 +327,12 @@ module RailsErrorDashboard
       @discord_webhook_url = ENV["DISCORD_WEBHOOK_URL"]
       @enable_discord_notifications = false
 
+      # Telegram notification settings
+      @enable_telegram_notifications = false
+      @telegram_bot_token = ENV["TELEGRAM_BOT_TOKEN"]
+      @telegram_chat_id = ENV["TELEGRAM_CHAT_ID"]
+      @telegram_api_base_url = ENV.fetch("TELEGRAM_API_BASE_URL", "https://api.telegram.org")
+
       # PagerDuty notification settings (critical errors only)
       @pagerduty_integration_key = ENV["PAGERDUTY_INTEGRATION_KEY"]
       @enable_pagerduty_notifications = false
@@ -316,6 +340,10 @@ module RailsErrorDashboard
       # Generic webhook settings (array of URLs)
       @webhook_urls = ENV.fetch("WEBHOOK_URLS", "").split(",").map(&:strip).reject(&:empty?)
       @enable_webhook_notifications = false
+      # nil leaves outbound webhooks unsigned, as before. Secret-only (no
+      # separate "enable" flag): a secret with nothing to apply it to is the
+      # one combination that has no sensible meaning.
+      @webhook_signing_secret = ENV["WEBHOOK_SIGNING_SECRET"].presence
 
       # Scheduled digest defaults - OFF by default (opt-in)
       @enable_scheduled_digests = false
@@ -483,6 +511,10 @@ module RailsErrorDashboard
       # roughly one write per thread per interval.
       @rack_attack_flush_interval = 5    # Seconds between DB flushes
 
+      # Missing-translation tracking - OFF by default (opt-in). Persists to its
+      # own table; does NOT require breadcrumbs.
+      @enable_missing_translation_tracking = false
+
       # ActionCable event tracking defaults - OFF by default (opt-in, requires breadcrumbs)
       @enable_actioncable_tracking = false
       # ActiveStorage event tracking defaults - OFF by default (opt-in, requires breadcrumbs)
@@ -810,6 +842,15 @@ module RailsErrorDashboard
           errors << "discord_webhook_url is required when enable_discord_notifications is true"
         end
 
+        if enable_telegram_notifications
+          if telegram_bot_token.to_s.strip.empty?
+            errors << "telegram_bot_token is required when enable_telegram_notifications is true"
+          end
+          if telegram_chat_id.to_s.strip.empty?
+            errors << "telegram_chat_id is required when enable_telegram_notifications is true"
+          end
+        end
+
         if enable_pagerduty_notifications && (pagerduty_integration_key.nil? || pagerduty_integration_key.strip.empty?)
           errors << "pagerduty_integration_key is required when enable_pagerduty_notifications is true"
         end

data/lib/rails_error_dashboard/engine.rb

@@ -48,6 +48,22 @@ module RailsErrorDashboard
       end
     end
 
+    # Register the crash-capture at_exit hook as soon as the host's
+    # config/initializers have run (so enable_crash_capture is known) and
+    # BEFORE Rails' :eager_load! finisher. Every engine initializer runs ahead
+    # of the finishers, so this is early enough for a Zeitwerk::NameError, a
+    # SyntaxError in a model or a raising initializer to be captured; the old
+    # place, config.after_initialize, runs AFTER eager loading and was never
+    # reached by exactly the crashes a boot check exists for. The import of
+    # earlier crash files stays in after_initialize, where the database is.
+    initializer "rails_error_dashboard.crash_capture", after: :load_config_initializers do
+      next if ENV["SECRET_KEY_BASE_DUMMY"].present?
+
+      if RailsErrorDashboard.configuration.enable_crash_capture
+        RailsErrorDashboard::Services::CrashCapture.enable!
+      end
+    end
+
     # Validate configuration after initialization
     initializer "rails_error_dashboard.validate_config", after: :load_config_initializers do
       config.after_initialize do
@@ -133,6 +149,28 @@ module RailsErrorDashboard
         at_exit { RailsErrorDashboard::Services::RackAttackTracker.flush_all_threads! }
       end
 
+      # Count the host app's missing translations. The handler wrap is the one
+      # place RED touches global I18n state, so it runs only when opted in,
+      # and here in after_initialize so the handler the host's own
+      # initializers configured is the one being wrapped (and delegated to).
+      #
+      # Same drain points as Rack Attack tracking: to_complete fires after the
+      # response body is closed (never delays a request, safety rule 2) and is
+      # interval-gated; at_exit drains whatever buffers are still on live
+      # threads. Puma joins its worker threads before at_exit runs, so what a
+      # worker held at SIGTERM (at most FLUSH_INTERVAL seconds of misses) is
+      # lost with it; the hook still covers the main thread, runners and
+      # console sessions. at_exit, not Signal.trap (safety rule 9).
+      if RailsErrorDashboard.configuration.enable_missing_translation_tracking
+        RailsErrorDashboard::Services::MissingTranslationHandler.install!
+
+        Rails.application.executor.to_complete do
+          RailsErrorDashboard::Services::MissingTranslationTracker.flush_if_due!
+        end
+
+        at_exit { RailsErrorDashboard::Services::MissingTranslationTracker.flush_all_threads! }
+      end
+
       # Drain the storm count buffer at the end of every request and job, and
       # again at process exit.
       #
@@ -224,7 +262,10 @@ module RailsErrorDashboard
         end
       end
 
-      # Import crash files from previous process death, then register at_exit hook
+      # Import crash files from a previous process death. The at_exit hook
+      # itself is registered by the "rails_error_dashboard.crash_capture"
+      # initializer above, before eager loading; enable! here is a no-op when
+      # that ran and a fallback when the configuration was only set later.
       if RailsErrorDashboard.configuration.enable_crash_capture
         RailsErrorDashboard::Services::CrashCapture.import!
         RailsErrorDashboard::Services::CrashCapture.enable!

data/lib/rails_error_dashboard/middleware/rate_limiter.rb

@@ -55,8 +55,14 @@ module RailsErrorDashboard
         "/red"
       end
 
+      # The mount itself or anything below it. A plain start_with? also
+      # matched the host's own /redirect when the engine was at /red. An
+      # engine mounted at "/" owns every path.
       def error_dashboard_route?(path)
-        path.start_with?(engine_mount_path)
+        mount = engine_mount_path.to_s.chomp("/")
+        return true if mount.empty?
+
+        path == mount || path.start_with?("#{mount}/")
       end
 
       def rate_limit_key(request, limit_config)

data/lib/rails_error_dashboard/plugin.rb

@@ -121,11 +121,27 @@ module RailsErrorDashboard
 
       send(method_name, *args)
     rescue => e
-      # Log plugin failures but never propagate - plugins must not break the app
-      RailsErrorDashboard::Logger.error("[RailsErrorDashboard] Plugin '#{name}' failed in #{method_name}: #{e.class} - #{e.message}")
-      RailsErrorDashboard::Logger.error("Plugin version: #{version}")
+      # Log plugin failures but never propagate - plugins must not break the app.
+      # name and version are plugin code too, so the log line must not depend
+      # on them answering.
+      RailsErrorDashboard::Logger.error("[RailsErrorDashboard] Plugin '#{safe_label}' failed in #{method_name}: #{e.class} - #{e.message}")
+      RailsErrorDashboard::Logger.error("Plugin version: #{safe_version}")
       RailsErrorDashboard::Logger.error(e.backtrace&.first(10)&.join("\n")) if e.backtrace
       nil # Explicitly return nil, never raise
     end
+
+    private
+
+    def safe_label
+      name.to_s
+    rescue StandardError, NotImplementedError
+      self.class.name
+    end
+
+    def safe_version
+      version.to_s
+    rescue StandardError, NotImplementedError
+      "unknown"
+    end
   end
 end

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