rails_error_dashboard 0.14.3 → 0.15.0

data/lib/rails_error_dashboard/services/backtrace_processor.rb

@@ -57,6 +57,12 @@ module RailsErrorDashboard
         # Strip everything before /lib/ruby/ (Ruby stdlib)
         elsif line.include?("/lib/ruby/")
           line.sub(%r{^.*/lib/ruby/}, "ruby/")
+        # A frame under Rails.root is that path relative to it, whatever the
+        # root is called. The /app/ heuristic below cannot tell a root named
+        # /app from the app/ directory: /app/lib/foo.rb became app/lib/foo.rb,
+        # which the source reader then looked for at /app/app/lib/foo.rb.
+        elsif (root = rails_root_prefix) && line.start_with?(root)
+          line.delete_prefix(root)
         # Strip everything before /app/ (application code)
         elsif line.include?("/app/")
           line.sub(%r{^.*/app/}, "app/")
@@ -69,6 +75,15 @@ module RailsErrorDashboard
       end
       # Keep public — used by LogError for cause chain backtrace shortening too.
 
+      # "#{Rails.root}/", or nil outside Rails.
+      def self.rails_root_prefix
+        return nil unless defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+
+        "#{Rails.root}/"
+      rescue StandardError
+        nil
+      end
+
       # Calculate a signature hash from backtrace for fuzzy similarity matching
       # Extracts file paths and method names, ignoring line numbers,
       # then produces an order-independent SHA256 digest.

data/lib/rails_error_dashboard/services/baseline_alert_payload_builder.rb

@@ -9,6 +9,7 @@ module RailsErrorDashboard
     # @example
     #   BaselineAlertPayloadBuilder.slack_payload(error_log, anomaly_data)
     #   BaselineAlertPayloadBuilder.discord_payload(error_log, anomaly_data)
+    #   BaselineAlertPayloadBuilder.telegram_payload(error_log, anomaly_data)
     #   BaselineAlertPayloadBuilder.webhook_payload(error_log, anomaly_data)
     class BaselineAlertPayloadBuilder
       ANOMALY_EMOJIS = {
@@ -140,6 +141,30 @@ module RailsErrorDashboard
         }
       end
 
+      # Build the Telegram sendMessage payload for a baseline anomaly. HTML
+      # parse mode with every value escaped; see TelegramPayloadBuilder for
+      # why HTML and not MarkdownV2.
+      # @return [Hash] sendMessage payload without chat_id
+      def self.telegram_payload(error_log, anomaly_data, locale: I18nStore::DEFAULT_LOCALE)
+        tg = TelegramPayloadBuilder
+        lines = [
+          tg.bold(NotificationHelpers.t("red.notifications.baseline_alert.heading", locale)),
+          tg.field(:application, NotificationHelpers.app_name(error_log), locale),
+          tg.field(:error_type, error_log.error_type, locale),
+          tg.field(:platform, error_log.platform || NotificationHelpers.unknown(locale), locale),
+          telegram_field(:severity, anomaly_level(anomaly_data[:level], locale), locale),
+          telegram_field(:std_devs, std_devs_text(anomaly_data, locale), locale),
+          telegram_field(:threshold, threshold_text(anomaly_data, locale), locale),
+          telegram_field(:baseline_type, anomaly_data[:baseline_type] || NotificationHelpers.not_available(locale), locale),
+          tg.field(:message, NotificationHelpers.truncate_message(error_log.message, 200), locale, code: true),
+          "",
+          tg.link(NotificationHelpers.dashboard_url(error_log),
+                  NotificationHelpers.t("red.notifications.error_alert.view_in_dashboard", locale))
+        ]
+
+        tg.html_payload(lines.join("\n"))
+      end
+
       # Build generic webhook payload for baseline anomaly
       # @param error_log [ErrorLog] The error
       # @param anomaly_data [Hash] Anomaly information
@@ -179,6 +204,11 @@ module RailsErrorDashboard
         NotificationHelpers.t("red.notifications.baseline_alert.labels.#{label}", locale)
       end
 
+      # Telegram's "<b>Label:</b> value" shape, for a baseline-only label.
+      def self.telegram_field(label, value, locale)
+        "#{TelegramPayloadBuilder.bold("#{baseline_label(label, locale)}:")} #{TelegramPayloadBuilder.escape(value)}"
+      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}"

data/lib/rails_error_dashboard/services/crash_capture.rb

@@ -14,6 +14,16 @@ module RailsErrorDashboard
     # disk as JSON. On the next boot, `import!` reads crash files and creates
     # ErrorLog records with severity "fatal".
     #
+    # BOOT CRASHES: the hook is registered from an engine initializer that
+    # runs right after the host's config/initializers (so the configuration
+    # is known) and before Rails' :eager_load! finisher. That ordering is the
+    # whole point: a Zeitwerk::NameError from eager loading, a SyntaxError in
+    # a model, an initializer that raised -- these kill the process before
+    # config.after_initialize ever runs, so a hook registered there (as this
+    # one was until 0.15) never saw them. A crash captured while
+    # Rails.application.initialized? is still false is marked phase "boot",
+    # imported with platform "boot_crash", and listed on the Boot Errors page.
+    #
     # Safety contract:
     # - Default OFF (opt-in via config.enable_crash_capture)
     # - Writes to tmpfile, NOT the database (connection pool may be closed)
@@ -24,6 +34,14 @@ module RailsErrorDashboard
     class CrashCapture
       FILE_PREFIX = "red_crash_"
 
+      BOOT_PHASE = "boot"
+      RUNTIME_PHASE = "runtime"
+      BOOT_PLATFORM = "boot_crash"
+      RUNTIME_PLATFORM = "crash_capture"
+
+      # "expected file /app/app/models/foo.rb to define constant Foo, but didn't"
+      ZEITWERK_MESSAGE = /expected file (?<file>.+?) to define constant (?<constant>\S+), but didn't/
+
       class << self
         # Enable crash capture. Registers the `at_exit` hook and records boot time.
         # @return [true]
@@ -108,6 +126,11 @@ module RailsErrorDashboard
           # Rails version (may not be available during crash)
           data[:rails_version] = Rails.version if defined?(Rails) && Rails.respond_to?(:version)
 
+          # Boot or runtime: a process that died before initialize! finished
+          # never served a request, which is a different kind of outage.
+          data[:phase] = boot_phase? ? BOOT_PHASE : RUNTIME_PHASE
+          data[:boot] = boot_detail(exception) if data[:phase] == BOOT_PHASE
+
           # Uptime
           if @boot_time
             data[:uptime_seconds] = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - @boot_time).round(1)
@@ -122,6 +145,51 @@ module RailsErrorDashboard
           data
         end
 
+        # True while Rails is still running its initializers (eager loading
+        # included). Rails.application.initialized? flips only after the last
+        # finisher has run. Outside Rails (a plain Ruby script) there is no
+        # boot phase to speak of.
+        def boot_phase?
+          defined?(Rails) && Rails.respond_to?(:application) && Rails.application &&
+            !Rails.application.initialized?
+        rescue
+          false
+        end
+
+        # What a boot crash names, for the Boot Errors page: the file and the
+        # constant for a Zeitwerk::NameError, else the first backtrace frame
+        # under Rails.root (a SyntaxError or an initializer that raised).
+        # Paths are made relative to Rails.root so the page reads
+        # "app/models/foo.rb", not a deploy directory.
+        def boot_detail(exception)
+          detail = {}
+          root = rails_root_prefix
+
+          if exception.class.name == "Zeitwerk::NameError" && (m = ZEITWERK_MESSAGE.match(exception.message.to_s))
+            detail[:file] = relative_path(m[:file], root)
+            detail[:constant] = m[:constant]
+          elsif (frame = Array(exception.backtrace).find { |f| root && f.to_s.start_with?(root) })
+            detail[:file] = relative_path(frame.to_s.split(":in ").first, root)
+          end
+
+          detail
+        rescue
+          {}
+        end
+
+        def rails_root_prefix
+          return nil unless defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+
+          "#{Rails.root}/"
+        rescue
+          nil
+        end
+
+        def relative_path(path, root)
+          path = path.to_s
+          root && path.start_with?(root) ? path.delete_prefix(root) : path
+        end
+
         def extract_cause_chain(exception)
           causes = []
           current = exception.cause
@@ -155,6 +223,8 @@ module RailsErrorDashboard
           cause_chain = data["cause_chain"]
           cause_json = cause_chain.is_a?(Array) && cause_chain.any? ? cause_chain.to_json : nil
 
+          boot = data["phase"] == BOOT_PHASE
+
           # Build environment_info from crash metadata
           env_info = {
             ruby_version: data["ruby_version"],
@@ -164,6 +234,8 @@ module RailsErrorDashboard
             uptime_seconds: data["uptime_seconds"],
             gc: data["gc"],
             crash_captured_at: data["timestamp"],
+            phase: data["phase"],
+            boot: (data["boot"] if boot && data["boot"].is_a?(Hash) && data["boot"].any?),
             source: "crash_capture"
           }.compact
 
@@ -180,7 +252,9 @@ module RailsErrorDashboard
             message: data["message"] || "Process crash captured via at_exit hook",
             backtrace: backtrace_text,
             occurred_at: occurred_at,
-            platform: "crash_capture",
+            # Boot crashes get their own platform so the Boot Errors page and
+            # the index's platform filter can find them.
+            platform: boot ? BOOT_PLATFORM : RUNTIME_PLATFORM,
             resolved: false
           }
 
@@ -210,7 +284,16 @@ module RailsErrorDashboard
             attributes[:last_seen_at] = occurred_at
           end
 
-          ErrorLog.create!(attributes)
+          # Through the same find-or-increment as every other capture: a crash
+          # that repeats on every restart is one row with a count, not a new
+          # row per restart -- and a plain create! collided with the unique
+          # group-identity index on the second one, which left the file as
+          # .failed and the crash unrecorded.
+          if attributes[:error_hash]
+            Commands::FindOrIncrementError.call(attributes[:error_hash], attributes)
+          else
+            ErrorLog.create!(attributes)
+          end
 
           # Delete file after successful import
           File.delete(file)

data/lib/rails_error_dashboard/services/digest_builder.rb

@@ -93,9 +93,7 @@ module RailsErrorDashboard
         unresolved = scope.where(resolved: false).count
         # Severity is computed from error_type via SeverityClassifier (not a DB column).
         # Count critical+high by matching known error type patterns via SQL WHERE IN.
-        critical_types = Services::SeverityClassifier::CRITICAL_ERROR_TYPES +
-                         Services::SeverityClassifier::HIGH_SEVERITY_ERROR_TYPES
-        critical_high = scope.where(error_type: critical_types).count
+        critical_high = scope.where(error_type: critical_and_high_types).count
 
         total = resolved + unresolved
         resolution_rate = total > 0 ? (resolved.to_f / total * 100).round(1) : 0
@@ -141,11 +139,9 @@ module RailsErrorDashboard
       end
 
       def critical_unresolved
-        critical_types = Services::SeverityClassifier::CRITICAL_ERROR_TYPES +
-                         Services::SeverityClassifier::HIGH_SEVERITY_ERROR_TYPES
         base_scope
           .where(resolved: false)
-          .where(error_type: critical_types)
+          .where(error_type: critical_and_high_types)
           .order(occurred_at: :desc)
           .limit(5)
           .map do |error|
@@ -161,6 +157,13 @@ module RailsErrorDashboard
         []
       end
 
+
+      # Built-in lists adjusted by custom_severity_rules, so the digest's
+      # "critical/high" agrees with the dashboard's badges.
+      def critical_and_high_types
+        Services::SeverityClassifier.error_types_for(:critical) +
+          Services::SeverityClassifier.error_types_for(:high)
+      end
       def build_comparison
         previous_start = (@days * 2).days.ago
         previous_end = @start_date

data/lib/rails_error_dashboard/services/error_notification_dispatcher.rb

@@ -19,6 +19,7 @@ module RailsErrorDashboard
         (config.enable_slack_notifications && config.slack_webhook_url.present?) ||
           (config.enable_email_notifications && config.notification_email_recipients.present?) ||
           (config.enable_discord_notifications && config.discord_webhook_url.present?) ||
+          TelegramDelivery.configured?(config) ||
           (config.enable_pagerduty_notifications && config.pagerduty_integration_key.present?) ||
           (config.enable_webhook_notifications && config.webhook_urls.present?) || false
       end
@@ -58,6 +59,11 @@ module RailsErrorDashboard
             fired << "discord"
           end
 
+          if TelegramDelivery.configured?(config)
+            TelegramErrorNotificationJob.perform_later(error_log.id, locale)
+            fired << "telegram"
+          end
+
           if config.enable_pagerduty_notifications && config.pagerduty_integration_key.present?
             PagerdutyErrorNotificationJob.perform_later(error_log.id, locale)
             fired << "pagerduty"

