rails_error_dashboard 0.8.3 → 0.9.0

data/lib/rails_error_dashboard/services/localized_time_formatter.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # strftime with the word-producing directives resolved from RED's own
+    # dictionary.
+    #
+    # WHY THIS EXISTS
+    #
+    # Ruby's strftime is not locale-aware: %B is "August" whatever RED's locale
+    # is. On the dashboard that does not matter, because a timestamp is
+    # rendered as a <span data-format> and the browser re-renders it through
+    # formatDateTime() using the red.js.* month/day/meridian vocabulary P3-T2
+    # added. Anywhere there is no browser — email (P4-T2), Slack and Discord
+    # payloads (P4-T3) — the server has to do that substitution itself.
+    #
+    # Sharing one implementation is the point: an email, a Slack message and
+    # the dashboard should not disagree about what a date looks like.
+    #
+    # Takes the locale as an argument rather than reading Current, because
+    # every caller runs inside a job where Current is nil or belongs to an
+    # unrelated request.
+    class LocalizedTimeFormatter
+      # The directives whose output is a *word*, and therefore locale-dependent:
+      # %B %b (month), %A %a (weekday), %p %P (meridian). Everything else
+      # (%Y, %m, %d, %H, %M, %S, %Z …) is digits or a timezone abbreviation and
+      # is left to strftime.
+      LOCALIZED_DIRECTIVES = /%[BbAaPp]/
+
+      # Stand-in for a localized word while strftime runs. Contains no percent,
+      # so strftime cannot read it as a directive, and no space, so it cannot
+      # alter the spacing the pattern asked for. The index keeps two
+      # occurrences of the same directive independent.
+      PLACEHOLDER = "\u0000RED%<index>d\u0000"
+
+      # @param time [Time]
+      # @param pattern [String] a strftime pattern
+      # @param locale [String]
+      # @return [String]
+      def self.call(time, pattern:, locale:)
+        new(locale).render(time, pattern)
+      end
+
+      def initialize(locale)
+        @locale = locale
+      end
+
+      # Two-pass, via placeholders: substituting a translated month name
+      # directly would put arbitrary text into the pattern, and while a French
+      # "%A" -> "mardi" is harmless, a translation containing a literal percent
+      # sign would corrupt every directive after it. The placeholder carries no
+      # percent, so strftime cannot misread it.
+      def render(time, pattern)
+        replacements = []
+
+        staged = pattern.gsub(LOCALIZED_DIRECTIVES) do |directive|
+          word = localized_word(directive, time)
+          next directive if word.nil?
+
+          replacements << word
+          format(PLACEHOLDER, index: replacements.length - 1)
+        end
+
+        rendered = time.strftime(staged)
+
+        replacements.each_with_index do |word, index|
+          rendered = rendered.sub(format(PLACEHOLDER, index: index), word)
+        end
+
+        rendered
+      end
+
+      private
+
+      attr_reader :locale
+
+      # @return [String, nil] nil means "leave it to strftime"
+      def localized_word(directive, time)
+        case directive
+        when "%B" then name_array(:months, 12)[time.month - 1]
+        when "%b" then name_array(:months_short, 12)[time.month - 1]
+        when "%A" then name_array(:days, 7)[time.wday]
+        when "%a" then name_array(:days_short, 7)[time.wday]
+        when "%p" then meridian_for(time)
+        when "%P" then meridian_for(time)&.downcase
+        end
+      end
+
+      # I18nStore.subtree returns SYMBOL keys — the backend loads the YAML
+      # symbolized. Indexing with a String silently yields nil here, and
+      # because a nil array falls back to English the bug looks exactly like
+      # "this locale has no translation" rather than like a defect. Caught in
+      # P4-T2 by a spec that asserted a translated month name and got English.
+      #
+      # A locale that translates only some of these must not produce a mix of
+      # translated and English names, so the whole array falls back together —
+      # the same rule I18nStore.subtree applies for the JS payload.
+      def name_array(key, expected_length)
+        names = I18nStore.subtree("red.js", locale: locale)[key]
+        return names if names.is_a?(Array) && names.length == expected_length
+
+        fallback = I18nStore.subtree("red.js", locale: I18nStore::DEFAULT_LOCALE)[key]
+        fallback.is_a?(Array) ? fallback : []
+      end
+
+      # A 24-hour locale may legitimately translate these to "", which is why
+      # this checks for a String rather than for presence.
+      def meridian_for(time)
+        meridian = I18nStore.subtree("red.js.meridian", locale: locale)
+        value = time.hour >= 12 ? meridian[:pm] : meridian[:am]
+        return value if value.is_a?(String)
+
+        time.hour >= 12 ? "PM" : "AM"
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/notification_helpers.rb

