rails_error_dashboard 0.8.4 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba282b251af897146a14dce9cbd14aae0032428b96bb8d274d7400db3b1386cd
-  data.tar.gz: 4d4de4a7d143fe4233ea283766f452018f0a057652620077579686c6a10b1cbe
+  metadata.gz: f85952e5800c354ae158411afbec605cddbc5e19595e8e94620d1b13fc17894b
+  data.tar.gz: 1af4bb9352a7fcffc10fc6b913b896ca2fd75198d31e044ff156b76cb52f6afc
 SHA512:
-  metadata.gz: e794d0737d5c8381a8a127ff30ebea8023fbf3e9b73f089d2cde9832617f953a6a589481a954dad41e1a18c85400e36e3a04a8a3bac35eaedc35aa53cf3a3d87
-  data.tar.gz: b9cff40ccba8d4459e0fe829dbf43fd054c66ff3f2a28a15d0be334e84fe757fc02c1d34e326ab1956a5d6074474113951e42bfdd9f9ef43705a0cfae46c0165
+  metadata.gz: a6bc19522b5797095df0545fd6eca1b2552bfcd693ebb4363a17e8076ad784654340a70d1e9591f2ab3fc17a5fc9be10e65efa1b0211b329203c639b085b37a7
+  data.tar.gz: c0885c4d27dde62b2439a40dac82acdee468f34ce9dd3d188b2f589bbceedab680c746ec7793e894cb3d5dacb7aff68908139cf90d655dc9790c0aea503ef784

data/README.md

@@ -602,6 +602,40 @@ end
 
 ---
 
