rails_error_dashboard 0.8.3 → 0.9.0

data/app/jobs/rails_error_dashboard/concerns/localized_job.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Concerns
+    # Gives a job an explicit, serialized locale instead of an inherited one.
+    #
+    # WHY JOBS CANNOT JUST READ Current.locale
+    #
+    # Mailers and notification jobs render outside the dashboard's
+    # around_action. There is no request, so there is no request locale.
+    # Reading Current.locale in a job returns nil at best — and at worst, on a
+    # reused Puma or job-runner thread, whatever an unrelated request left
+    # behind. That is the same bug class as #143 and #148: state outliving the
+    # request that set it.
+    #
+    # So the locale is resolved at ENQUEUE time (see .enqueue_locale) and
+    # travels in the job's arguments. The job then reads only its own argument.
+    #
+    # WHY ENQUEUE TIME RESOLVES TO CONFIG, NOT TO A USER
+    #
+    # Notifications are enqueued from the capture path — log_error, the storm
+    # gate — which runs inside a *host app* request, not a dashboard one. There
+    # is no dashboard user in scope and Current.locale is correctly nil there.
+    # The meaningful answer is config.dashboard_locale, which is what
+    # Current.locale_or_default returns when Current.locale is unset. Resolving
+    # through that one path keeps a single precedence chain for the whole gem
+    # and lets a dashboard-initiated enqueue (a future "send test notification"
+    # button) pick up the acting user's locale for free.
+    #
+    # BACKWARD COMPATIBILITY IS NOT OPTIONAL HERE
+    #
+    # Queues drain across a deploy. Jobs enqueued by the previous version have
+    # no locale argument at all, and they must still run — a notification is
+    # never worth losing over a translation detail. Every consumer therefore
+    # defaults the argument, and #job_locale hardens whatever arrives.
+    module LocalizedJob
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # The locale to serialize into a job's arguments, resolved in the
+        # enqueueing thread while its context is still valid.
+        #
+        # Returns a String, never a Symbol: ActiveJob serializes Symbols
+        # inconsistently across adapters, and Sidekiq's JSON round-trip turns
+        # one into a String anyway. Being explicit avoids a locale that is a
+        # Symbol on the inline adapter and a String in production.
+        #
+        # @return [String] a locale RED ships. Never nil, never raises.
+        def enqueue_locale
+          Current.locale_or_default
+        rescue StandardError
+          I18nStore::DEFAULT_LOCALE
+        end
+      end
+
+      private
+
+      # The locale this job should render in, from its own argument.
+      #
+      # Total by design. A nil (pre-upgrade payload), a garbage string, a
+      # Symbol, or a locale RED does not ship all degrade to
+      # config.dashboard_locale and then to English. REQ-4: a notification must
+      # never be lost because of a locale problem.
+      #
+      # @param value [Object] whatever arrived in the job arguments
+      # @return [String] a locale RED ships
+      def job_locale(value)
+        candidate = value.to_s.strip
+        return Current.locale_or_default if candidate.empty?
+
+        # resolve/1 already degrades an unknown tag to English, but an unknown
+        # tag should first get a chance at the configured locale — a queued job
+        # carrying a stale tag is closer to "no opinion" than to "wants
+        # English".
+        return I18nStore.resolve(candidate) if I18nStore.available?(candidate)
+
+        Current.locale_or_default
+      rescue StandardError
+        I18nStore::DEFAULT_LOCALE
+      end
+    end
+  end
+end

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