rails_error_dashboard 0.8.4 → 0.9.1

data/app/jobs/rails_error_dashboard/discord_error_notification_job.rb

@@ -5,13 +5,15 @@ module RailsErrorDashboard
   class DiscordErrorNotificationJob < ApplicationJob
     queue_as :default
 
-    def perform(error_log_id)
+    # @param locale [String, nil] resolved at enqueue time. nil for jobs
+    #   enqueued by a pre-Phase-4 version still draining from the queue.
+    def perform(error_log_id, locale = nil)
       error_log = ErrorLog.find(error_log_id)
       webhook_url = RailsErrorDashboard.configuration.discord_webhook_url
 
       return unless webhook_url.present?
 
-      payload = Services::DiscordPayloadBuilder.call(error_log)
+      payload = Services::DiscordPayloadBuilder.call(error_log, locale: job_locale(locale))
       post_json(webhook_url, payload)
     rescue StandardError => e
       Rails.logger.error("[RailsErrorDashboard] Failed to send Discord notification: #{e.message}")

data/app/jobs/rails_error_dashboard/email_error_notification_job.rb

@@ -4,14 +4,16 @@ module RailsErrorDashboard
   class EmailErrorNotificationJob < ApplicationJob
     queue_as :error_notifications
 
-    def perform(error_log_id)
+    # @param locale [String, nil] resolved at enqueue time. nil for jobs
+    #   enqueued by a pre-Phase-4 version still draining from the queue.
+    def perform(error_log_id, locale = nil)
       error_log = ErrorLog.find_by(id: error_log_id)
       return unless error_log
 
       recipients = RailsErrorDashboard.configuration.notification_email_recipients
       return unless recipients.present?
 
-      ErrorNotificationMailer.error_alert(error_log, recipients).deliver_now
+      ErrorNotificationMailer.error_alert(error_log, recipients, locale: job_locale(locale)).deliver_now
     rescue => e
       Rails.logger.error("[RailsErrorDashboard] Failed to send email notification: #{e.message}")
       Rails.logger.error(e.backtrace&.first(5)&.join("\n")) if e.backtrace

data/app/jobs/rails_error_dashboard/pagerduty_error_notification_job.rb

@@ -8,7 +8,9 @@ module RailsErrorDashboard
 
     PAGERDUTY_EVENTS_API = "https://events.pagerduty.com/v2/enqueue"
 
-    def perform(error_log_id)
+    # @param locale [String, nil] resolved at enqueue time. nil for jobs
+    #   enqueued by a pre-Phase-4 version still draining from the queue.
+    def perform(error_log_id, locale = nil)
       error_log = ErrorLog.find(error_log_id)
 
       # Only trigger PagerDuty for critical errors
@@ -17,7 +19,9 @@ module RailsErrorDashboard
       routing_key = RailsErrorDashboard.configuration.pagerduty_integration_key
       return unless routing_key.present?
 
-      payload = Services::PagerdutyPayloadBuilder.call(error_log, routing_key: routing_key)
+      payload = Services::PagerdutyPayloadBuilder.call(
+        error_log, routing_key: routing_key, locale: job_locale(locale)
+      )
       response = post_json(PAGERDUTY_EVENTS_API, payload)
 
       unless response_success?(response)

data/app/jobs/rails_error_dashboard/scheduled_digest_job.rb

@@ -12,18 +12,23 @@ module RailsErrorDashboard
   class ScheduledDigestJob < ApplicationJob
     queue_as :default
 
-    def perform(period: "daily", application_id: nil)
+    # @param locale [String, nil] resolved at enqueue time. nil for jobs
+    #   enqueued by a pre-Phase-4 version still draining from the queue.
+    def perform(period: "daily", application_id: nil, locale: nil)
       return unless RailsErrorDashboard.configuration.enable_scheduled_digests
 
       recipients = effective_recipients
       return if recipients.blank?
 
+      resolved_locale = job_locale(locale)
+
       digest = Services::DigestBuilder.call(
         period: period.to_sym,
-        application_id: application_id
+        application_id: application_id,
+        locale: resolved_locale
       )
 
-      DigestMailer.digest_summary(digest, recipients).deliver_now
+      DigestMailer.digest_summary(digest, recipients, locale: resolved_locale).deliver_now
     rescue => e
       Rails.logger.error("[RailsErrorDashboard] ScheduledDigestJob failed: #{e.class}: #{e.message}")
     end

data/app/jobs/rails_error_dashboard/slack_error_notification_job.rb