+## Languages
+
+The dashboard, its emails and its notification payloads are translated. Eleven locales ship:
+
+| Locale | Language | Status |
+|---|---|---|
+| `en` | English | Source language |
+| `de` | Deutsch | Machine-translated, unreviewed |
+| `es` | Español | Machine-translated, unreviewed |
+| `fr` | Français | Machine-translated, unreviewed |
+| `pt-BR` | Português (Brasil) | Machine-translated, unreviewed |
+| `ja` | 日本語 | Machine-translated, unreviewed |
+| `ru` | Русский | Machine-translated, unreviewed |
+| `uk` | Українська | Machine-translated, unreviewed |
+| `pl` | Polski | Machine-translated, unreviewed |
+| `it` | Italiano | Machine-translated, unreviewed |
+| `zh-CN` | 简体中文 | Machine-translated, unreviewed |
+
+```ruby
+config.dashboard_locale = "de"  # en, de, es, fr, pt-BR, ja, ru, uk, pl, it, zh-CN — default "en"
+```
+
+Users can also switch language per-session from the picker in the dashboard navbar, which overrides the configured default for them alone.
+
+**Everything but English is machine-translated and has not been reviewed by a native speaker.** That is stated plainly rather than as "beta", which would imply a review process that has not happened — RED's maintainer reads only English. Key structure, interpolation variables and plural categories *are* verified mechanically in every locale; wording, register and idiom are not verified by anyone. A wrong or missing translation falls back to **English**, never to a broken page.
+
+**Corrections are very welcome, and a one-key PR is a perfectly good PR.** If you read one of these languages, [every locale has an open issue](https://github.com/AnjanJ/rails_error_dashboard/issues?q=is%3Aissue+is%3Aopen+label%3Atranslation%3Aneeds-review) tracking its review — comment there, or [report a bad translation](https://github.com/AnjanJ/rails_error_dashboard/issues/new?template=translation_report.yml) without touching any code. You do not need to know Ruby, and you are not expected to review a whole file.
+
+RED translates through its own private I18n backend, so it never reads, writes or mutates your application's `I18n` configuration — your locale and its `available_locales` are untouched.
+
+[Translations guide →](docs/guides/TRANSLATIONS.md) — how the system works, how to correct a string, and how to add a locale.
+
+---
+
 ## FAQ
 
 **Does Rails Error Dashboard support a separate database for errors?**
@@ -647,6 +681,7 @@ Rails 7.0–8.1 and Ruby 3.2–4.0.
 - **[Batch Operations](docs/guides/BATCH_OPERATIONS.md)** — Bulk resolve/delete
 - **[Real-Time Updates](docs/guides/REAL_TIME_UPDATES.md)** — Live dashboard
 - **[Error Trends](docs/guides/ERROR_TREND_VISUALIZATIONS.md)** — Charts and analytics
+- **[Translations](docs/guides/TRANSLATIONS.md)** — Seven shipped locales, correcting a string, adding a language
 
 ### Advanced
 - **[Multi-App Support](docs/MULTI_APP_PERFORMANCE.md)** — Track multiple applications

data/app/controllers/rails_error_dashboard/application_controller.rb

@@ -1,5 +1,17 @@
 module RailsErrorDashboard
   class ApplicationController < ActionController::Base
+    # Authenticate EVERY dashboard controller, not just the ones that remember
+    # to ask. This filter used to live on ErrorsController, which meant a new
+    # controller inherited no protection at all — LocalesController (the P5-T1
+    # language picker) shipped unauthenticated for exactly that reason, and an
+    # unauthenticated POST reached controller code and 500'd instead of being
+    # refused with a 401.
+    #
+    # Declaring it here inverts the default: a controller is protected unless
+    # it explicitly opts out with skip_before_action, which is a visible,
+    # reviewable act rather than an omission nobody notices.
+    before_action :authenticate_dashboard_user!
+
     include Pagy::Method
 
     # Enable features that are disabled in API-only mode
@@ -8,6 +20,10 @@ module RailsErrorDashboard
     include ActionController::Flash
     include ActionController::RequestForgeryProtection
 
+    # red_t for flash messages. Not the view helper — that html-escapes, and a
+    # flash string is escaped again when the layout renders it.
+    include Translation
+
     layout "rails_error_dashboard"
 
     protect_from_forgery with: :exception
@@ -70,9 +86,10 @@ module RailsErrorDashboard
 
     private
 
-    # Set Pagy's locale for this request and restore whatever was there before.
+    # Set the dashboard's locale for this request and restore whatever was
+    # there before.
     #
-    # Two details are load-bearing:
+    # Three details are load-bearing:
     #
     # 1. The previous value is read from Thread.current directly, NOT from
     #    Pagy::I18n.locale. The getter coerces nil to "en", so restoring through
@@ -82,12 +99,58 @@ module RailsErrorDashboard
     #    the dashboard's locale on the thread for the host app's next request.
     #    The ensure also covers the rescue_from handlers above, which still
     #    render through the view layer.
+    # 3. RED's own locale is set on RailsErrorDashboard::Current, NOT via
+    #    I18n.with_locale. RED translates through a private backend
+    #    (I18nStore); touching the host's I18n.locale would mutate host global
+    #    state for no benefit and re-introduce exactly the coupling #148 removed.
+    #
+    # Pagy's locale and RED's are resolved independently: they ship different
+    # dictionaries, so a locale RED can serve but Pagy cannot must still render
+    # the UI translated, with English pagination, rather than raising.
     def with_dashboard_locale
-      previous = Thread.current[:pagy_locale]
+      previous_pagy = Thread.current[:pagy_locale]
       Pagy::I18n.locale = dashboard_pagy_locale
+      Current.locale = dashboard_locale
       yield
     ensure
-      Thread.current[:pagy_locale] = previous
+      Thread.current[:pagy_locale] = previous_pagy
+      Current.locale = nil
+    end
+
+    # The locale RED renders its own strings in. Resolved against the locales
+    # RED ships (not Pagy's), and never raises.
+    #
+    # Precedence (P5-T1 REQ-3): session -> config.dashboard_locale -> "en".
+    # The session half is applied here and the rest by locale_or_default, which
+    # validates whatever it is given against the locales RED actually ships.
+    # Assigning Current.locale only when the session holds a usable value keeps
+    # an empty session from overriding the configured default.
+    def dashboard_locale
+      Current.locale = session_locale
+      Current.locale_or_default
+    rescue StandardError
+      I18nStore::DEFAULT_LOCALE
+    end
+
+    # The user's picked locale, or nil.
+    #
+    # Returns nil rather than raising for every way this can go wrong: no
+    # session at all (an API-only host where the engine's session middleware
+    # did not take effect — REQ-7), or a tampered value (REQ-6). A garbage
+    # value is not merely ignored but CLEARED, so a session poisoned once does
+    # not cost a lookup on every subsequent request.
+    #
+    # #available? is total for any input, including an Array or a Hash, so no
+    # type check is needed before it.
+    def session_locale
+      stored = session[:red_locale]
+      return nil if stored.nil?
+      return I18nStore.resolve(stored) if I18nStore.available?(stored)
+
+      session.delete(:red_locale)
+      nil
+    rescue StandardError
+      nil
     end
 
     def dashboard_pagy_locale
@@ -136,5 +199,45 @@ module RailsErrorDashboard
       # Tracked by a flag rather than the value, since the common case is nil.
       @storm_banner_event = Queries::StormHistory.banner_event unless @storm_banner_loaded
     end
+
+    def authenticate_dashboard_user!
+      auth_lambda = RailsErrorDashboard.configuration.authenticate_with
+
+      if auth_lambda
+        authenticate_with_lambda(auth_lambda)
+      else
+        authenticate_with_basic_auth
+      end
+    end
+
+    def authenticate_with_lambda(auth_lambda)
+      authorized = begin
+        instance_exec(&auth_lambda)
+      rescue => e
+        Rails.logger.error(
+          "[RailsErrorDashboard] authenticate_with lambda raised #{e.class}: #{e.message}"
+        )
+        false
+      end
+
+      return if performed?
+
+      unless authorized
+        render plain: "Access Denied", status: :forbidden
+      end
+    end
+
+    def authenticate_with_basic_auth
+      authenticate_or_request_with_http_basic do |username, password|
+        ActiveSupport::SecurityUtils.secure_compare(
+          username,
+          RailsErrorDashboard.configuration.dashboard_username
+        ) &
+        ActiveSupport::SecurityUtils.secure_compare(
+          password,
+          RailsErrorDashboard.configuration.dashboard_password
+        )
+      end
+    end
   end
 end

data/app/controllers/rails_error_dashboard/errors_controller.rb

@@ -30,6 +30,23 @@ module RailsErrorDashboard
       sort_direction
     ].freeze
 
