rails_error_dashboard 0.8.3 → 0.9.0

data/lib/rails_error_dashboard/private_backend.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "i18n"
+
+module RailsErrorDashboard
+  # The backend behind I18nStore: a Backend::Simple that the host app's I18n
+  # configuration cannot reach into.
+  #
+  # Backend::Simple is very nearly private already — it holds its own
+  # translations hash and its own initialized flag. Two upstream behaviours
+  # break that, and both act at LOAD time rather than lookup time, so neither
+  # raises and neither leaves a trace. The dashboard simply renders English.
+  # Both were found in P4-T3, by a fixture locale that kept resolving to
+  # English; see tasks/i18n-sprint-plan.md.
+  #
+  # This class states the two fixes as invariants of RED's backend. The
+  # previous implementation got the same result by clearing and restoring
+  # I18n.available_locales around the load and by poking @initialized from
+  # outside — correct, but it mutated a global that a concurrent thread could
+  # observe mid-window. Nothing here touches global state.
+  class PrivateBackend < ::I18n::Backend::Simple
+    # DEFECT 1 — the host's allowlist must not decide what RED's dictionary
+    # CONTAINS.
+    #
+    # Upstream store_translations opens with a guard that discards the data,
+    # silently, returning it unstored, when all three of these hold:
+    #
+    #   1. I18n.enforce_available_locales           (the Rails DEFAULT)
+    #   2. I18n.available_locales_initialized?      (a one-way latch, below)
+    #   3. the locale is absent from the host's list
+    #
+    # Condition 2 is the fuse, and nothing can defuse it: it flips the first
+    # time anything ASSIGNS to I18n.available_locales, and I18n exposes no way
+    # to clear it. A host that configures locales at boot — or any gem that
+    # touches the setting once — arms the filter for the life of the process.
+    #
+    # The effect is that a host with `config.i18n.available_locales = [:en, :ja]`
+    # strips RED's de/fr/es/pt-BR out of RED's OWN private dictionary, and every
+    # dashboard page renders English with nothing anywhere to say why.
+    #
+    # The guard is the first statement in the upstream method, so there is no
+    # way to skip it via super and no supported hook to satisfy it — its three
+    # inputs are all host globals. What follows it is four lines of public I18n
+    # API, reproduced here without the guard.
+    #
+    # BECAUSE THIS RESTATES AN UPSTREAM BODY, it is pinned by
+    # spec/lib/rails_error_dashboard/private_backend_spec.rb, which asserts the
+    # upstream semantics this reproduces. If an i18n upgrade changes
+    # store_translations, that spec fails loudly rather than this drifting
+    # silently out of step.
+    def store_translations(locale, data, options = ::I18n::EMPTY_HASH)
+      locale = locale.to_sym
+      translations[locale] ||= Concurrent::Hash.new
+      data = ::I18n::Utils.deep_symbolize_keys(data) unless options.fetch(:skip_symbolize_keys, false)
+      STORE_MUTEX.synchronize { ::I18n::Utils.deep_merge!(translations[locale], data) }
+    end
+
+    # DEFECT 2 — the host's load_path must not decide what RED's dictionary
+    # CONTAINS either.
+    #
+    # Backend::Base#load_translations falls back to I18n.load_path when called
+    # with no filenames, and upstream init_translations calls it exactly that
+    # way. So any lookup against a backend that was never marked initialized
+    # merges every locale file the host app and its gems have registered into
+    # RED's dictionary — the precise coupling I18nStore exists to prevent. In
+    # RED's own suite that meant all of Faker's locales; in a host app it means
+    # a colliding key resolving by load order.
+    #
+    # Marking the backend initialized without reading anything makes the
+    # explicit load_translations(*files) in I18nStore#build_backend the only
+    # thing that ever populates it. Lookups are unaffected: upstream #lookup
+    # and #available_locales call init_translations only `unless initialized?`.
+    def init_translations
+      @initialized = true
+    end
+    # Upstream declares init_translations protected. Keep it so: widening an
+    # inherited method's visibility is a silent API change.
+    protected :init_translations
+
+    # DEFECT 3 — upstream's plural rule is English, so a locale with different
+    # CLDR categories cannot be rendered at all.
+    #
+    # Backend::Base#pluralization_key is `count == 1 ? :one : :other` with a
+    # :zero special case. That IS English (and de/fr/es/pt-BR are close enough
+    # that nothing noticed). It is wrong for any language whose categories
+    # differ, and it fails in the two opposite directions RED now has to serve:
+    #
+    #   ja, zh-CN  have `other` ALONE. At count 1 upstream asks for :one, the
+    #              entry has no :one, and pluralize raises
+    #              InvalidPluralizationData. I18nStore rescues that into the
+    #              English fallback, so a fully translated Japanese string
+    #              renders in ENGLISH for every count of 1 — silently.
+    #   fr, es,    have `many`. Upstream never asks for it, so the category the
+    #   pt-BR      locale is required to supply is dead weight.
+    #
+    # RED cannot depend on rails-i18n for real CLDR rules (invariant 7 — no new
+    # runtime dependency), and does not need to: it ships a known, small set of
+    # locales, and the categories each one uses are already declared in
+    # bin/i18n-check. This table is the runtime half of that same statement.
+    #
+    # Only `other` is guaranteed. Every branch falls back to :other when the
+    # category it wants is absent, so a partially-translated entry degrades to
+    # a rendered string rather than to the English fallback.
+    PLURAL_RULES = {
+      # No grammatical number: one form covers every count.
+      "ja" => ->(_count) { :other },
+      "zh-CN" => ->(_count) { :other },
+      # 0 and 1 both take the singular; millions take `many`.
+      "fr" => ->(count) { count.abs < 2 ? :one : :other },
+      # `many` is the CLDR category for large round numbers. RED's strings are
+      # counts of errors and users, so the practical split is one/other; asking
+      # for :many only when the entry actually supplies it keeps a correct
+      # es/pt-BR file working either way.
+      "es" => ->(count) { count == 1 ? :one : :other },
+      "pt-BR" => ->(count) { count.abs < 2 ? :one : :other },
+      # Russian, the first four-category locale. Unlike the Romance rules
+      # above, `other` is NOT the fallback bucket here — CLDR assigns it to
+      # fractional counts only, and every whole number lands in one/few/many.
+      #
+      # The %100 guards are the part that is easy to get wrong: 11 is `many`,
+      # not `one`, and 12-14 are `many`, not `few`, even though 1 and 2-4 are.
+      # A rule written only on %10 renders "11 ошибка" instead of "11 ошибок".
+      "ru" => lambda { |count|
+        return :other unless count.is_a?(Integer)
+
+        i = count.abs
+        mod10 = i % 10
+        mod100 = i % 100
+
+        return :one if mod10 == 1 && mod100 != 11
+        return :few if (2..4).cover?(mod10) && !(12..14).cover?(mod100)
+
+        :many
+      },
+      # Ukrainian takes the SAME integer rule as Russian. That is a fact about
+      # CLDR, not an assumption worth reusing by reference: keeping the lambda
+      # written out means correcting one language never silently moves the
+      # other, and the boundary specs pin both independently.
+      "uk" => lambda { |count|
+        return :other unless count.is_a?(Integer)
+
+        i = count.abs
+        mod10 = i % 10
+        mod100 = i % 100
+
+        return :one if mod10 == 1 && mod100 != 11
+        return :few if (2..4).cover?(mod10) && !(12..14).cover?(mod100)
+
+        :many
+      },
+      # Polish is four-category like ru/uk and DIFFERS from both, which is the
+      # trap this table exists to prevent. Polish `one` is exactly 1 — 21 and
+      # 101 take `many` ("21 bledow"), where ru/uk take `one` ("21 помилка").
+      # Copying the Russian lambda here renders every count ending in 1 above 1
+      # in the wrong form, and no structural check would catch it.
+      "pl" => lambda { |count|
+        return :other unless count.is_a?(Integer)
+
+        i = count.abs
+        mod10 = i % 10
+        mod100 = i % 100
+
+        return :one if i == 1
+        return :few if (2..4).cover?(mod10) && !(12..14).cover?(mod100)
+
+        :many
+      },
+      # Italian matches the other Romance locales: `many` is CLDR's large-round
+      # -number category, so the practical split for counts of errors is
+      # one/other, and :many is asked for only when the entry supplies it.
+      "it" => ->(count) { count == 1 ? :one : :other }
+    }.freeze
+    private_constant :PLURAL_RULES
+
+    # Overrides the hook rather than #pluralize, so upstream's
+    # InvalidPluralizationData guard still fires for an entry that genuinely
+    # lacks the category asked for — a missing form must stay loud, and
+    # I18nStore's rescue must stay a safety net rather than the normal path.
+    #
+    # A locale absent from PLURAL_RULES keeps upstream's English behaviour,
+    # which is the right default: de and en are English-shaped, and an unknown
+    # locale is better served by the documented upstream rule than by a guess.
+    def pluralization_key(entry, count)
+      rule = PLURAL_RULES[@current_pluralization_locale.to_s]
+      return super unless rule
+
+      return :zero if count == 0 && entry.has_key?(:zero)
+
+      key = rule.call(count)
+      entry.has_key?(key) ? key : :other
+    end
+
+    # Upstream calls pluralization_key from #pluralize, which knows the locale;
+    # the hook itself does not receive it. Capture it around the call rather
+    # than reading I18n.locale, which is the HOST's current locale and need not
+    # be the locale this lookup is for (I18nStore always passes locale:
+    # explicitly, and jobs render several locales under one I18n.locale).
+    def pluralize(locale, entry, count)
+      previous = @current_pluralization_locale
+      @current_pluralization_locale = locale
+      super
+    ensure
+      @current_pluralization_locale = previous
+    end
+
+    # Upstream guards its own deep_merge! with a private class-level mutex
+    # (Simple::Implementation::MUTEX). Reaching for that constant would couple
+    # this to an internal name; RED holds its own, which is equivalent because
+    # it guards writes to this backend's own translations hash.
+    STORE_MUTEX = Mutex.new
+    private_constant :STORE_MUTEX
+  end
+end

