rails_error_dashboard 0.8.3 → 0.9.0

data/config/routes.rb

@@ -7,6 +7,11 @@ RailsErrorDashboard::Engine.routes.draw do
   # Settings page
   get "settings", to: "errors#settings", as: :settings
 
+  # Per-user dashboard language, persisted in the session (P5-T1).
+  # POST only: changing it is a state change, and a GET would let any link or
+  # prefetch alter the user's language.
+  post "locale", to: "locales#create", as: :locale
+
   # Webhook endpoint for two-way issue sync (GitHub/GitLab/Codeberg)
   post "webhooks/:provider", to: "webhooks#receive", as: :webhook
 

data/db/migrate/20260325000001_fix_swallowed_exceptions_index_for_mysql.rb

@@ -13,8 +13,14 @@ class FixSwallowedExceptionsIndexForMysql < ActiveRecord::Migration[7.0]
     return unless table_exists?(:rails_error_dashboard_swallowed_exceptions)
 
     # Remove the oversized index if it exists (it may not exist on MySQL
-    # since the original migration would have failed at this point)
-    if index_exists?(:rails_error_dashboard_swallowed_exceptions, name: "index_swallowed_exceptions_upsert_key")
+    # since the original migration would have failed at this point).
+    #
+    # Checked by name rather than by columns. index_exists? takes the column
+    # list as a required positional argument — omitting it raises ArgumentError
+    # on Rails 8 — and passing it would be wrong here anyway: this migration
+    # wants to free the *name* before re-adding it, whatever columns the
+    # existing index happens to cover.
+    if index_name_exists?(:rails_error_dashboard_swallowed_exceptions, "index_swallowed_exceptions_upsert_key")
       remove_index :rails_error_dashboard_swallowed_exceptions, name: "index_swallowed_exceptions_upsert_key"
     end
 
@@ -33,7 +39,7 @@ class FixSwallowedExceptionsIndexForMysql < ActiveRecord::Migration[7.0]
   def down
     return unless table_exists?(:rails_error_dashboard_swallowed_exceptions)
 
-    if index_exists?(:rails_error_dashboard_swallowed_exceptions, name: "index_swallowed_exceptions_upsert_key")
+    if index_name_exists?(:rails_error_dashboard_swallowed_exceptions, "index_swallowed_exceptions_upsert_key")
       remove_index :rails_error_dashboard_swallowed_exceptions, name: "index_swallowed_exceptions_upsert_key"
     end
 

data/lib/rails_error_dashboard/commands/batch_delete_errors.rb

@@ -5,6 +5,8 @@ module RailsErrorDashboard
     # Command: Delete multiple errors at once
     # This is a write operation that destroys multiple ErrorLog records
     class BatchDeleteErrors
+      include RailsErrorDashboard::Translation
+
       def self.call(error_ids)
         new(error_ids).call
       end
@@ -14,7 +16,7 @@ module RailsErrorDashboard
       end
 
       def call
-        return { success: false, count: 0, errors: [ "No error IDs provided" ] } if @error_ids.empty?
+        return { success: false, count: 0, errors: [ red_t("red.commands.no_error_ids") ] } if @error_ids.empty?
 
         errors = ErrorLog.where(id: @error_ids)
         count = errors.count

data/lib/rails_error_dashboard/commands/batch_mute_errors.rb

@@ -4,6 +4,8 @@ module RailsErrorDashboard
   module Commands
     # Command: Mute multiple errors at once
     class BatchMuteErrors
+      include RailsErrorDashboard::Translation
+
       def self.call(error_ids, muted_by: nil, reason: nil)
         new(error_ids, muted_by, reason).call
       end
@@ -15,7 +17,7 @@ module RailsErrorDashboard
       end
 
       def call
-        return { success: false, count: 0, errors: [ "No error IDs provided" ] } if @error_ids.empty?
+        return { success: false, count: 0, errors: [ red_t("red.commands.no_error_ids") ] } if @error_ids.empty?
 
         errors = ErrorLog.where(id: @error_ids)
 
@@ -46,7 +48,7 @@ module RailsErrorDashboard
           count: muted_count,
           total: @error_ids.size,
           failed_ids: failed_ids,
-          errors: failed_ids.empty? ? [] : [ "Failed to mute #{failed_ids.size} error(s)" ]
+          errors: failed_ids.empty? ? [] : [ red_tp("red.commands.batch_failed.mute", count: failed_ids.size) ]
         }
       rescue => e
         RailsErrorDashboard::Logger.error("Batch mute failed: #{e.message}")