+    # Batch action param => the key naming its outcome. English happens to form
+    # all four by adding "d"/"ed"; most languages do not, so each outcome is
+    # named rather than derived from the param.
+    BATCH_OUTCOMES = {
+      "resolve" => "resolved",
+      "mute" => "muted",
+      "unmute" => "unmuted",
+      "delete" => "deleted"
+    }.freeze
+
+    # Named once: the check and the message that reports it were both writing
+    # 4000, and the copy that drifts is the one the user reads.
+    AI_HELP_QUESTION_LIMIT = 4000
+
+    # The initializer every "not enabled" notice points at. A path, not prose.
+    INITIALIZER_PATH = "config/initializers/rails_error_dashboard.rb"
+
     def overview
       # Get dashboard stats using Query (pass application filter)
       @stats = Queries::DashboardStats.call(application_id: @current_application_id)
@@ -155,10 +172,10 @@ module RailsErrorDashboard
       result = Commands::CreateIssue.call(params[:id], dashboard_url: dashboard_url)
 
       if result[:success]
-        flash[:notice] = "Issue created successfully"
+        flash[:notice] = red_t("red.flash.issue.created")
         flash[:new_issue_url] = result[:issue_url]
       else
-        flash[:alert] = "Failed to create issue: #{result[:error]}"
+        flash[:alert] = red_t("red.flash.issue.create_failed", reason: result[:error])
       end
       redirect_to error_path(params[:id], anchor: "issue-tracking", **app_context_params)
     end
@@ -167,27 +184,30 @@ module RailsErrorDashboard
       result = Commands::LinkExistingIssue.call(params[:id], issue_url: params[:issue_url])
 
       if result[:success]
-        flash[:notice] = "Issue linked successfully"
+        flash[:notice] = red_t("red.flash.issue.linked")
       else
-        flash[:alert] = "Failed to link issue: #{result[:error]}"
+        flash[:alert] = red_t("red.flash.issue.link_failed", reason: result[:error])
       end
       redirect_to error_path(params[:id], anchor: "issue-tracking", **app_context_params)
     end
 
     def ai_help
       unless RailsErrorDashboard.configuration.llm_configured?