@@ -9,6 +9,81 @@ module RailsErrorDashboard
     module NotificationHelpers
       module_function
 
+      # Translate for a notification payload.
+      #
+      # Positional locale rather than the ambient one: a payload is built
+      # inside a job, where Current.locale is nil at best and an unrelated
+      # request's value at worst (P4-T1). Every builder threads the locale it
+      # was handed.
+      #
+      # No escaping — these values go into JSON, not HTML.
+      #
+      # @return [String] never nil, never raises
+      def t(key, locale, **options)
+        I18nStore.translate(key, locale: locale, **options)
+      end
+
+      # A "*Label:*\nvalue" Slack mrkdwn field.
+      #
+      # The bold-label-newline-value shape is Slack markup, not language, so it
+      # stays here rather than being baked into each translation — a translator
+      # editing "*%{label}:*" could break the formatting for every field at
+      # once. Only the label itself is translated.
+      #
+      # @param label [Symbol] a key under red.notifications.error_alert.labels
+      def field(label, value, locale)
+        "*#{t("red.notifications.error_alert.labels.#{label}", locale)}:*\n#{value}"
+      end
+
+      # One label from red.notifications.error_alert.labels.
+      #
+      # Discord wants a bare field name, Slack wants it wrapped in its mrkdwn
+      # bold-and-newline shape — hence this and #field rather than one method.
+      #
+      # @param label [Symbol]
+      def label(label, locale)
+        t("red.notifications.error_alert.labels.#{label}", locale)
+      end
+
+      # @return [String] the localized "Unknown" placeholder
+      def unknown(locale)
+        t("red.notifications.shared.unknown", locale)
+      end
+
+      # @return [String] the localized "N/A" placeholder
+      def not_available(locale)
+        t("red.notifications.shared.not_available", locale)
+      end
+
+      # A human-readable timestamp for a notification body.
+      #
+      # Uses the locale's date format and month names rather than strftime's,
+      # which are always English (see MailerI18nHelper for the same problem).
+      # Falls back to the machine format if anything goes wrong — a wrong-looking
+      # timestamp is better than a lost notification.
+      #
+      # @return [String] "" for nil
+      def format_datetime(time, locale)
+        return "" if time.nil?
+
+        utc = time.respond_to?(:utc) ? time.utc : time
+        pattern = I18nStore.translate("red.time.formats.full", locale: locale)
+        # A miss returns humanized key text, which would be a nonsense strftime
+        # pattern. Detect it the same way red_time_format does.
+        pattern = I18nStore.translate("red.time.formats.full", locale: I18nStore::DEFAULT_LOCALE) unless pattern.include?("%")
+
+        LocalizedTimeFormatter.call(utc, pattern: pattern, locale: locale)
+      rescue StandardError
+        format_time(time)
+      end
+
+      # A localized timestamp, or the localized "N/A" for nil.
+      def format_datetime_or_na(time, locale)
+        return not_available(locale) if time.nil?
+
+        format_datetime(time, locale)
+      end
+
       # Generate dashboard URL for an error
       # @param error_log [ErrorLog] The error
       # @return [String] Full URL to the error detail page
@@ -46,16 +121,24 @@ module RailsErrorDashboard
       end
 
       # Extract first backtrace line (truncated)
+      #
+      # The line itself is diagnostic output and is never translated — only the
+      # "N/A" shown in its absence is, and only when a locale is supplied.
+      # Callers that pass no locale keep the literal, so existing non-i18n
+      # callers are unaffected.
+      #
       # @param backtrace [String, Array, nil] Raw backtrace
       # @param length [Integer] Maximum length (default 100)
-      # @return [String] First line or "N/A"
-      def extract_first_backtrace_line(backtrace, length = 100)
-        return "N/A" if backtrace.nil?
+      # @param locale [String, nil] locale for the placeholder
+      # @return [String] First line, or the "N/A" placeholder
+      def extract_first_backtrace_line(backtrace, length = 100, locale: nil)
+        placeholder = locale ? not_available(locale) : "N/A"
+        return placeholder if backtrace.nil?
 
         lines = backtrace.is_a?(String) ? backtrace.lines : backtrace
         first_line = lines.first&.strip
 