data/lib/rails_error_dashboard/services/exception_filter.rb

@@ -28,7 +28,8 @@ module RailsErrorDashboard
       end
 
       # Check if exception is in the ignored exceptions list
-      # Supports both string class names and regex patterns
+      # Supports class-name strings and Class/Module objects (both match
+      # subclasses), and regex patterns (matched against the class name)
       # @param exception [Exception] The exception to check
       # @return [Boolean] true if the exception should be ignored
       def self.ignored?(exception)
@@ -41,6 +42,8 @@ module RailsErrorDashboard
           case ignored
           when String
             exception.is_a?(ignored.constantize)
+          when Module
+            exception.is_a?(ignored)
           when Regexp
             exception_class_name.match?(ignored)
           else

data/lib/rails_error_dashboard/services/github_link_generator.rb

@@ -135,20 +135,36 @@ module RailsErrorDashboard
       def normalize_file_path
         path = file_path.strip
 
-        # Remove leading slash
-        path = path.sub(%r{^/}, "")
-
-        # Remove Rails.root or app root prefix if present
-        # Handles paths like "/Users/foo/myapp/app/models/user.rb" -> "app/models/user.rb"
-        # Match pattern: look for one of the standard Rails directories
-        match = path.match(%r{.*/?((?:app|lib|config|db|spec|test)/.*)$})
-        if match
-          path = match[1]
+        # A frame under Rails.root is that path relative to the root, exactly.
+        root = rails_root_prefix
+        path = path.delete_prefix(root) if root && path.start_with?(root)
+
+        if path.start_with?("/")
+          # An absolute path under some other root: the best guess is the
+          # last standard Rails directory in it ("/Users/foo/myapp/app/..." ->
+          # "app/...").
+          path = path.sub(%r{^/}, "")
+          match = path.match(%r{.*/((?:app|lib|config|db|spec|test)/.*)\z})
+        else
+          # Already relative (BacktraceProcessor stores frames that way): the
+          # FIRST standard directory at a segment boundary. The greedy guess
+          # above, applied here, linked app/services/config/loader.rb to
+          # config/loader.rb and app/models/contest/x.rb to test/x.rb.
+          match = path.match(%r{(?:\A|/)((?:app|lib|config|db|spec|test)/.*)\z})
         end
+        path = match[1] if match
 
         path
       end
 
+      def rails_root_prefix
+        return nil unless defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+
+        "#{Rails.root}/"
+      rescue StandardError
+        nil
+      end
+
       # Generate GitHub link
       #
       # Format: https://github.com/user/repo/blob/{ref}/path/to/file.rb#L42