-        render json: { error: "AI Help is not configured" }, status: :not_found
+        render json: { error: red_t("red.flash.ai_help.not_configured") }, status: :not_found
         return
       end
 
       question = params[:question].to_s.strip
       if question.blank?
-        render json: { error: "Question cannot be blank" }, status: :unprocessable_entity
+        render json: { error: red_t("red.flash.ai_help.blank_question") }, status: :unprocessable_entity
         return
       end
 
-      if question.length > 4000
-        render json: { error: "Question is too long. Keep it under 4,000 characters." }, status: :unprocessable_entity
+      if question.length > AI_HELP_QUESTION_LIMIT
+        render json: {
+          error: red_t("red.flash.ai_help.question_too_long",
+                       limit: helpers.number_with_delimiter(AI_HELP_QUESTION_LIMIT))
+        }, status: :unprocessable_entity
         return
       end
 
@@ -248,7 +268,7 @@ module RailsErrorDashboard
     def platform_comparison
       # Check if feature is enabled
       unless RailsErrorDashboard.configuration.enable_platform_comparison
-        flash[:alert] = "Platform Comparison is not enabled. Enable it in config/initializers/rails_error_dashboard.rb"
+        flash[:alert] = feature_disabled_message("platform_comparison")
         redirect_to errors_path(**app_context_params)
         return
       end
@@ -287,13 +307,25 @@ module RailsErrorDashboard
       when "delete"
         Commands::BatchDeleteErrors.call(error_ids)
       else
-        { success: false, count: 0, errors: [ "Invalid action type" ] }
+        { success: false, count: 0, errors: [ red_t("red.commands.invalid_action") ] }
       end
 
       if result[:success]
-        flash[:notice] = "Successfully #{action_type}d #{result[:count]} error(s)"
+        # One key per outcome rather than "Successfully #{action_type}d": the
+        # original conjugated English past tense by appending a "d" to the raw
+        # param, which no other language can be asked to do.
+        #
+        # An unrecognized action cannot reach here (the case above returns
+        # success: false), but the lookup still degrades rather than raising —
+        # a flash message is never worth a 500 on the error dashboard.
+        outcome = BATCH_OUTCOMES[action_type]
+        flash[:notice] = if outcome
+          red_tp("red.flash.batch.#{outcome}", count: result[:count])
+        else
+          red_t("red.commands.invalid_action")
+        end
       else
-        flash[:alert] = "Batch operation failed: #{result[:errors].join(', ')}"
+        flash[:alert] = red_t("red.flash.batch.failed", reason: result[:errors].join(", "))
       end
 
       redirect_to errors_path(**app_context_params)
@@ -302,7 +334,7 @@ module RailsErrorDashboard
     def correlation
       # Check if feature is enabled
       unless RailsErrorDashboard.configuration.enable_error_correlation
-        flash[:alert] = "Error Correlation is not enabled. Enable it in config/initializers/rails_error_dashboard.rb"
+        flash[:alert] = feature_disabled_message("error_correlation")
         redirect_to errors_path(**app_context_params)
         return
       end
@@ -348,7 +380,7 @@ module RailsErrorDashboard
 
     def deprecations
       unless RailsErrorDashboard.configuration.enable_breadcrumbs
-        flash[:alert] = "Breadcrumbs are not enabled. Enable them in config/initializers/rails_error_dashboard.rb"
+        flash[:alert] = feature_disabled_message("breadcrumbs", plural: true)
         redirect_to errors_path(**app_context_params)
         return
       end
@@ -368,7 +400,7 @@ module RailsErrorDashboard
 
     def n_plus_one_summary
       unless RailsErrorDashboard.configuration.enable_breadcrumbs
-        flash[:alert] = "Breadcrumbs are not enabled. Enable them in config/initializers/rails_error_dashboard.rb"
+        flash[:alert] = feature_disabled_message("breadcrumbs", plural: true)
         redirect_to errors_path(**app_context_params)
         return
       end
@@ -388,7 +420,7 @@ module RailsErrorDashboard
 
     def cache_health_summary
       unless RailsErrorDashboard.configuration.enable_breadcrumbs