-        return "N/A" if first_line.nil?
+        return placeholder if first_line.nil?
         first_line.length > length ? "#{first_line[0...length]}..." : first_line
       end
 

data/lib/rails_error_dashboard/services/pagerduty_payload_builder.rb

@@ -12,16 +12,32 @@ module RailsErrorDashboard
     class PagerdutyPayloadBuilder
       # @param error_log [ErrorLog] The error to build a payload for
       # @param routing_key [String] PagerDuty integration key
+      # @param locale [String] resolved by the enqueueing thread (P4-T1)
       # @return [Hash] PagerDuty Events API v2 payload
-      def self.call(error_log, routing_key:)
+      #
+      # ONLY "summary" AND THE LINK TEXT ARE LOCALIZED.
+      #
+      # event_action ("trigger") and severity ("critical") are PagerDuty API
+      # enums, not adjectives — PagerDuty rejects any other value, so a
+      # translated "critical" would drop the incident rather than localize it.
+      # The custom_details keys are consumed by whatever the operator has wired
+      # downstream, and "client" is RED's product name.
+      def self.call(error_log, routing_key:, locale: I18nStore::DEFAULT_LOCALE)
         {
           routing_key: routing_key,
           event_action: "trigger",
           payload: {
-            summary: "[#{NotificationHelpers.app_name(error_log)}] Critical Error: #{error_log.error_type} in #{error_log.platform}",
+            summary: NotificationHelpers.t(
+              "red.notifications.error_alert.pagerduty_summary",
+              locale,
+              application: NotificationHelpers.app_name(error_log),
+              error_type: error_log.error_type,
+              platform: error_log.platform
+            ),
+            # API enum, not an adjective. Never translated.
             severity: "critical",
             source: NotificationHelpers.error_source(error_log),
-            component: error_log.controller_name || "Unknown",
+            component: error_log.controller_name || NotificationHelpers.unknown(locale),
             group: error_log.error_type,
             class: error_log.error_type,
             custom_details: {
@@ -41,10 +57,11 @@ module RailsErrorDashboard
           links: [
             {
               href: NotificationHelpers.dashboard_url(error_log),
-              text: "View in Error Dashboard"
+              text: NotificationHelpers.t("red.notifications.error_alert.view_in_dashboard", locale)
             }
           ],
-          client: "Rails Error Dashboard",
+          # Product name — not translated.
+          client: NotificationHelpers.t("red.notifications.shared.product_name", locale),
           client_url: NotificationHelpers.dashboard_url(error_log)
         }
       end

data/lib/rails_error_dashboard/services/slack_payload_builder.rb

@@ -11,100 +11,120 @@ module RailsErrorDashboard
     #   # => { text: "...", blocks: [...] }
     class SlackPayloadBuilder
       # @param error_log [ErrorLog] The error to build a payload for
+      # @param locale [String] resolved by the enqueueing thread (P4-T1)
       # @return [Hash] Slack Block Kit payload
-      def self.call(error_log)
+      #
+      # Only the human-readable *values* are localized. Every "type" and
+      # "style" below is Slack Block Kit vocabulary that Slack parses —
+      # translating one would produce an invalid payload, not a localized one.
+      def self.call(error_log, locale: I18nStore::DEFAULT_LOCALE)
         {
-          text: "🚨 New Error Alert",
+          text: NotificationHelpers.t("red.notifications.error_alert.fallback", locale),
           blocks: [
-            header_block,
-            fields_block(error_log),
-            message_block(error_log),
-            user_block(error_log),
-            request_block(error_log),
-            actions_block(error_log),
-            context_block(error_log)
+            header_block(locale),
+            fields_block(error_log, locale),
+            message_block(error_log, locale),
+            user_block(error_log, locale),
+            request_block(error_log, locale),
+            actions_block(error_log, locale),
+            context_block(error_log, locale)
           ].compact
         }
       end
 
-      def self.header_block
+      def self.header_block(locale)
         {
           type: "header",
           text: {
             type: "plain_text",
-            text: "🚨 Error Alert",
+            text: NotificationHelpers.t("red.notifications.error_alert.heading", locale),
             emoji: true
           }
         }
       end
 
-      def self.fields_block(error_log)
+      def self.fields_block(error_log, locale)
         {
           type: "section",
           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#{NotificationHelpers.platform_emoji(error_log.platform)} #{error_log.platform || 'Unknown'}"
+              text: NotificationHelpers.field(
+                :platform,
+                "#{NotificationHelpers.platform_emoji(error_log.platform)} " \
+                  "#{error_log.platform || NotificationHelpers.unknown(locale)}",
+                locale
+              )
             },
             {
               type: "mrkdwn",
-              text: "*Occurred:*\n#{error_log.occurred_at.strftime('%B %d, %Y at %I:%M %p')}"
+              text: NotificationHelpers.field(
+                :occurred, NotificationHelpers.format_datetime(error_log.occurred_at, locale), locale
+              )
             }
           ]
         }
       end
 
