rails_error_dashboard 0.8.3 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 270ac48ebee51c2f68cab29abdbf1169b7db7d7b860bf1fc5a43883960cdc0c6
-  data.tar.gz: 6def5b5a2bbcabffd1116f13607771f6923823dc65eec803e028ba911af85ec9
+  metadata.gz: f85952e5800c354ae158411afbec605cddbc5e19595e8e94620d1b13fc17894b
+  data.tar.gz: 1af4bb9352a7fcffc10fc6b913b896ca2fd75198d31e044ff156b76cb52f6afc
 SHA512:
-  metadata.gz: fd6984fc8ccb2a68f9543786ffd6157d1a975ed5d446a13e38b3a38b42cc93047117918186b7f3936c2ddc3a53c3609db63073abad5f25d02edba4961e7b1f30
-  data.tar.gz: 55ba8d78b0d06176ac80e63919cd29a6ca94423d8880712c8fb82979a17741b5881878ef2351efd89c468fbb3d03c6411c82c5c4668a687f4f441b512c169814
+  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,10 +20,24 @@ 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
 
+    # Render pagination in the dashboard's own locale, not the host app's.
+    #
+    # Pagy stores its locale in Thread.current[:pagy_locale] and never resets it
+    # (pagy 43.6.1, modules/i18n/i18n.rb:24-31 — the "for the duration of a single
+    # request" comment is aspirational; nothing in the gem enforces it). A host app
+    # that sets a per-request locale leaves that value on the Puma thread, so a
+    # dashboard request landing on a recycled thread inherits whatever language the
+    # host last used — Russian on one refresh, Portuguese on the next (issue #148).
+    around_action :with_dashboard_locale
+
     # CRITICAL: Ensure dashboard errors never break the app
     # Catch all exceptions and render user-friendly error page
     # NOTE: rescue_from is checked in reverse declaration order (last = highest priority).
@@ -60,6 +86,96 @@ module RailsErrorDashboard
 
     private
 
+    # Set the dashboard's locale for this request and restore whatever was
+    # there before.
+    #
+    # 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
+    #    it would stamp "en" onto a thread that started clean — making the
+    #    dashboard a source of the very leak it is fixing.
+    # 2. around_action + ensure, not before_action. A before_action would strand
+    #    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_pagy = Thread.current[:pagy_locale]
+      Pagy::I18n.locale = dashboard_pagy_locale
+      Current.locale = dashboard_locale
+      yield
+    ensure
+      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
+      configured = RailsErrorDashboard.configuration.dashboard_locale.to_s.strip
+      return "en" if configured.empty?
+
+      self.class.resolved_pagy_locales[configured] ||= resolve_pagy_locale(configured)
+    rescue StandardError
+      "en"
+    end
+
+    # Pagy looks its dictionary up by exact filename AND by an exact top-level
+    # key inside that YAML, so "EN" finds en.yml but then reads a nil dictionary
+    # and raises mid-render. Match the shipped filenames case-insensitively and
+    # fall back to English for anything Pagy cannot serve.
+    def resolve_pagy_locale(configured)
+      available = Pagy::I18n.pathnames.flat_map { |dir| Dir.glob(dir.join("*.yml")) }
+                              .map { |path| File.basename(path, ".yml") }
+      available.find { |locale| locale.casecmp?(configured) } || "en"
+    end
+
+    def self.resolved_pagy_locales
+      @resolved_pagy_locales ||= {}
+    end
+
     def render_dashboard_error(icon:, title:, message:, detail: nil, icon_style: nil, status: :internal_server_error)
       set_common_view_variables
       error_html = <<~ERB
@@ -83,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,11 +517,15 @@ 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
 
+      # Distinguishes "gem not installed" from "installed but no rules matched"
+      # in the empty state — both otherwise render an identical blank page.
+      @rack_attack_missing = !defined?(::Rack::Attack)
+
       days = days_param(default: 30)
       @days = days
       result = Queries::RackAttackSummary.call(days, application_id: @current_application_id)
@@ -506,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
@@ -547,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
@@ -567,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
@@ -581,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
@@ -601,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
 
@@ -639,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
 
@@ -652,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
 
@@ -739,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