-        flash[:alert] = "Breadcrumbs are not enabled. Enable them in config/initializers/rails_error_dashboard.rb"
+        flash[:alert] = feature_disabled_message("breadcrumbs", plural: true)
         redirect_to errors_path(**app_context_params)
         return
       end
@@ -409,7 +441,7 @@ module RailsErrorDashboard
 
     def job_health_summary
       unless RailsErrorDashboard.configuration.enable_system_health
-        flash[:alert] = "System health is not enabled. Enable it in config/initializers/rails_error_dashboard.rb"
+        flash[:alert] = feature_disabled_message("system_health")
         redirect_to errors_path(**app_context_params)
         return
       end
@@ -429,7 +461,7 @@ module RailsErrorDashboard
 
     def database_health_summary
       unless RailsErrorDashboard.configuration.enable_system_health
-        flash[:alert] = "System health is not enabled. Enable it in config/initializers/rails_error_dashboard.rb"
+        flash[:alert] = feature_disabled_message("system_health")
         redirect_to errors_path(**app_context_params)
         return
       end
@@ -462,9 +494,9 @@ module RailsErrorDashboard
       unless RailsErrorDashboard.configuration.detect_swallowed_exceptions
         # On Ruby < 3.3, validate! auto-disables this feature — tell the user why
         if RUBY_VERSION < "3.3"
-          flash[:alert] = "Swallowed exception detection requires Ruby 3.3+ (you have #{RUBY_VERSION}). Upgrade Ruby to use this feature."
+          flash[:alert] = red_t("red.flash.swallowed_requires_ruby", version: RUBY_VERSION)
         else
-          flash[:alert] = "Swallowed exception detection is not enabled. Enable it in config/initializers/rails_error_dashboard.rb"
+          flash[:alert] = feature_disabled_message("swallowed_exceptions")
         end
         redirect_to errors_path(**app_context_params)
         return
@@ -485,7 +517,7 @@ module RailsErrorDashboard
 
     def rack_attack_summary
       unless RailsErrorDashboard.configuration.enable_rack_attack_tracking
-        flash[:alert] = "Rack Attack tracking is not enabled. Set enable_rack_attack_tracking = true in config/initializers/rails_error_dashboard.rb"
+        flash[:alert] = feature_disabled_message("rack_attack", options: "enable_rack_attack_tracking = true", set: true)
         redirect_to errors_path(**app_context_params)
         return
       end
@@ -510,7 +542,7 @@ module RailsErrorDashboard
     def actioncable_health_summary
       unless RailsErrorDashboard.configuration.enable_actioncable_tracking &&
              RailsErrorDashboard.configuration.enable_breadcrumbs
-        flash[:alert] = "ActionCable tracking is not enabled. Enable enable_actioncable_tracking and enable_breadcrumbs in config/initializers/rails_error_dashboard.rb"
+        flash[:alert] = feature_disabled_message("actioncable", options: "enable_actioncable_tracking and enable_breadcrumbs")
         redirect_to errors_path(**app_context_params)
         return
       end
@@ -551,7 +583,7 @@ module RailsErrorDashboard
     def activestorage_health_summary
       unless RailsErrorDashboard.configuration.enable_activestorage_tracking &&
              RailsErrorDashboard.configuration.enable_breadcrumbs
-        flash[:alert] = "ActiveStorage tracking is not enabled. Enable enable_activestorage_tracking and enable_breadcrumbs in config/initializers/rails_error_dashboard.rb"
+        flash[:alert] = feature_disabled_message("activestorage", options: "enable_activestorage_tracking and enable_breadcrumbs")
         redirect_to errors_path(**app_context_params)
         return
       end
@@ -571,7 +603,7 @@ module RailsErrorDashboard
 
     def diagnostic_dumps
       unless RailsErrorDashboard.configuration.enable_diagnostic_dump
-        flash[:alert] = "Diagnostic dumps are not enabled. Enable them in config/initializers/rails_error_dashboard.rb"
+        flash[:alert] = feature_disabled_message("diagnostic_dumps", plural: true)
         redirect_to errors_path(**app_context_params)
         return
       end
@@ -585,7 +617,7 @@ module RailsErrorDashboard
 
     def create_diagnostic_dump
       unless RailsErrorDashboard.configuration.enable_diagnostic_dump
-        flash[:alert] = "Diagnostic dumps are not enabled."
+        flash[:alert] = red_t("red.flash.diagnostic_dump.disabled")
         redirect_to errors_path(**app_context_params)
         return
       end
@@ -605,31 +637,31 @@ module RailsErrorDashboard
         note: params[:note].presence
       )
 
-      flash[:notice] = "Diagnostic dump captured successfully."
+      flash[:notice] = red_t("red.flash.diagnostic_dump.captured")
       redirect_to diagnostic_dumps_errors_path
     rescue => e
-      flash[:alert] = "Failed to capture diagnostic dump: #{e.message}"
+      flash[:alert] = red_t("red.flash.diagnostic_dump.failed", message: e.message)
       redirect_to diagnostic_dumps_errors_path
     end
 
     def enable_coverage
       unless RailsErrorDashboard.configuration.enable_coverage_tracking
-        flash[:alert] = "Coverage tracking is not enabled in configuration."
+        flash[:alert] = red_t("red.flash.coverage.not_enabled")
         redirect_to errors_path(**app_context_params)
         return
       end
 
       if Services::CoverageTracker.enable!
-        flash[:notice] = "Code path coverage enabled. Reproduce the error, then view source code to see executed lines."
+        flash[:notice] = red_t("red.flash.coverage.enabled")
       else
-        flash[:alert] = "Could not enable coverage. Requires Ruby 3.2+."
+        flash[:alert] = red_t("red.flash.coverage.unavailable")
       end
       redirect_back fallback_location: errors_path
     end
 
     def disable_coverage
       Services::CoverageTracker.disable!
-      flash[:notice] = "Code path coverage disabled."
+      flash[:notice] = red_t("red.flash.coverage.disabled")
       redirect_back fallback_location: errors_path
     end
 
@@ -643,10 +675,10 @@ module RailsErrorDashboard
 
       Commands::LogError.call(exception, { request: request, source: "dashboard.test_error" })
 
-      flash[:notice] = "Test error logged successfully. Check your notification channels (Slack, Discord, email, etc.) to confirm delivery."
+      flash[:notice] = red_t("red.flash.test_error.logged")
       redirect_to errors_path(**app_context_params)
     rescue => e
-      flash[:alert] = "Failed to log test error: #{e.message}"
+      flash[:alert] = red_t("red.flash.test_error.failed", message: e.message)
       redirect_to settings_path(**app_context_params)
     end
 
@@ -656,6 +688,32 @@ module RailsErrorDashboard
 
     private
 
+    # "X is not enabled. Enable it in <initializer>" was written out eleven
+    # times with only the feature name changing. One helper, so the wording
+    # cannot drift page to page — and the initializer path is interpolated
+    # rather than translated, because it is a path.
+    #
+    # English agrees the verb and pronoun with the feature name, so a plural
+    # feature ("Breadcrumbs are... Enable them") needs a different key from a
+    # singular one ("System health is... Enable it"). The caller says which;
+    # inferring it from the English string would be guessing at grammar.
+    #
+    # @param feature [String] a key under red.flash.features
+    # @param plural [Boolean] whether the feature name takes a plural verb
+    # @param options [String, nil] config option names to cite instead
+    # @param set [Boolean] use "Set" rather than "Enable" for those options
+    def feature_disabled_message(feature, plural: false, options: nil, set: false)
+      name = red_t("red.flash.features.#{feature}")
+
+      if options
+        key = set ? "red.flash.not_enabled_set_options" : "red.flash.not_enabled_options"
+        red_t(key, feature: name, options: options, file: INITIALIZER_PATH)
+      else
+        key = plural ? "red.flash.not_enabled_plural" : "red.flash.not_enabled"
+        red_t(key, feature: name, file: INITIALIZER_PATH)
+      end
+    end
+
     def calculate_release_comparison
       return {} if @errors_by_version.empty? || @errors_by_version.count < 2
 
@@ -743,45 +801,5 @@ module RailsErrorDashboard
       @storm_banner_loaded = true
       @storm_banner_event = Queries::StormHistory.banner_event
     end