-      def self.message_block(error_log)
+      def self.message_block(error_log, locale)
         {
           type: "section",
           text: {
             type: "mrkdwn",
-            text: "*Message:*\n```#{NotificationHelpers.truncate_message(error_log.message)}```"
+            # Message content is diagnostic output and is never translated.
+            text: NotificationHelpers.field(
+              :message, "```#{NotificationHelpers.truncate_message(error_log.message)}```", locale
+            )
           }
         }
       end
 
-      def self.user_block(error_log)
+      def self.user_block(error_log, locale)
         return nil unless error_log.user_id.present?
 
-        user_email = error_log.user&.email || "User ##{error_log.user_id}"
+        user_email = error_log.user&.email ||
+          NotificationHelpers.t("red.notifications.error_alert.user_fallback", locale, id: error_log.user_id)
 
         {
           type: "section",
           fields: [
             {
               type: "mrkdwn",
-              text: "*User:*\n#{user_email}"
+              text: NotificationHelpers.field(:user, user_email, locale)
             },
             {
               type: "mrkdwn",
-              text: "*IP Address:*\n#{error_log.ip_address || 'N/A'}"
+              text: NotificationHelpers.field(
+                :ip_address, error_log.ip_address || NotificationHelpers.not_available(locale), locale
+              )
             }
           ]
         }
       end
 
-      def self.request_block(error_log)
+      def self.request_block(error_log, locale)
         return nil unless error_log.request_url.present?
 
         {
           type: "section",
           text: {
             type: "mrkdwn",
-            text: "*Request URL:*\n`#{NotificationHelpers.truncate_message(error_log.request_url, 200)}`"
+            text: NotificationHelpers.field(
+              :request_url, "`#{NotificationHelpers.truncate_message(error_log.request_url, 200)}`", locale
+            )
           }
         }
       end
 