@@ -4,21 +4,23 @@ module RailsErrorDashboard
   class SlackErrorNotificationJob < ApplicationJob
     queue_as :error_notifications
 
-    def perform(error_log_id)
+    # @param locale [String, nil] resolved at enqueue time. nil for jobs
+    #   enqueued by a pre-Phase-4 version still draining from the queue.
+    def perform(error_log_id, locale = nil)
       error_log = ErrorLog.find_by(id: error_log_id)
       return unless error_log
 
       webhook_url = RailsErrorDashboard.configuration.slack_webhook_url
       return unless webhook_url.present?
 
-      send_slack_notification(error_log, webhook_url)
+      send_slack_notification(error_log, webhook_url, job_locale(locale))
     rescue => e
       Rails.logger.error("Failed to send Slack notification: #{e.message}")
     end
 
     private
 
-    def send_slack_notification(error_log, webhook_url)
+    def send_slack_notification(error_log, webhook_url, locale)
       require "net/http"
       require "json"
 
@@ -31,7 +33,7 @@ module RailsErrorDashboard
       http.read_timeout = 10  # 10 seconds to read response
 
       request = Net::HTTP::Post.new(uri.path, { "Content-Type" => "application/json" })
-      request.body = Services::SlackPayloadBuilder.call(error_log).to_json
+      request.body = Services::SlackPayloadBuilder.call(error_log, locale: locale).to_json
 
       response = http.request(request)
 

data/app/jobs/rails_error_dashboard/storm_notification_job.rb

@@ -11,9 +11,11 @@ module RailsErrorDashboard
 
     # @param started_at [String] ISO8601 episode start
     # @param state [String] breaker state at notification time ("shedding"/"open")
-    def perform(started_at:, state: "shedding")
+    # @param locale [String, nil] resolved at enqueue time. nil for jobs
+    #   enqueued by a pre-Phase-4 version still draining from the queue.
+    def perform(started_at:, state: "shedding", locale: nil)
       config = RailsErrorDashboard.configuration
-      message = build_message(started_at, state, config)
+      message = build_message(started_at, state, config, job_locale(locale))
 
       if config.enable_slack_notifications && config.slack_webhook_url.present?
         post_json(config.slack_webhook_url, { text: message })
@@ -38,14 +40,30 @@ module RailsErrorDashboard
 
     private
 
-    def build_message(started_at, state, config)
-      mode = state == "open" ? "count-only mode (occurrences tallied, detail paused)" : "shedding mode (context sampling active)"
+    # Assembled from four keys rather than one, because the dashboard link is
+    # conditional. Each key is a whole sentence — never a fragment joined to
+    # another, which would bake English word order into every translation.
+    #
+    # ":warning:" is Slack/Discord emoji shortcode, not text.
+    def build_message(started_at, state, config, locale)
+      mode_key = state == "open" ? "open" : "shedding"
+      mode = t("red.notifications.storm.mode.#{mode_key}", locale)
+
       dashboard = (config.dashboard_base_url || "").chomp("/")
-      link = dashboard.present? ? " Dashboard: #{dashboard}/errors/storms" : ""
+      link = if dashboard.present?
+        " " + t("red.notifications.storm.dashboard", locale, url: "#{dashboard}/errors/storms")
+      else
+        ""
+      end
+
+      ":warning: " \
+        "#{t("red.notifications.storm.detected", locale, application: app_name(config), started_at: started_at)} " \
+        "#{t("red.notifications.storm.engaged", locale, mode: mode)} " \
+        "#{t("red.notifications.storm.suppressed", locale)}#{link}"
+    end
 
-      ":warning: Error storm detected in #{app_name(config)} at #{started_at}. " \
-        "Storm protection engaged — #{mode}. Per-error notifications are " \
-        "suppressed until the storm subsides; exact counts are preserved.#{link}"
+    def t(key, locale, **options)
+      RailsErrorDashboard::I18nStore.translate(key, locale: locale, **options)
     end
 
     def app_name(config)

data/app/jobs/rails_error_dashboard/webhook_error_notification_job.rb

@@ -6,7 +6,9 @@ module RailsErrorDashboard
   class WebhookErrorNotificationJob < ApplicationJob
     queue_as :default
 
-    def perform(error_log_id)
+    # @param locale [String, nil] resolved at enqueue time. nil for jobs
+    #   enqueued by a pre-Phase-4 version still draining from the queue.
+    def perform(error_log_id, locale = nil)
       error_log = ErrorLog.find(error_log_id)
       webhook_urls = RailsErrorDashboard.configuration.webhook_urls
 