-
-    def authenticate_dashboard_user!
-      auth_lambda = RailsErrorDashboard.configuration.authenticate_with
-
-      if auth_lambda
-        authenticate_with_lambda(auth_lambda)
-      else
-        authenticate_with_basic_auth
-      end
-    end
-
-    def authenticate_with_lambda(auth_lambda)
-      authorized = begin
-        instance_exec(&auth_lambda)
-      rescue => e
-        Rails.logger.error(
-          "[RailsErrorDashboard] authenticate_with lambda raised #{e.class}: #{e.message}"
-        )
-        false
-      end
-
-      return if performed?
-
-      unless authorized
-        render plain: "Access Denied", status: :forbidden
-      end
-    end
-
-    def authenticate_with_basic_auth
-      authenticate_or_request_with_http_basic do |username, password|
-        ActiveSupport::SecurityUtils.secure_compare(
-          username,
-          RailsErrorDashboard.configuration.dashboard_username
-        ) &
-        ActiveSupport::SecurityUtils.secure_compare(
-          password,
-          RailsErrorDashboard.configuration.dashboard_password
-        )
-      end
-    end
   end
 end

data/app/controllers/rails_error_dashboard/locales_controller.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Per-user language selection for the dashboard, persisted in the session.
+  #
+  # Its own controller rather than another action on ErrorsController: this
+  # touches no error data, and keeping it separate means the picker cannot be
+  # reached by anything that filters or loads errors.
+  class LocalesController < ApplicationController
+    # POST /locale
+    #
+    # Sets session[:red_locale] and returns the user to where they were.
+    #
+    # The new locale takes effect on the NEXT request, not this one. That is
+    # deliberate and it is what keeps the around_action ordering intact
+    # (P5-T1 REQ-9): with_dashboard_locale has already resolved and set
+    # Current.locale by the time this action body runs, so writing the session
+    # here cannot disturb a locale that is mid-request. The redirect then
+    # renders the target page under the new value.
+    def create
+      requested = params[:locale].to_s
+
+      if I18nStore.available?(requested)
+        # Store the canonical shipped spelling, not what the user sent.
+        # I18nStore.resolve matches case-insensitively, so "PT-br" would
+        # otherwise be written to the session and re-resolved on every
+        # subsequent request.
+        session[:red_locale] = I18nStore.resolve(requested)
+      else
+        # REQ-6: an unrecognized value is cleared rather than left to fail
+        # silently on every later request. Falling through to config is the
+        # correct behaviour, and clearing is what makes it happen.
+        session.delete(:red_locale)
+        flash[:alert] = red_t("red.flash.locale.unavailable")
+      end
+
+      redirect_to safe_return_path
+    rescue StandardError => e
+      # Session storage can be unavailable (REQ-7: an API-only host where the
+      # engine's session middleware did not take effect). Changing the language
+      # is never worth breaking the dashboard over — the user keeps the
+      # configured locale and the page still renders.
+      Rails.logger.warn("[RailsErrorDashboard] Locale selection failed: #{e.class} - #{e.message}")
+      redirect_to safe_return_path
+    end
+
+    private
+
+    # Where to send the user back to (REQ-8: same page, query params intact).
+    #
+    # Never trusts the raw Referer. An absolute URL from another origin would
+    # turn the picker into an open redirect, so only the path and query of a
+    # referer that belongs to this engine are reused; anything else falls back
+    # to the dashboard root.
+    def safe_return_path
+      referer = request.referer.to_s
+      return default_return_path if referer.empty?
+
+      uri = URI.parse(referer)
+      return default_return_path unless same_origin?(uri)
+
+      candidate = uri.path.to_s
+      return default_return_path unless candidate.start_with?(engine_mount_path)
+
+      uri.query.present? ? "#{candidate}?#{uri.query}" : candidate
+    rescue StandardError
+      default_return_path
+    end
+
+    def same_origin?(uri)
+      return true if uri.host.nil? # a relative referer
+
+      uri.host == request.host && uri.port == request.port
+    end
+
+    def engine_mount_path
+      path = RailsErrorDashboard::Engine.routes.find_script_name({})
+      path.presence || "/"
+    rescue StandardError
+      "/"
+    end
+
+    def default_return_path
+      overview_path
+    end
+  end
+end