-      def self.actions_block(error_log)
+      def self.actions_block(error_log, locale)
         {
           type: "actions",
           elements: [
@@ -112,7 +132,7 @@ module RailsErrorDashboard
               type: "button",
               text: {
                 type: "plain_text",
-                text: "View Details",
+                text: NotificationHelpers.t("red.notifications.error_alert.view_details", locale),
                 emoji: true
               },
               url: NotificationHelpers.dashboard_url(error_log),
@@ -122,13 +142,13 @@ module RailsErrorDashboard
         }
       end
 
-      def self.context_block(error_log)
+      def self.context_block(error_log, locale)
         {
           type: "context",
           elements: [
             {
               type: "mrkdwn",
-              text: "Error ID: #{error_log.id}"
+              text: NotificationHelpers.t("red.notifications.error_alert.error_id", locale, id: error_log.id)
             }
           ]
         }

data/lib/rails_error_dashboard/services/storm_protection/gate.rb

@@ -240,7 +240,8 @@ module RailsErrorDashboard
             @storm_notified_episode = episode[:started_at]
             StormNotificationJob.perform_later(
               started_at: episode[:started_at].iso8601,
-              state: state.to_s
+              state: state.to_s,
+              locale: ApplicationJob.enqueue_locale
             )
           rescue => e
             RailsErrorDashboard::Logger.error(

data/lib/rails_error_dashboard/services/webhook_payload_builder.rb

@@ -11,8 +11,22 @@ module RailsErrorDashboard
     #   # => { event: "error.created", timestamp: "...", error: { ... } }
     class WebhookPayloadBuilder
       # @param error_log [ErrorLog] The error to build a payload for
+      # @param locale [String] accepted so the signature matches its siblings
       # @return [Hash] Webhook payload
-      def self.call(error_log)
+      #
+      # DELIBERATELY NOT LOCALIZED (P4-T3 REQ-2, REQ-6).
+      #
+      # Every key here, and every value, is consumed by a program the operator
+      # wrote — not read by a person. "error.created", the severity string, the
+      # ISO8601 timestamps and the field names are an API contract; translating
+      # any of them silently breaks whatever is parsing the payload. There is
+      # no human-readable chrome in this payload to translate.
+      #
+      # The locale parameter exists so every builder has the same signature and
+      # the dispatcher does not need to special-case this one.
+      def self.call(error_log, locale: I18nStore::DEFAULT_LOCALE)
+        _locale = locale
+
         {
           event: "error.created",
           timestamp: Time.current.iso8601,

data/lib/rails_error_dashboard/translation.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  # Translation for code that is not a view.
+  #
+  # I18nHelper#red_t is a view helper: it html-escapes its output, because that
+  # is what a template needs. Controllers and commands produce flash messages
+  # and result strings that Rails escapes when the view renders them, so
+  # escaping here would double-escape every apostrophe.
+  #
+  # Both paths resolve the locale the same way — Current.locale_or_default —
+  # so a flash message set during a request renders in the same locale as the
+  # page that shows it.
+  #
+  # Like everything else in the i18n path, these never raise. A controller
+  # cannot be the place a translation lookup takes down the dashboard.
+  module Translation
+    # @param key [String, Symbol] e.g. "red.flash.issue.created"
+    # @return [String] never nil, never raises, never html-escaped
+    def red_t(key, **options)
+      I18nStore.translate(key, locale: red_locale, **options)
+    rescue StandardError
+      ""
+    end
+
+    # Pluralized translation. Selects the form from +count+ using the locale's
+    # CLDR rules rather than an English binary plural.
+    def red_tp(key, count:, **options)
+      red_t(key, count: count, **options)
+    end
+
+    # @return [String] a locale RED ships
+    def red_locale
+      Current.locale_or_default
+    rescue StandardError
+      I18nStore::DEFAULT_LOCALE
+    end
+  end
+end

data/lib/rails_error_dashboard/version.rb

@@ -1,3 +1,3 @@
 module RailsErrorDashboard
-  VERSION = "0.8.3"
+  VERSION = "0.9.0"
 end

data/lib/rails_error_dashboard.rb

@@ -1,5 +1,8 @@
 require "rails_error_dashboard/version"
 require "rails_error_dashboard/engine"
+require "rails_error_dashboard/i18n_store"
+require "rails_error_dashboard/current"
+require "rails_error_dashboard/translation"
 require "rails_error_dashboard/configuration_error"
 require "rails_error_dashboard/test_error"
 require "rails_error_dashboard/configuration"
@@ -37,6 +40,7 @@ require "rails_error_dashboard/services/error_normalizer"
 require "rails_error_dashboard/services/exception_filter"
 require "rails_error_dashboard/services/error_hash_generator"
 require "rails_error_dashboard/services/error_notification_dispatcher"
+require "rails_error_dashboard/services/localized_time_formatter"
 require "rails_error_dashboard/services/notification_helpers"
 require "rails_error_dashboard/services/slack_payload_builder"
 require "rails_error_dashboard/services/discord_payload_builder"

data/lib/tasks/error_dashboard.rake

@@ -545,7 +545,11 @@ namespace :error_dashboard do
     end
 
     puts "Sending #{period} error digest to #{recipients.join(', ')}..."
-    RailsErrorDashboard::ScheduledDigestJob.perform_later(period: period, application_id: app_id)
+    RailsErrorDashboard::ScheduledDigestJob.perform_later(
+      period: period,
+      application_id: app_id,
+      locale: RailsErrorDashboard::ApplicationJob.enqueue_locale
+    )
     puts "Digest job enqueued."
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_error_dashboard
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.9.0
 platform: ruby
 authors:
 - Anjan Jagirdar
@@ -169,14 +169,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.22'
+        version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.22'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -246,9 +246,12 @@ files:
 - Rakefile
 - app/controllers/rails_error_dashboard/application_controller.rb
 - app/controllers/rails_error_dashboard/errors_controller.rb
+- app/controllers/rails_error_dashboard/locales_controller.rb
 - app/controllers/rails_error_dashboard/webhooks_controller.rb
 - app/helpers/rails_error_dashboard/application_helper.rb
 - app/helpers/rails_error_dashboard/backtrace_helper.rb
+- app/helpers/rails_error_dashboard/i18n_helper.rb
+- app/helpers/rails_error_dashboard/mailer_i18n_helper.rb
 - app/helpers/rails_error_dashboard/overview_helper.rb
 - app/helpers/rails_error_dashboard/user_agent_helper.rb
 - app/jobs/rails_error_dashboard/add_issue_recurrence_comment_job.rb
@@ -256,6 +259,7 @@ files:
 - app/jobs/rails_error_dashboard/async_error_logging_job.rb
 - app/jobs/rails_error_dashboard/baseline_alert_job.rb
 - app/jobs/rails_error_dashboard/close_linked_issue_job.rb
+- app/jobs/rails_error_dashboard/concerns/localized_job.rb
 - app/jobs/rails_error_dashboard/create_issue_job.rb
 - app/jobs/rails_error_dashboard/discord_error_notification_job.rb
 - app/jobs/rails_error_dashboard/email_error_notification_job.rb
@@ -331,6 +335,17 @@ files:
 - app/views/rails_error_dashboard/errors/storms.html.erb
 - app/views/rails_error_dashboard/errors/swallowed_exceptions.html.erb
 - app/views/rails_error_dashboard/errors/user_impact.html.erb
+- config/locales/de.yml
+- config/locales/en.yml
+- config/locales/es.yml
+- config/locales/fr.yml
+- config/locales/it.yml
+- config/locales/ja.yml
+- config/locales/pl.yml
+- config/locales/pt-BR.yml
+- config/locales/ru.yml
+- config/locales/uk.yml
+- config/locales/zh-CN.yml
 - config/routes.rb
 - db/development.sqlite3
 - db/migrate/20251223000000_create_rails_error_dashboard_complete_schema.rb
@@ -404,9 +419,11 @@ files:
 - lib/rails_error_dashboard/commands/upsert_cascade_pattern.rb
 - lib/rails_error_dashboard/configuration.rb
 - lib/rails_error_dashboard/configuration_error.rb
+- lib/rails_error_dashboard/current.rb
 - lib/rails_error_dashboard/engine.rb
 - lib/rails_error_dashboard/error_reporter.rb
 - lib/rails_error_dashboard/helpers/user_model_detector.rb
+- lib/rails_error_dashboard/i18n_store.rb
 - lib/rails_error_dashboard/integrations/llm_middleware.rb
 - lib/rails_error_dashboard/integrations/llm_span_processor.rb
 - lib/rails_error_dashboard/integrations/o_tel.rb
@@ -420,6 +437,7 @@ files:
 - lib/rails_error_dashboard/plugins/audit_log_plugin.rb
 - lib/rails_error_dashboard/plugins/jira_integration_plugin.rb
 - lib/rails_error_dashboard/plugins/metrics_plugin.rb
+- lib/rails_error_dashboard/private_backend.rb
 - lib/rails_error_dashboard/queries/action_cable_summary.rb
 - lib/rails_error_dashboard/queries/active_storage_summary.rb
 - lib/rails_error_dashboard/queries/analytics_stats.rb
@@ -481,6 +499,7 @@ files:
 - lib/rails_error_dashboard/services/llm_cost_estimator.rb
 - lib/rails_error_dashboard/services/llm_summary.rb
 - lib/rails_error_dashboard/services/local_variable_capturer.rb
+- lib/rails_error_dashboard/services/localized_time_formatter.rb
 - lib/rails_error_dashboard/services/markdown_error_formatter.rb
 - lib/rails_error_dashboard/services/n_plus_one_detector.rb
 - lib/rails_error_dashboard/services/notification_helpers.rb
@@ -513,6 +532,7 @@ files:
 - lib/rails_error_dashboard/subscribers/llm_call_subscriber.rb
 - lib/rails_error_dashboard/subscribers/rack_attack_subscriber.rb
 - lib/rails_error_dashboard/test_error.rb
+- lib/rails_error_dashboard/translation.rb
 - lib/rails_error_dashboard/value_objects/error_context.rb
 - lib/rails_error_dashboard/value_objects/llm_call_event.rb
 - lib/rails_error_dashboard/version.rb
@@ -530,7 +550,7 @@ metadata:
   funding_uri: https://github.com/sponsors/AnjanJ
 post_install_message: |
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    RED (Rails Error Dashboard) v0.8.3
+    RED (Rails Error Dashboard) v0.9.0
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   First install: