rails_error_dashboard 0.14.4 → 0.15.0

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/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