data/lib/rails_error_dashboard/services/missing_translation_handler.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Wraps the host app's I18n.exception_handler so every missing translation
+    # is counted, then hands the exception to the handler the app already had.
+    #
+    # WHY THE EXCEPTION HANDLER: I18n.t calls it for every miss
+    # (i18n/lib/i18n.rb, handle_exception). There is no
+    # ActiveSupport::Notifications event for a miss, so subscribing, as the
+    # deprecation tracker does, is not an option.
+    #
+    # WHY ALSO A VIEW-HELPER HOOK: the view helper t() does NOT go through
+    # the exception handler before Rails 8.1. It looks the key up with a
+    # sentinel default (so I18n never misses) and renders the "translation
+    # missing" span from its own missing_translation method; only 8.1 added
+    # an exception_handler call there. Templates are where most misses live,
+    # so ViewHelperHook is prepended onto ActionView's TranslationHelper and
+    # counts in missing_translation itself. A thread flag set around super
+    # keeps the handler from counting the same miss a second time on 8.1.
+    #
+    # WHAT IS NOT SEEN, by design: a lookup given a :default never misses, and
+    # with raise_on_missing_translations (or `raise: true`) I18n raises before
+    # reaching any handler -- that miss surfaces as an exception, which RED
+    # captures as an error anyway.
+    #
+    # These are the only places RED touches global I18n and ActionView state,
+    # which is why they are opt-in (enable_missing_translation_tracking,
+    # default false) and transparent: no return value changes, no exception
+    # the original would have raised is swallowed, and uninstall! puts the
+    # original handler back (the view hook stays prepended -- Ruby cannot
+    # un-prepend -- but does nothing while the handler is not installed).
+    # RED's own dashboard strings never arrive here; I18nStore resolves them
+    # in a private backend.
+    class MissingTranslationHandler
+      # Set by ViewHelperHook around super so a Rails 8.1+ missing_translation,
+      # which calls the exception handler itself, is counted once, not twice.
+      VIEW_HOOK_FLAG = :red_missing_translation_in_view_hook
+
+      attr_reader :original
+
+      # @param original [#call, Symbol] the handler being wrapped. I18n allows
+      #   a Symbol naming a method on I18n itself; it is delegated the same way
+      #   I18n.handle_exception would.
+      def initialize(original)
+        @original = original
+      end
+
+      # The I18n exception handler contract.
+      def call(exception, locale, key, options)
+        track(exception, locale, key, options) if exception.is_a?(::I18n::MissingTranslation)
+        delegate(exception, locale, key, options)
+      end
+
+      # Prepended onto ActionView::Helpers::TranslationHelper: counts the miss
+      # the view helper is about to render as "translation missing".
+      module ViewHelperHook
+        private
+
+        def missing_translation(key, options)
+          if MissingTranslationHandler.installed?
+            MissingTranslationHandler.record_view_miss(key, options)
+            Thread.current.thread_variable_set(MissingTranslationHandler::VIEW_HOOK_FLAG, true)
+          end
+          super
+        ensure
+          Thread.current.thread_variable_set(MissingTranslationHandler::VIEW_HOOK_FLAG, nil)
+        end
+      end
+
+      class << self
+        # Wrap the current global handler and hook the view helper. Idempotent:
+        # a second install (code reloading, a spec that installs twice) does
+        # not stack wrappers.
+        # @return [MissingTranslationHandler]
+        def install!
+          install_view_hook!
+
+          current = ::I18n.exception_handler
+          return current if current.is_a?(self)
+
+          ::I18n.exception_handler = new(current)
+        end
+
+        # Put the wrapped handler back. A no-op when nothing is installed.
+        def uninstall!
+          current = ::I18n.exception_handler
+          return unless current.is_a?(self)
+
+          ::I18n.exception_handler = current.original
+        end
+
+        def installed?
+          ::I18n.exception_handler.is_a?(self)
+        end
+
+        # Count a miss the view helper reported. Never raises.
+        def record_view_miss(key, options)
+          options = {} unless options.is_a?(Hash)
+          locale = options[:locale] || ::I18n.locale
+          full_key = ::I18n.normalize_keys(nil, key, options[:scope]).join(".")
+
+          MissingTranslationTracker.record(locale: locale.to_s, key: full_key)
+        rescue => e
+          nil
+        end
+
+        private
+
+        def install_view_hook!
+          return unless defined?(::ActionView::Helpers::TranslationHelper)
+
+          helper = ::ActionView::Helpers::TranslationHelper
+          helper.prepend(ViewHelperHook) unless helper.ancestors.include?(ViewHelperHook)
+        rescue => e
+          RailsErrorDashboard::Logger.debug(
+            "[RailsErrorDashboard] MissingTranslationHandler view hook not installed: #{e.class} - #{e.message}"
+          )
+          nil
+        end
+      end
+
+      private
+
+      # Counting must never change what the host sees, so it is rescued on its
+      # own and the exception is delegated whatever happened here.
+      def track(exception, locale, key, options)
+        # The view hook already counted this one (Rails 8.1+ calls the
+        # handler from inside missing_translation).
+        return if Thread.current.thread_variable_get(VIEW_HOOK_FLAG)
+
+        # The full dotted key as I18n normalised it, scope included, locale
+        # excluded: "users.show.greeting", not "en.users.show.greeting".
+        scope = options.is_a?(Hash) ? options[:scope] : nil
+        full_key = ::I18n.normalize_keys(nil, exception.key, scope).join(".")
+
+        MissingTranslationTracker.record(locale: locale.to_s, key: full_key)
+      rescue => e
+        nil
+      end
+
+      def delegate(exception, locale, key, options)
+        case original
+        when Symbol
+          ::I18n.send(original, exception, locale, key, options)
+        else
+          original.call(exception, locale, key, options)
+        end
+      end
+    end
+  end
+end