data/lib/rails_error_dashboard/commands/batch_resolve_errors.rb

@@ -5,6 +5,8 @@ module RailsErrorDashboard
     # Command: Resolve multiple errors at once
     # This is a write operation that updates multiple ErrorLog records
     class BatchResolveErrors
+      include RailsErrorDashboard::Translation
+
       def self.call(error_ids, resolved_by_name: nil, resolution_comment: nil)
         new(error_ids, resolved_by_name, resolution_comment).call
       end
@@ -16,7 +18,7 @@ module RailsErrorDashboard
       end
 
       def call
-        return { success: false, count: 0, errors: [ "No error IDs provided" ] } if @error_ids.empty?
+        return { success: false, count: 0, errors: [ red_t("red.commands.no_error_ids") ] } if @error_ids.empty?
 
         errors = ErrorLog.where(id: @error_ids)
 
@@ -50,7 +52,7 @@ module RailsErrorDashboard
           count: resolved_count,
           total: @error_ids.size,
           failed_ids: failed_ids,
-          errors: failed_ids.empty? ? [] : [ "Failed to resolve #{failed_ids.size} error(s)" ]
+          errors: failed_ids.empty? ? [] : [ red_tp("red.commands.batch_failed.resolve", count: failed_ids.size) ]
         }
       rescue => e
         RailsErrorDashboard::Logger.error("Batch resolve failed: #{e.message}")

data/lib/rails_error_dashboard/commands/batch_unmute_errors.rb

@@ -4,6 +4,8 @@ module RailsErrorDashboard
   module Commands
     # Command: Unmute multiple errors at once
     class BatchUnmuteErrors
+      include RailsErrorDashboard::Translation
+
       def self.call(error_ids)
         new(error_ids).call
       end
@@ -13,7 +15,7 @@ module RailsErrorDashboard
       end
 
       def call
-        return { success: false, count: 0, errors: [ "No error IDs provided" ] } if @error_ids.empty?
+        return { success: false, count: 0, errors: [ red_t("red.commands.no_error_ids") ] } if @error_ids.empty?
 
         errors = ErrorLog.where(id: @error_ids)
 
@@ -44,7 +46,7 @@ module RailsErrorDashboard
           count: unmuted_count,
           total: @error_ids.size,
           failed_ids: failed_ids,
-          errors: failed_ids.empty? ? [] : [ "Failed to unmute #{failed_ids.size} error(s)" ]
+          errors: failed_ids.empty? ? [] : [ red_tp("red.commands.batch_failed.unmute", count: failed_ids.size) ]
         }
       rescue => e
         RailsErrorDashboard::Logger.error("Batch unmute failed: #{e.message}")

data/lib/rails_error_dashboard/commands/create_issue.rb

@@ -12,6 +12,8 @@ module RailsErrorDashboard
     #   result[:success]   # => true
     #   result[:issue_url] # => "https://github.com/user/repo/issues/42"
     class CreateIssue
+      include RailsErrorDashboard::Translation
+
       def self.call(error_id, dashboard_url: nil)
         new(error_id, dashboard_url: dashboard_url).call
       end
@@ -26,11 +28,11 @@ module RailsErrorDashboard
 
         # Don't create duplicate issues
         if error.external_issue_url.present?
-          return { success: false, error: "Error already has a linked issue: #{error.external_issue_url}" }
+          return { success: false, error: red_t("red.commands.issue.already_linked", url: error.external_issue_url) }
         end
 
         client = Services::IssueTrackerClient.from_config
-        return { success: false, error: "Issue tracking is not configured" } unless client
+        return { success: false, error: red_t("red.commands.issue.not_configured") } unless client
 
         config = RailsErrorDashboard.configuration
         title = "[#{error.error_type}] #{error.message.to_s.truncate(100)}"
@@ -50,7 +52,7 @@ module RailsErrorDashboard
           { success: false, error: result[:error] }
         end
       rescue ActiveRecord::RecordNotFound
-        { success: false, error: "Error not found: #{@error_id}" }
+        { success: false, error: red_t("red.commands.error_not_found", id: @error_id) }
       rescue => e
         { success: false, error: "#{e.class}: #{e.message}" }
       end

data/lib/rails_error_dashboard/commands/link_existing_issue.rb