@@ -15,7 +17,7 @@ module RailsErrorDashboard
       # Ensure webhook_urls is an array
       urls = Array(webhook_urls)
 
-      payload = Services::WebhookPayloadBuilder.call(error_log)
+      payload = Services::WebhookPayloadBuilder.call(error_log, locale: job_locale(locale))
 
       urls.each do |url|
         send_webhook(url, payload, error_log)

data/app/mailers/rails_error_dashboard/application_mailer.rb

@@ -4,5 +4,19 @@ module RailsErrorDashboard
   class ApplicationMailer < ActionMailer::Base
     default from: -> { RailsErrorDashboard.configuration.notification_email_from }
     layout false
+
+    # Mailers do not pick up engine helpers the way controllers do, so these
+    # are included explicitly.
+    #
+    # I18nHelper gives the .html.erb parts red_t; MailerI18nHelper adds
+    # red_mail_t (unescaped, for the .text.erb parts) and red_mail_time (a
+    # localized timestamp that needs no JavaScript).
+    #
+    # The locale arrives as an explicit argument and is assigned to
+    # @red_locale, which I18nHelper#red_locale prefers over Current — a mailer
+    # renders outside the request that set Current, and on a reused thread
+    # Current holds an unrelated request's value (P4-T1).
+    helper RailsErrorDashboard::I18nHelper
+    helper RailsErrorDashboard::MailerI18nHelper
   end
 end

data/app/mailers/rails_error_dashboard/digest_mailer.rb

@@ -2,18 +2,34 @@
 
 module RailsErrorDashboard
   class DigestMailer < ApplicationMailer
-    def digest_summary(digest, recipients)
+    # @param locale [String] resolved at enqueue time, never read from
+    #   Current — a mailer renders outside the request that set it.
+    def digest_summary(digest, recipients, locale: I18nStore::DEFAULT_LOCALE)
       @digest = digest
       @dashboard_url = dashboard_base_url
+      @red_locale = locale
 
       mail(
         to: recipients,
-        subject: "RED Digest — #{digest[:stats][:new_errors]} new errors (#{digest[:period_label]})"
+        subject: subject_for(digest, locale)
       )
     end
 
     private
 
+    # "N new errors" was an English binary plural built by interpolation. It is
+    # now a real plural key, selected by the locale's CLDR rules (REQ-1).
+    def subject_for(digest, locale)
+      count = digest[:stats][:new_errors].to_i
+
+      I18nStore.translate(
+        "red.mailers.digest.subject",
+        locale: locale,
+        count: count,
+        period: digest[:period_label]
+      )
+    end
+
     def dashboard_base_url
       base = RailsErrorDashboard.configuration.dashboard_base_url || "http://localhost:3000"
       mount_path = RailsErrorDashboard.configuration.engine_mount_path

data/app/mailers/rails_error_dashboard/error_notification_mailer.rb

@@ -2,18 +2,35 @@
 
 module RailsErrorDashboard
   class ErrorNotificationMailer < ApplicationMailer
-    def error_alert(error_log, recipients)
+    # @param locale [String] resolved at enqueue time, never read from
+    #   Current — a mailer renders outside the request that set it.
+    def error_alert(error_log, recipients, locale: I18nStore::DEFAULT_LOCALE)
       @error_log = error_log
       @dashboard_url = dashboard_url(error_log)
+      @red_locale = locale
 
       mail(
         to: recipients,
-        subject: "🚨 [#{error_log.application&.name || 'Unknown'}] #{error_log.error_type}: #{truncate_subject(error_log.message)}"
+        subject: subject_for(error_log, locale)
       )
     end
 
     private
 
+    # The subject is assembled from a key rather than interpolated inline, so a
+    # locale can reorder or drop the emoji. error_type and message are verbatim
+    # error content and are never translated.
+    def subject_for(error_log, locale)
+      I18nStore.translate(
+        "red.mailers.error_alert.subject",
+        locale: locale,
+        application: error_log.application&.name ||
+          I18nStore.translate("red.mailers.shared.unknown_application", locale: locale),
+        error_type: error_log.error_type,
+        message: truncate_subject(error_log.message)
+      )
+    end
+
     def dashboard_url(error_log)
       base_url = RailsErrorDashboard.configuration.dashboard_base_url || "http://localhost:3000"
       mount_path = RailsErrorDashboard.configuration.engine_mount_path