rails_error_dashboard 0.14.3 → 0.15.0

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

data/lib/rails_error_dashboard/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

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

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

@@ -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,55 +43,36 @@ 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
         "/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)
-      end
+        mount = engine_mount_path.to_s.chomp("/")
+        return true if mount.empty?
 
-      def find_limit_config(path)
-        if path.start_with?("#{engine_mount_path}/api")
-          API_LIMIT
-        else
-          DASHBOARD_LIMIT
-        end
+        path == mount || path.start_with?("#{mount}/")
       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)
@@ -91,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