@@ -11,6 +11,8 @@ module RailsErrorDashboard
     #   result = LinkExistingIssue.call(error_id, issue_url: "https://github.com/user/repo/issues/42")
     #   result[:success] # => true
     class LinkExistingIssue
+      include RailsErrorDashboard::Translation
+
       PROVIDER_PATTERNS = {
         github: %r{github\.com/([^/]+/[^/]+)/issues/(\d+)}i,
         gitlab: %r{gitlab\.com/([^/]+/[^/]+)/-/issues/(\d+)}i,
@@ -29,7 +31,7 @@ module RailsErrorDashboard
       end
 
       def call
-        return { success: false, error: "Issue URL is required" } if @issue_url.blank?
+        return { success: false, error: red_t("red.commands.issue.url_required") } if @issue_url.blank?
 
         error = ErrorLog.find(@error_id)
         parsed = parse_issue_url(@issue_url)
@@ -42,7 +44,7 @@ module RailsErrorDashboard
 
         { success: true, issue_url: @issue_url, provider: parsed[:provider] }
       rescue ActiveRecord::RecordNotFound
-        { success: false, error: "Error not found: #{@error_id}" }
+        { success: false, error: red_t("red.commands.error_not_found", id: @error_id) }
       rescue => e
         { success: false, error: "#{e.class}: #{e.message}" }
       end

data/lib/rails_error_dashboard/commands/log_error.rb

@@ -505,7 +505,7 @@ module RailsErrorDashboard
         return unless config.baseline_alert_severities.include?(anomaly[:level])
 
         # Enqueue alert job (which will handle throttling)
-        BaselineAlertJob.perform_later(error_log.id, anomaly)
+        BaselineAlertJob.perform_later(error_log.id, anomaly, ApplicationJob.enqueue_locale)
 
         RailsErrorDashboard::Logger.info(
           "Baseline alert queued for #{error_log.error_type} on #{error_log.platform}: " \

data/lib/rails_error_dashboard/configuration.rb

@@ -222,6 +222,18 @@ module RailsErrorDashboard
     # Dashboard UI appearance
     attr_accessor :accent_color  # :crimson (default), :ruby, :ember, :violet
 
+    # Locale the dashboard renders in, independent of the host app's locale.
+    #
+    # Drives both Pagy's pagination labels and RED's own translation lookups.
+    # Ships "en", "de", "fr", "es", "pt-BR" and "ja". Everything but English is
+    # machine-translated and has NOT been reviewed by a native speaker — see
+    # docs/guides/TRANSLATIONS.md. A missing or wrong translation falls back to
+    # English rather than breaking the page.
+    #
+    # Users can override this per-session with the dashboard's language picker.
+    # Unknown or wrong-cased values fall back to "en" (default: "en").
+    attr_accessor :dashboard_locale
+
     # LLM-powered AI help (disabled unless provider and API key are configured)
     attr_accessor :llm_provider              # :openai or :anthropic
     attr_accessor :llm_api_key               # String or lambda/proc
@@ -433,6 +445,7 @@ module RailsErrorDashboard
 
       # Dashboard UI
       @accent_color = :crimson  # :crimson, :ruby, :ember, :violet
+      @dashboard_locale = "en"  # en, de, es, fr, pt-BR, ja, ru, uk, pl, it, zh-CN (non-English machine-translated)
 
       # LLM-powered AI help defaults - OFF until provider and API key are configured
       @llm_provider = ENV["RED_LLM_PROVIDER"]&.to_sym
@@ -590,6 +603,16 @@ module RailsErrorDashboard
         if rack_attack_flush_interval && rack_attack_flush_interval < 1
           errors << "rack_attack_flush_interval must be at least 1 (got: #{rack_attack_flush_interval})"
         end
+
+        # Warn rather than auto-disable: validation may run before the host's
+        # Rack::Attack initializer has loaded, so a missing constant here does
+        # not prove it will still be missing at after_initialize (when the
+        # subscriber actually registers). Auto-disabling would break that case.
+        unless defined?(::Rack::Attack)
+          warnings << "enable_rack_attack_tracking is enabled but the rack-attack gem " \
+                      "does not appear to be loaded. No events will be recorded until " \
+                      "Rack::Attack is installed and configured."
+        end
       end
 
       # Validate actioncable tracking requires breadcrumbs

data/lib/rails_error_dashboard/current.rb

@@ -0,0 +1,56 @@
+module RailsErrorDashboard
+  # Request-scoped state for the dashboard.
+  #
+  # Currently holds only the locale. ActiveSupport resets CurrentAttributes
+  # between requests, but the dashboard does NOT rely on that alone — the
+  # around_action in ApplicationController clears this explicitly in an
+  # ensure block. Two reasons:
+  #
+  #   1. RED renders inside the host app's process, on Puma threads the host
+  #      also uses. State that outlives its request is the shape behind both
+  #      #143 and #148, where a value stranded on a recycled thread leaked
+  #      into a later request.
+  #   2. The reset is a framework guarantee we do not want to depend on for a
+  #      safety property.
+  #
+  # NOTE: locale intentionally has NO default. A getter that coerced nil to
+  # "en" would make restoration stamp "en" onto a thread that started clean —
+  # the exact trap documented in ApplicationController#with_dashboard_locale
+  # for Pagy. Callers resolve the default themselves via .locale_or_default.
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :locale
+
+    class << self
+      # The locale the dashboard should render in, applying full precedence:
+      #
+      #   Current.locale            (set per request; later, the user's picker)
+      #     -> config.dashboard_locale
+      #       -> "en"
+      #
+      # Each candidate is validated against the locales RED actually ships, so
+      # a configured locale we cannot serve degrades to English instead of
+      # failing mid-render.
+      #
+      # @return [String] a locale RED ships. Never nil, never raises.
+      def locale_or_default
+        # to_s.strip rather than .presence — locale is a public attribute and
+        # a later caller (the session-backed picker in Phase 5) could put any
+        # object in it. Anything that is not a usable String falls through to
+        # the configured value.
+        candidate = locale.to_s.strip
+        candidate = configured_locale.to_s.strip if candidate.empty?
+        I18nStore.resolve(candidate)
+      rescue StandardError
+        I18nStore::DEFAULT_LOCALE
+      end
+
+      private
+
+      def configured_locale
+        RailsErrorDashboard.configuration&.dashboard_locale
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/i18n_store.rb

@@ -0,0 +1,293 @@
+require "rails_error_dashboard/private_backend"
+
+module RailsErrorDashboard
+  # RED's own translation store, deliberately isolated from the host app's I18n.
+  #
+  # WHY A PRIVATE BACKEND INSTEAD OF THE USUAL ENGINE LOAD PATH
+  #
+  # The conventional way to translate a Rails engine is to append
+  # config/locales to I18n.load_path and namespace the keys. That shares the
+  # host's backend, and sharing it hands the host three ways to break the
+  # dashboard:
+  #
+  #   1. config.i18n.raise_on_missing_translations = true turns any key we
+  #      forgot into a 500 — on the error dashboard, the one page that has to
+  #      work when everything else is broken.
+  #   2. enforce_available_locales with a short available_locales list raises
+  #      I18n::InvalidLocale as soon as RED asks for its own locale.
+  #   3. A custom exception_handler can raise on anything it likes.
+  #
+  # RED's locale is also deliberately independent of the host's — that is the
+  # whole point of issue #148. Sharing a backend would re-create the coupling
+  # that bug was about.
+  #
+  # The trade-off: hosts cannot override RED's strings with their own locale
+  # files. That is the right default for a self-hosted ops tool, and it can be
+  # relaxed later without breaking anything.
+  #
+  # NOTHING IN HERE MAY RAISE. Every public method is total: it returns a
+  # String for any input, including garbage. See #translate.
+  module I18nStore
+    DEFAULT_LOCALE = "en".freeze
+
+    # The language's own name for itself. See .locale_options for why these are
+    # constants rather than translation keys.
+    ENDONYMS = {
+      "en" => "English",
+      "de" => "Deutsch",
+      "fr" => "Français",
+      "es" => "Español",
+      "pt-BR" => "Português (Brasil)",
+      "ja" => "日本語",
+      "ru" => "Русский",
+      "uk" => "Українська",
+      "pl" => "Polski",
+      "zh-CN" => "简体中文",
+      "it" => "Italiano"
+    }.freeze
+
+    # Raw backend lookups signal a miss by throwing :exception rather than
+    # returning — I18n.translate is what normally catches it. We call the
+    # backend directly, so we catch it ourselves.
+    MISSING = Object.new.freeze
+    private_constant :MISSING
+
+    class << self
+      # Translate +key+ in +locale+, falling back to English, then to a
+      # readable last resort derived from the key itself.
+      #
+      # @param key [String, Symbol] dot-separated key, e.g. "red.nav.errors"
+      # @param locale [String, Symbol] target locale
+      # @return [String] always a String — never nil, never a raise
+      def translate(key, locale: DEFAULT_LOCALE, **options)
+        return "" if key.nil? || key.to_s.empty?
+
+        resolved = lookup(key, locale, options)
+        return resolved unless resolved.equal?(MISSING)
+
+        unless locale.to_s == DEFAULT_LOCALE
+          fallback = lookup(key, DEFAULT_LOCALE, options)
+          return fallback unless fallback.equal?(MISSING)
+        end
+
+        humanized_key(key)
+      rescue StandardError
+        # Truly last resort. A translation lookup must never be the reason a
+        # dashboard page fails to render.
+        humanized_key(key)
+      end
+      alias_method :t, :translate
+
+      # Fetch a whole branch of the dictionary as a Hash, for callers that need
+      # the tree rather than one leaf — the JS payload is the only one today.
+      #
+      # #translate deliberately treats a Hash result as a miss: a key resolving
+      # to a subtree instead of a leaf is a caller bug when you asked for text.
+      # Here it is the point, so this is a separate method rather than a flag on
+      # #translate.
+      #
+      # Falls back to English as a whole branch, not key by key. A partially
+      # translated locale returning a half-English tree would be harder to
+      # debug than one that is cleanly English until it is finished.
+      #
+      # @param key [String, Symbol] dot-separated key, e.g. "red.js"
+      # @return [Hash] deep-frozen dup, or {} for a miss. Never nil, never raises.
+      def subtree(key, locale: DEFAULT_LOCALE)
+        return {} if key.nil? || key.to_s.empty?
+
+        resolved = lookup_subtree(key, locale)
+        return resolved unless resolved.equal?(MISSING)
+
+        unless locale.to_s == DEFAULT_LOCALE
+          fallback = lookup_subtree(key, DEFAULT_LOCALE)
+          return fallback unless fallback.equal?(MISSING)
+        end
+
+        {}
+      rescue StandardError
+        {}
+      end
+
+      # Locales RED ships, derived from the files actually present.
+      # @return [Array<Symbol>]
+      def available_locales
+        @available_locales ||= locale_files.map { |path| File.basename(path, ".yml").to_sym }.sort
+      end
+
+      # Each shipped locale paired with its ENDONYM — the language's own name
+      # for itself (Deutsch, not German).
+      #
+      # Deliberately NOT translation keys. An endonym is a property of the
+      # language, not of the locale you are viewing from: a picker that renders
+      # "German" when viewed from English and "Deutsch" when viewed from German
+      # is unusable precisely when you need it, which is when you are stuck in a
+      # language you cannot read. Every entry reads the same in every locale.
+      #
+      # A locale with a file but no entry here falls back to its own tag ("xh"),
+      # which is honest and still selectable, rather than being hidden.
+      #
+      # @return [Array<Array(String, String)>] [locale, endonym] pairs, sorted
+      #   by locale so the picker's order is stable.
+      def locale_options
+        available_locales.map { |locale| [ locale.to_s, ENDONYMS.fetch(locale.to_s, locale.to_s) ] }
+      rescue StandardError
+        [ [ DEFAULT_LOCALE, ENDONYMS.fetch(DEFAULT_LOCALE) ] ]
+      end
+
+      # Resolve an arbitrary value to a locale RED can actually serve.
+      # Matches case-insensitively ("EN" -> :en) because a wrong-cased tag that
+      # passes a format check but misses the dictionary is a mid-render failure.
+      #
+      # @return [String] a locale RED ships, or "en"
+      def resolve(value)
+        candidate = value.to_s.strip
+        return DEFAULT_LOCALE if candidate.empty?
+
+        match = available_locales.find { |locale| locale.to_s.casecmp?(candidate) }
+        match ? match.to_s : DEFAULT_LOCALE
+      rescue StandardError
+        DEFAULT_LOCALE
+      end
+
+      # @return [Boolean] whether RED ships this locale
+      #
+      # Compares case-insensitively rather than against a downcased copy —
+      # "pt-BR" is a real locale filename and downcasing it would report a
+      # locale we ship as unavailable.
+      def available?(value)
+        candidate = value.to_s.strip
+        return false if candidate.empty?
+
+        available_locales.any? { |locale| locale.to_s.casecmp?(candidate) }
+      rescue StandardError
+        false
+      end
+
+      # Double-checked locking. The fast path reads a fully-built backend; the
+      # slow path builds it under the mutex. build_backend assigns only after
+      # load_translations returns, so no thread can observe a half-loaded
+      # backend through @backend.
+      def backend
+        cached = @backend
+        return cached if cached
+
+        load_mutex.synchronize do
+          @backend ||= build_backend
+        end
+      end
+
+      # Test seam. Clears memoized state so specs can reload from disk.
+      def reset!
+        load_mutex.synchronize do
+          @backend = nil
+          @available_locales = nil
+        end
+      end
+
+      private
+
+      # Returns the translated String, or MISSING. Never raises, never throws.
+      def lookup(key, locale, options)
+        result = catch(:exception) do
+          backend.translate(locale.to_s.to_sym, key.to_s, **options)
+        end
+
+        # A miss throws :exception carrying an I18n::MissingTranslation.
+        return MISSING if result.is_a?(::I18n::MissingTranslation)
+        return MISSING if result.nil?
+
+        # A key that resolves to a subtree rather than a leaf is a caller bug,
+        # not something to render.
+        return MISSING if result.is_a?(Hash)
+
+        result.to_s
+      rescue ::I18n::InvalidPluralizationData
+        # A locale supplying only :other while :count is 1 (or missing a plural
+        # category the count needs). Real risk for translated locales — English
+        # has one/other, but not every language's forms line up. Fall through so
+        # the caller gets English rather than a 500.
+        MISSING
+      rescue StandardError
+        MISSING
+      end
+
+      # Returns a Hash for a subtree key, or MISSING. Never raises, never throws.
+      def lookup_subtree(key, locale)
+        result = catch(:exception) do
+          backend.translate(locale.to_s.to_sym, key.to_s)
+        end
+
+        return MISSING unless result.is_a?(Hash)
+
+        result
+      rescue StandardError
+        MISSING
+      end
+
+      # The backend is a PrivateBackend, not a bare Backend::Simple: two
+      # upstream load-time behaviours let the host app decide what RED's
+      # dictionary CONTAINS, and both are fixed there as invariants rather than
+      # worked around here. See private_backend.rb for the mechanism — the
+      # short version is that a host allowlist could strip RED's own locales
+      # out of RED's own dictionary, and the first lookup could merge the
+      # host's entire load_path in. Neither raises; both just render English.
+      #
+      # Found in P4-T3 by a spec fixture that kept resolving to English.
+      def build_backend
+        PrivateBackend.new.tap do |backend|
+          # Load each file individually rather than in one call, and never let
+          # one bad file take the dictionary down with it.
+          #
+          # load_translations raises for anything it cannot read: a file
+          # deleted between Dir[] and the open (locale_files is memoized, so
+          # the gap is real), a YAML syntax error, a permissions problem. A
+          # single call loses every locale to the first failure, and the raise
+          # escapes into whatever was rendering — which for RED is the error
+          # dashboard, the one page that must not break. NOTHING IN THIS FILE
+          # MAY RAISE (see the class comment); this was the last unguarded call.
+          #
+          # A file that fails is skipped and logged. The remaining locales load,
+          # and any key the skipped file would have supplied falls back to
+          # English through the normal path.
+          locale_files.each do |file|
+            backend.load_translations(file)
+          rescue StandardError => e
+            warn_unloadable_locale(file, e)
+          end
+        end
+      end
+
+      # A locale file that cannot be read is a real problem, but not one worth
+      # breaking the dashboard over. Logged rather than raised, and guarded
+      # because the logger itself must not be the thing that raises.
+      def warn_unloadable_locale(file, error)
+        ::Rails.logger&.warn(
+          "[RailsErrorDashboard] Skipped unreadable locale file #{file}: #{error.class} - #{error.message}"
+        )
+      rescue StandardError
+        nil
+      end
+
+      def locale_files
+        Dir[File.join(locales_path, "*.yml")].sort
+      end
+
+      def locales_path
+        File.expand_path("../../config/locales", __dir__)
+      end
+
+      # "red.nav.error_logs" -> "Error logs". Readable, and never the string
+      # "translation missing", which must never reach a user's screen.
+      def humanized_key(key)
+        segment = key.to_s.split(".").last.to_s
+        return "" if segment.empty?
+
+        segment.tr("_", " ").capitalize
+      end
+
+      def load_mutex
+        @load_mutex ||= Mutex.new
+      end
+    end
+  end
+end