data/lib/rails_error_dashboard/services/baseline_alert_payload_builder.rb

@@ -30,15 +30,19 @@ module RailsErrorDashboard
       # @param error_log [ErrorLog] The error
       # @param anomaly_data [Hash] Anomaly information
       # @return [Hash] Slack payload
-      def self.slack_payload(error_log, anomaly_data)
+      # @param locale [String] resolved by the enqueueing thread (P4-T1)
+      #
+      # As in SlackPayloadBuilder, the Block Kit "type" values are Slack's
+      # vocabulary and stay English; only the labels and button text move.
+      def self.slack_payload(error_log, anomaly_data, locale: I18nStore::DEFAULT_LOCALE)
         {
-          text: "🚨 Baseline Anomaly Alert",
+          text: NotificationHelpers.t("red.notifications.baseline_alert.fallback", locale),
           blocks: [
             {
               type: "header",
               text: {
                 type: "plain_text",
-                text: "🚨 Baseline Anomaly Detected"
+                text: NotificationHelpers.t("red.notifications.baseline_alert.heading", locale)
               }
             },
             {
@@ -46,23 +50,27 @@ module RailsErrorDashboard
               fields: [
                 {
                   type: "mrkdwn",
-                  text: "*Application:*\n#{NotificationHelpers.app_name(error_log)}"
+                  text: NotificationHelpers.field(:application, NotificationHelpers.app_name(error_log), locale)
                 },
                 {
                   type: "mrkdwn",
-                  text: "*Error Type:*\n#{error_log.error_type}"
+                  text: NotificationHelpers.field(:error_type, error_log.error_type, locale)
                 },
                 {
                   type: "mrkdwn",
-                  text: "*Platform:*\n#{error_log.platform}"
+                  text: NotificationHelpers.field(:platform, error_log.platform, locale)
                 },
                 {
                   type: "mrkdwn",
-                  text: "*Severity:*\n#{anomaly_emoji(anomaly_data[:level])} #{anomaly_data[:level].to_s.upcase}"
+                  text: baseline_field(
+                    :severity,
+                    "#{anomaly_emoji(anomaly_data[:level])} #{anomaly_level(anomaly_data[:level], locale)}",
+                    locale
+                  )
                 },
                 {
                   type: "mrkdwn",
-                  text: "*Standard Deviations:*\n#{anomaly_data[:std_devs_above]&.round(1)}σ above baseline"
+                  text: baseline_field(:std_devs, std_devs_text(anomaly_data, locale), locale)
                 }
               ]
             },
@@ -70,14 +78,22 @@ module RailsErrorDashboard
               type: "section",
               text: {
                 type: "mrkdwn",
-                text: "*Message:*\n```#{NotificationHelpers.truncate_message(error_log.message, 200)}```"
+                # Message content is diagnostic output — never translated.
+                text: NotificationHelpers.field(
+                  :message, "```#{NotificationHelpers.truncate_message(error_log.message, 200)}```", locale
+                )
               }
             },
             {
               type: "section",
               text: {
                 type: "mrkdwn",
-                text: "*Baseline Info:*\nThreshold: #{anomaly_data[:threshold]&.round(1)} errors\nBaseline Type: #{anomaly_data[:baseline_type]}"
+                text: baseline_field(
+                  :baseline_info,
+                  "#{baseline_label(:threshold, locale)}: #{threshold_text(anomaly_data, locale)}\n" \
+                    "#{baseline_label(:baseline_type, locale)}: #{anomaly_data[:baseline_type]}",
+                  locale
+                )
               }
             },
             {
@@ -87,7 +103,7 @@ module RailsErrorDashboard
                   type: "button",
                   text: {
                     type: "plain_text",
-                    text: "View in Dashboard"
+                    text: NotificationHelpers.t("red.notifications.baseline_alert.view_in_dashboard", locale)
                   },
                   url: NotificationHelpers.dashboard_url(error_log)
                 }
@@ -101,21 +117,21 @@ module RailsErrorDashboard
       # @param error_log [ErrorLog] The error
       # @param anomaly_data [Hash] Anomaly information
       # @return [Hash] Discord payload
-      def self.discord_payload(error_log, anomaly_data)
+      def self.discord_payload(error_log, anomaly_data, locale: I18nStore::DEFAULT_LOCALE)
         {
           embeds: [
             {
-              title: "🚨 Baseline Anomaly Detected",
+              title: NotificationHelpers.t("red.notifications.baseline_alert.heading", locale),
               color: anomaly_color(anomaly_data[:level]),
               fields: [
-                { name: "Application", value: NotificationHelpers.app_name(error_log), inline: true },
-                { name: "Error Type", value: error_log.error_type, inline: true },
-                { name: "Platform", value: error_log.platform, inline: true },
-                { name: "Severity", value: anomaly_data[:level].to_s.upcase, inline: true },
-                { name: "Standard Deviations", value: "#{anomaly_data[:std_devs_above]&.round(1)}σ above baseline", inline: true },
-                { name: "Threshold", value: "#{anomaly_data[:threshold]&.round(1)} errors", inline: true },
-                { name: "Baseline Type", value: anomaly_data[:baseline_type] || "N/A", inline: true },
-                { name: "Message", value: "```#{NotificationHelpers.truncate_message(error_log.message, 200)}```", inline: false }
+                { name: NotificationHelpers.label(:application, locale), value: NotificationHelpers.app_name(error_log), inline: true },
+                { name: NotificationHelpers.label(:error_type, locale), value: error_log.error_type, inline: true },
+                { name: NotificationHelpers.label(:platform, locale), value: error_log.platform, inline: true },
+                { name: baseline_label(:severity, locale), value: anomaly_level(anomaly_data[:level], locale), inline: true },
+                { name: baseline_label(:std_devs, locale), value: std_devs_text(anomaly_data, locale), inline: true },
+                { name: baseline_label(:threshold, locale), value: threshold_text(anomaly_data, locale), inline: true },
+                { name: baseline_label(:baseline_type, locale), value: anomaly_data[:baseline_type] || NotificationHelpers.not_available(locale), inline: true },
+                { name: NotificationHelpers.label(:message, locale), value: "```#{NotificationHelpers.truncate_message(error_log.message, 200)}```", inline: false }
               ],
               url: NotificationHelpers.dashboard_url(error_log),
               timestamp: Time.current.iso8601
@@ -128,7 +144,12 @@ module RailsErrorDashboard
       # @param error_log [ErrorLog] The error
       # @param anomaly_data [Hash] Anomaly information
       # @return [Hash] Webhook payload
-      def self.webhook_payload(error_log, anomaly_data)
+      # Machine-readable. Every key AND value here is consumed by whatever the
+      # operator has wired up downstream, so nothing is localized — the locale
+      # is accepted only so the signature matches its siblings (REQ-2, REQ-6).
+      def self.webhook_payload(error_log, anomaly_data, locale: I18nStore::DEFAULT_LOCALE)
+        _locale = locale
+
         {
           event: "baseline_anomaly",
           timestamp: Time.current.iso8601,
@@ -151,6 +172,52 @@ module RailsErrorDashboard
         }
       end
 
+      # A label from red.notifications.baseline_alert.labels. Separate from
+      # NotificationHelpers.label because these are anomaly-specific and do not
+      # appear on an ordinary error alert.
+      def self.baseline_label(label, locale)
+        NotificationHelpers.t("red.notifications.baseline_alert.labels.#{label}", locale)
+      end
+
+      # Slack's bold-label-newline-value shape, for a baseline-only label.
+      def self.baseline_field(label, value, locale)
+        "*#{baseline_label(label, locale)}:*\n#{value}"
+      end
+
+      # Anomaly levels are their own vocabulary — an anomaly can be "elevated",
+      # an error cannot — so they do not reuse red.common.severity. Previously
+      # rendered with .upcase on the raw symbol, which applies English
+      # morphology to a machine value.
+      def self.anomaly_level(level, locale)
+        key = ANOMALY_EMOJIS.key?(level) ? level : :unknown
+        NotificationHelpers.t("red.notifications.baseline_alert.level.#{key}", locale)
+      end
+
+      def self.std_devs_text(anomaly_data, locale)
+        NotificationHelpers.t(
+          "red.notifications.baseline_alert.std_devs_above",
+          locale,
+          value: anomaly_data[:std_devs_above]&.round(1)
+        )
+      end
+
+      # "N errors" was an English binary plural; it is now a real plural key.
+      #
+      # The threshold is a rounded float (e.g. 12.5) but plural selection needs
+      # an Integer, so :count carries the integer and :value the number that is
+      # actually displayed. A locale whose plural rules differ at 1 vs 1.5 is
+      # not a case CLDR expresses, so rounding for selection is correct.
+      def self.threshold_text(anomaly_data, locale)
+        rounded = anomaly_data[:threshold]&.round(1)
+
+        NotificationHelpers.t(
+          "red.notifications.baseline_alert.threshold_errors",
+          locale,
+          count: rounded.to_i,
+          value: rounded
+        )
+      end
+
       # @param level [Symbol] Anomaly level (:critical, :high, :elevated)
       # @return [String] Emoji
       def self.anomaly_emoji(level)

data/lib/rails_error_dashboard/services/digest_builder.rb

@@ -9,26 +9,33 @@ module RailsErrorDashboard
     #   DigestBuilder.call(period: :daily)
     #   # => { period: :daily, stats: { new_errors: 12, ... }, top_errors: [...], ... }
     class DigestBuilder
+      # Labels are keys, not literals: they leak into both the mail subject
+      # and the body, so a translated digest with an English "Last 24 hours"
+      # in its subject line would be obviously half-done (P4-T2 REQ-4).
       PERIODS = {
-        daily: { days: 1, label: "Last 24 hours" },
-        weekly: { days: 7, label: "Last 7 days" }
+        daily: { days: 1, label_key: "red.mailers.digest.periods.daily" },
+        weekly: { days: 7, label_key: "red.mailers.digest.periods.weekly" }
       }.freeze
 
-      def self.call(period: :daily, application_id: nil)
-        new(period: period, application_id: application_id).call
+      def self.call(period: :daily, application_id: nil, locale: I18nStore::DEFAULT_LOCALE)
+        new(period: period, application_id: application_id, locale: locale).call
       end
 
-      def initialize(period: :daily, application_id: nil)
+      # locale is carried from the enqueue site (P4-T1) and is what
+      # #period_label resolves against. Never Current: a digest is built inside
+      # a job, where Current is nil or belongs to an unrelated request.
+      def initialize(period: :daily, application_id: nil, locale: I18nStore::DEFAULT_LOCALE)
         @period = PERIODS.key?(period) ? period : :daily
         @days = PERIODS[@period][:days]
         @application_id = application_id
+        @locale = locale
         @start_date = @days.days.ago
       end
 
       def call
         {
           period: @period,
-          period_label: PERIODS[@period][:label],
+          period_label: period_label,
           generated_at: Time.current,
           stats: build_stats,
           top_errors: top_errors,
@@ -42,6 +49,13 @@ module RailsErrorDashboard
 
       private
 
+      # Resolved with the locale carried from the enqueue site (P4-T1), not
+      # from Current — a digest is built inside a job, where Current is nil or
+      # belongs to an unrelated request.
+      def period_label
+        I18nStore.translate(PERIODS[@period][:label_key], locale: @locale)
+      end
+
       def base_scope
         scope = ErrorLog.where("occurred_at >= ?", @start_date)
         scope = scope.where(application_id: @application_id) if @application_id.present?
@@ -145,7 +159,7 @@ module RailsErrorDashboard
       def empty_result
         {
           period: @period,
-          period_label: PERIODS.dig(@period, :label) || "Unknown",
+          period_label: period_label,
           generated_at: Time.current,
           stats: { new_errors: 0, total_occurrences: 0, resolved: 0, unresolved: 0, critical_high: 0, resolution_rate: 0 },
           top_errors: [],

data/lib/rails_error_dashboard/services/discord_payload_builder.rb

@@ -18,52 +18,64 @@ module RailsErrorDashboard
       DEFAULT_COLOR = 8421504 # Gray
 
       # @param error_log [ErrorLog] The error to build a payload for
+      # @param locale [String] resolved by the enqueueing thread (P4-T1)
       # @return [Hash] Discord embed payload
-      def self.call(error_log)
+      #
+      # Field *names* are human-readable and localized; "inline", "color" and
+      # "timestamp" are Discord embed schema and stay as they are. The footer
+      # is the product name, which is not translated.
+      def self.call(error_log, locale: I18nStore::DEFAULT_LOCALE)
+        unknown = NotificationHelpers.unknown(locale)
+        not_available = NotificationHelpers.not_available(locale)
+
         {
           embeds: [ {
-            title: "🚨 New Error: #{error_log.error_type}",
+            # error_type is an exception class name — verbatim.
+            title: NotificationHelpers.t(
+              "red.notifications.error_alert.discord_title", locale, error_type: error_log.error_type
+            ),
             description: NotificationHelpers.truncate_message(error_log.message, 200),
             color: severity_color(error_log),
             fields: [
               {
-                name: "Application",
+                name: NotificationHelpers.label(:application, locale),
                 value: NotificationHelpers.app_name(error_log),
                 inline: true
               },
               {
-                name: "Platform",
-                value: error_log.platform || "Unknown",
+                name: NotificationHelpers.label(:platform, locale),
+                value: error_log.platform || unknown,
                 inline: true
               },
               {
-                name: "Occurrences",
+                name: NotificationHelpers.label(:occurrences, locale),
                 value: error_log.occurrence_count.to_s,
                 inline: true
               },
               {
-                name: "Controller",
-                value: error_log.controller_name || "N/A",
+                name: NotificationHelpers.label(:controller, locale),
+                value: error_log.controller_name || not_available,
                 inline: true
               },
               {
-                name: "Action",
-                value: error_log.action_name || "N/A",
+                name: NotificationHelpers.label(:action, locale),
+                value: error_log.action_name || not_available,
                 inline: true
               },
               {
-                name: "First Seen",
-                value: NotificationHelpers.format_time(error_log.first_seen_at),
+                name: NotificationHelpers.label(:first_seen, locale),
+                value: NotificationHelpers.format_datetime_or_na(error_log.first_seen_at, locale),
                 inline: true
               },
               {
-                name: "Location",
-                value: NotificationHelpers.extract_first_backtrace_line(error_log.backtrace),
+                # Backtrace content is diagnostic output — never translated.
+                name: NotificationHelpers.label(:location, locale),
+                value: NotificationHelpers.extract_first_backtrace_line(error_log.backtrace, locale: locale),
                 inline: false
               }
             ],
             footer: {
-              text: "Rails Error Dashboard"
+              text: NotificationHelpers.t("red.notifications.shared.product_name", locale)
             },
             timestamp: error_log.occurred_at.iso8601
           } ]

data/lib/rails_error_dashboard/services/error_notification_dispatcher.rb

@@ -25,28 +25,33 @@ module RailsErrorDashboard
           config = RailsErrorDashboard.configuration
           fired = []
 
+          # Resolved once, here, in the enqueueing thread. Jobs must not
+          # resolve it themselves — they run without a request, possibly on a
+          # thread another request left state on. See Concerns::LocalizedJob.
+          locale = ApplicationJob.enqueue_locale
+
           if config.enable_slack_notifications && config.slack_webhook_url.present?
-            SlackErrorNotificationJob.perform_later(error_log.id)
+            SlackErrorNotificationJob.perform_later(error_log.id, locale)
             fired << "slack"
           end
 
           if config.enable_email_notifications && config.notification_email_recipients.present?
-            EmailErrorNotificationJob.perform_later(error_log.id)
+            EmailErrorNotificationJob.perform_later(error_log.id, locale)
             fired << "email"
           end
 
           if config.enable_discord_notifications && config.discord_webhook_url.present?
-            DiscordErrorNotificationJob.perform_later(error_log.id)
+            DiscordErrorNotificationJob.perform_later(error_log.id, locale)
             fired << "discord"
           end
 
           if config.enable_pagerduty_notifications && config.pagerduty_integration_key.present?
-            PagerdutyErrorNotificationJob.perform_later(error_log.id)
+            PagerdutyErrorNotificationJob.perform_later(error_log.id, locale)
             fired << "pagerduty"
           end
 
           if config.enable_webhook_notifications && config.webhook_urls.present?
-            WebhookErrorNotificationJob.perform_later(error_log.id)
+            WebhookErrorNotificationJob.perform_later(error_log.id, locale)
             fired << "webhook"
           end