rails_error_dashboard 0.14.4 → 0.15.0

data/lib/rails_error_dashboard/queries/boot_errors.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: the crashes that happened while the process was still booting.
+    #
+    # A boot crash (a Zeitwerk::NameError from eager loading, a SyntaxError in
+    # a model, an initializer that raised) is imported by CrashCapture with
+    # platform "boot_crash" and the file and constant it names, when it names
+    # them, in environment_info.boot. One entry per error row, most recent
+    # first: the question is "what stopped the last deploy", not a frequency
+    # ranking.
+    class BootErrors
+      PLATFORM = "boot_crash"
+
+      def self.call(days = 30, application_id: nil)
+        new(days, application_id: application_id).call
+      end
+
+      def initialize(days = 30, application_id: nil)
+        @days = days
+        @application_id = application_id
+        @start_date = days.days.ago
+      end
+
+      # @return [Hash] entries: [{id:, error_type:, message:, file:, constant:,
+      #   count:, first_seen:, last_seen:, resolved:}], unresolved_count: Integer
+      def call
+        rows = base_query
+          .order(last_seen_at: :desc, id: :desc)
+          .pluck(:id, :error_type, :message, :environment_info, :occurrence_count,
+                 :first_seen_at, :last_seen_at, :resolved)
+
+        entries = rows.map do |id, error_type, message, env_info, count, first_seen, last_seen, resolved|
+          boot = boot_detail(env_info)
+          {
+            id: id,
+            error_type: error_type.to_s,
+            message: message.to_s,
+            file: boot["file"].presence,
+            constant: boot["constant"].presence,
+            count: [ count.to_i, 1 ].max,
+            first_seen: first_seen,
+            last_seen: last_seen,
+            resolved: resolved ? true : false
+          }
+        end
+
+        { entries: entries, unresolved_count: entries.count { |e| !e[:resolved] } }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] BootErrors query failed: #{e.class}: #{e.message}")
+        { entries: [], unresolved_count: 0 }
+      end
+
+      private
+
+      def base_query
+        scope = ErrorLog.where(platform: PLATFORM).where("last_seen_at >= ?", @start_date)
+        scope = scope.where(application_id: @application_id) if @application_id.present?
+        scope
+      end
+
+      # environment_info is JSON text; the boot detail is optional and the
+      # column may hold anything an older row wrote, so every step is guarded.
+      def boot_detail(env_info)
+        return {} if env_info.blank?
+
+        parsed = env_info.is_a?(String) ? JSON.parse(env_info) : env_info
+        boot = parsed.is_a?(Hash) ? parsed["boot"] : nil
+        boot.is_a?(Hash) ? boot : {}
+      rescue JSON::ParserError, TypeError
+        {}
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/dashboard_stats.rb

@@ -305,19 +305,11 @@ module RailsErrorDashboard
       # breakdown makes them agree by construction instead of by luck --
       # asserted by spec/queries/dashboard_breakdowns_event_volume_spec.rb.
       def errors_by_severity_7d
-        critical = Services::SeverityClassifier::CRITICAL_ERROR_TYPES
-        high     = Services::SeverityClassifier::HIGH_SEVERITY_ERROR_TYPES
-        medium   = Services::SeverityClassifier::MEDIUM_SEVERITY_ERROR_TYPES
-
         totals = { critical: 0, high: 0, medium: 0, low: 0 }
         weekly_volume.by_group_attribute(:error_type).each do |error_type, count|
-          bucket =
-            if critical.include?(error_type) then :critical
-            elsif high.include?(error_type)  then :high
-            elsif medium.include?(error_type) then :medium
-            else :low
-            end
-          totals[bucket] += count
+          # classify honours custom_severity_rules; the bare constants did not.
+          bucket = Services::SeverityClassifier.classify(error_type)
+          totals[totals.key?(bucket) ? bucket : :low] += count
         end
         totals
       end

data/lib/rails_error_dashboard/queries/errors_list.rb

@@ -159,26 +159,18 @@ module RailsErrorDashboard
       def filter_by_severity(query)
         return query unless @filters[:severity].present?
 
-        # Map severity levels to error types
-        error_types = case @filters[:severity].to_sym
-        when :critical
-          Services::SeverityClassifier::CRITICAL_ERROR_TYPES
-        when :high
-          Services::SeverityClassifier::HIGH_SEVERITY_ERROR_TYPES
-        when :medium
-          Services::SeverityClassifier::MEDIUM_SEVERITY_ERROR_TYPES
+        # Severity is not a column: it is classified from error_type, built-in
+        # lists plus config.custom_severity_rules. The classifier owns both, so
+        # the filter agrees with the badges by construction.
+        case @filters[:severity].to_sym
+        when :critical, :high, :medium
+          query.where(error_type: Services::SeverityClassifier.error_types_for(@filters[:severity]))
         when :low
           # Low severity = everything NOT in the other categories
-          all_categorized = Services::SeverityClassifier::CRITICAL_ERROR_TYPES +
-                           Services::SeverityClassifier::HIGH_SEVERITY_ERROR_TYPES +
-                           Services::SeverityClassifier::MEDIUM_SEVERITY_ERROR_TYPES
-          # Use NOT IN to filter out categorized errors
-          return query.where.not(error_type: all_categorized)
+          query.where.not(error_type: Services::SeverityClassifier.categorized_error_types)
         else
-          return query
+          query
         end
-
-        query.where(error_type: error_types)
       end
 
       # Phase 3: Workflow filter methods

data/lib/rails_error_dashboard/queries/health_status.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: is the error dashboard itself able to do its job right now?
+    #
+    # "Who watches the watchmen": if the error database is unreachable, or the
+    # async queue that carries captures is misconfigured, no error ever reaches
+    # the dashboard and nothing else will say so. GET /health answers that
+    # question for an uptime monitor.
+    #
+    # Four checks, each individually rescued so one failing probe never hides
+    # the others:
+    #
+    #   database         SELECT 1 on the ERROR database (ErrorLogsRecord's
+    #                    pool, so use_separate_database is honoured), plus
+    #                    "are RED's tables there". The one check that can make
+    #                    the whole answer "down".
+    #   errors           last capture time and the last-24h count: cheap,
+    #                    both served by the occurred_at index.
+    #   queue            the Active Job adapter RED's jobs run on, whether
+    #                    captures are async, and the Solid Queue config
+    #                    problems the boot check found (memoised per process).
+    #   storm_protection the circuit breaker's current state.
+    #   active_storage   one existence check against the host's configured
+    #                    storage service (Services::ActiveStorageProbe).
+    #                    Storage is the app's dependency, not RED's, so a
+    #                    failure here degrades the answer rather than taking
+    #                    it down; "skipped" when ActiveStorage is not set up.
+    #
+    # Budget: one DB round trip plus two indexed queries. No COUNT(*) over the
+    # whole table (unbounded on a large install), no file reads (the Solid
+    # Queue check is memoised), nothing external. Never raises.
+    class HealthStatus
+      OK = "ok"
+      DEGRADED = "degraded"
+      DOWN = "down"
+      # A check that does not apply to this host: neutral for the overall answer.
+      SKIPPED = "skipped"
+
+      def self.call
+        new.call
+      end
+
+      def call
+        started = monotonic_now
+
+        database = check_database
+        checks = {
+          database: database,
+          # Skipped when the database is down: the queries would only fail
+          # again, slower, against a server that is not answering.
+          errors: database[:status] == DOWN ? skipped("database unreachable") : check_errors,
+          queue: check_queue,
+          storm_protection: check_storm_protection,
+          active_storage: check_active_storage
+        }
+
+        {
+          status: overall_status(checks),
+          version: RailsErrorDashboard::VERSION,
+          timestamp: Time.current.utc.iso8601,
+          checks: checks,
+          duration_ms: elapsed_ms(started)
+        }
+      rescue StandardError => e
+        # Last line of defence: the controller must always have something to
+        # render, and a health endpoint that 500s is the wrong kind of alarm.
+        {
+          status: DOWN,
+          version: RailsErrorDashboard::VERSION,
+          timestamp: Time.current.utc.iso8601,
+          checks: {},
+          error: e.class.name
+        }
+      end
+
+      # The HTTP status the controller should answer with.
+      def self.http_status_for(result)
+        result[:status] == DOWN ? 503 : 200
+      end
+
+      private
+
+      def check_database
+        config = RailsErrorDashboard.configuration
+        started = monotonic_now
+
+        adapter = nil
+        ErrorLogsRecord.connection_pool.with_connection do |connection|
+          adapter = connection.adapter_name
+          connection.select_value("SELECT 1")
+        end
+
+        tables_present = ErrorLog.table_exists?
+
+        {
+          status: tables_present ? OK : DOWN,
+          adapter: adapter,
+          separate_database: config.use_separate_database ? true : false,
+          tables_present: tables_present,
+          latency_ms: elapsed_ms(started)
+        }.tap do |check|
+          check[:reason] = "missing_tables" unless tables_present
+        end
+      rescue StandardError => e
+        {
+          status: DOWN,
+          separate_database: RailsErrorDashboard.configuration.use_separate_database ? true : false,
+          # Class only: the message can carry a host name or a connection string.
+          error: e.class.name
+        }
+      end
+
+      def check_errors
+        last = ErrorLog.maximum(:occurred_at)
+        {
+          status: OK,
+          last_error_at: last&.utc&.iso8601,
+          last_24h: ErrorLog.where("occurred_at >= ?", 24.hours.ago).count
+        }
+      rescue StandardError => e
+        { status: DEGRADED, error: e.class.name }
+      end
+
+      def check_queue
+        config = RailsErrorDashboard.configuration
+        problems = Services::SolidQueueConfigCheck.current_problems
+
+        {
+          status: problems.empty? ? OK : DEGRADED,
+          async_logging: config.async_logging ? true : false,
+          adapter: ApplicationJob.queue_adapter_name.to_s,
+          problems: problems
+        }
+      rescue StandardError => e
+        { status: DEGRADED, error: e.class.name }
+      end
+
+      def check_storm_protection
+        enabled = RailsErrorDashboard.configuration.enable_storm_protection ? true : false
+        state = enabled ? Services::StormProtection::Gate.state.to_s : "closed"
+
+        {
+          # Any state but closed means captures are being shed or merely
+          # counted: the dashboard is lagging reality by design, and a monitor
+          # should know.
+          status: state == "closed" ? OK : DEGRADED,
+          enabled: enabled,
+          state: state
+        }
+      rescue StandardError => e
+        { status: DEGRADED, error: e.class.name }
+      end
+
+      def check_active_storage
+        probe = Services::ActiveStorageProbe.call
+        case probe[:status]
+        when Services::ActiveStorageProbe::OK
+          { status: OK, service: probe[:service], latency_ms: probe[:latency_ms] }
+        when Services::ActiveStorageProbe::SKIPPED
+          { status: SKIPPED, reason: probe[:reason] }
+        else
+          { status: DEGRADED, service: probe[:service], error: probe[:error] }
+        end
+      rescue StandardError => e
+        { status: DEGRADED, error: e.class.name }
+      end
+
+      def skipped(reason)
+        { status: DEGRADED, skipped: reason }
+      end
+
+      def overall_status(checks)
+        statuses = checks.values.map { |c| c[:status] }
+        return DOWN if statuses.include?(DOWN)
+        return DEGRADED if statuses.include?(DEGRADED)
+
+        OK
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def elapsed_ms(started)
+        ((monotonic_now - started) * 1000).round(2)
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/queries/missing_translation_summary.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Queries
+    # Query: the host app's missing translation keys, most-missed first.
+    #
+    # Reads the missing_translations table (indexed SQL, no JSON parsing) for
+    # rows last seen inside the window. One entry per (locale, key): the same
+    # key missing in two locales is two rows, because fixing one locale file
+    # does not fix the other.
+    class MissingTranslationSummary
+      def self.call(days = 30, application_id: nil)
+        new(days, application_id: application_id).call
+      end
+
+      def initialize(days = 30, application_id: nil)
+        @days = days
+        @application_id = application_id
+        @start_date = days.days.ago
+      end
+
+      # @return [Hash] entries: [{locale:, key:, source:, count:, first_seen:, last_seen:}],
+      #   overflow_count: Integer, locales: [String]
+      # One pluck of every in-window row; entries, the locale set and the
+      # overflow total all come out of it, so a page view is two statements
+      # (table_exists? and this) whatever the row count.
+      def call
+        return empty unless MissingTranslation.table_exists?
+
+        merged = {}
+        overflow = 0
+
+        base_query.pluck(:locale, :translation_key, :source, :miss_count, :first_seen_at, :last_seen_at)
+          .each do |locale, key, source, count, first_seen, last_seen|
+            # Misses the tracker could not attribute to a key because its
+            # buffer was full: kept out of the listing (they belong to no
+            # key) but totalled, so the page never silently understates.
+            if key == MissingTranslation::OVERFLOW_KEY
+              overflow += count.to_i
+              next
+            end
+
+            # Merged by (locale, key) rather than trusted to be unique: the
+            # upsert index includes application_id, and a NULL there (no
+            # application_name configured) lets two threads' first writes of
+            # the same key both land, on every database. Two rows for one key
+            # would read as two problems; summing them reads as one.
+            entry = merged[[ locale.to_s, key.to_s ]] ||= {
+              locale: locale.to_s, key: key.to_s, source: nil, count: 0, first_seen: nil, last_seen: nil
+            }
+            entry[:count] += count.to_i
+            entry[:source] ||= source.presence
+            entry[:first_seen] = [ entry[:first_seen], first_seen ].compact.min
+            entry[:last_seen] = [ entry[:last_seen], last_seen ].compact.max
+          end
+
+        entries = merged.values.sort_by { |e| [ -e[:count], -(e[:last_seen]&.to_f || 0) ] }
+
+        {
+          entries: entries,
+          overflow_count: overflow,
+          locales: entries.map { |e| e[:locale] }.uniq.sort
+        }
+      rescue => e
+        Rails.logger.error("[RailsErrorDashboard] MissingTranslationSummary query failed: #{e.class}: #{e.message}")
+        empty
+      end
+
+      private
+
+      def empty
+        { entries: [], overflow_count: 0, locales: [] }
+      end
+
+      def base_query
+        scope = MissingTranslation.seen_since(@start_date)
+        scope = scope.for_application(@application_id) if @application_id.present?
+        scope
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/active_storage_probe.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RailsErrorDashboard
+  module Services
+    # Is the host's ActiveStorage service reachable right now?
+    #
+    # One existence check for a key that is never stored. The answer itself
+    # (false) is irrelevant; the round trip is the test: Disk stats a path,
+    # S3/GCS/Azure make one HEAD-style request. A raise (credentials, DNS, a
+    # bucket that no longer exists, a disk that is not mounted) means the
+    # service is down for the app too, which is what an operator wants to
+    # know before the upload errors start.
+    #
+    # Read by the /health endpoint and the ActiveStorage Health page, both
+    # on demand: nothing here runs on the capture path. Never raises.
+    class ActiveStorageProbe
+      # Namespaced so it cannot collide with a real blob key, which are
+      # 28-character base36 tokens.
+      PROBE_KEY = "rails_error_dashboard/health-probe"
+
+      OK = "ok"
+      DOWN = "down"
+      SKIPPED = "skipped"
+
+      def self.call
+        new.call
+      end
+
+      def call
+        return skipped("active_storage_not_loaded") unless defined?(::ActiveStorage)
+        # Checked before ActiveStorage::Blob is touched: loading that class
+        # reads config/storage.yml and raises when the file is missing, which
+        # on a host that never set storage up is "not configured", not "down".
+        return skipped("no_service_configured") unless configured?
+
+        service = storage_service
+        return skipped("no_service_configured") if service.nil?
+
+        started = monotonic_now
+        service.exist?(PROBE_KEY)
+
+        { status: OK, service: service_name(service), latency_ms: elapsed_ms(started) }
+      rescue => e
+        # Class only: the message can carry a bucket name, a host or a path.
+        { status: DOWN, service: safe_service_name(service), error: e.class.name }
+      end
+
+      private
+
+      def skipped(reason)
+        { status: SKIPPED, reason: reason }
+      end
+
+      # The configured service object. A seam: specs replace it with a double
+      # rather than stubbing ActiveStorage::Blob, whose class load reads the
+      # blobs table's schema (absent in the dummy app).
+      def storage_service
+        ::ActiveStorage::Blob.service
+      end
+
+      # config.active_storage.service names the service chosen for this
+      # environment; nil when the app never configured storage.
+      def configured?
+        ::Rails.application.config.active_storage.service.present?
+      rescue
+        false
+      end
+
+      # The name from config/storage.yml ("amazon", "local"), which is what
+      # the operator recognises; the class otherwise.
+      def service_name(service)
+        name = service.respond_to?(:name) ? service.name : nil
+        name.presence&.to_s || service.class.name.to_s.demodulize.delete_suffix("Service").downcase
+      end
+
+      def safe_service_name(service)
+        service ? service_name(service) : nil
+      rescue
+        nil
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def elapsed_ms(started)
+        ((monotonic_now - started) * 1000).round(2)
+      end
+    end
+  end
+end

data/lib/rails_error_dashboard/services/backtrace_parser.rb

@@ -94,15 +94,21 @@ module RailsErrorDashboard
       end
 
       def app_code?(file_path)
-        # Match /app/ or app/ (shortened paths start without leading /)
-        return true if file_path.include?("/app/") || file_path.start_with?("app/")
+        # A gem's own app/ or lib/ (an engine's models, a gem's lib) is not
+        # the host's code: it got the View Source button and a link into the
+        # host's repository for a file that is not there.
+        return false if gem_code?(file_path) || ruby_code?(file_path)
 
-        # Match /lib/ or lib/ but exclude gems and ruby stdlib
-        lib_path = file_path.include?("/lib/") || file_path.start_with?("lib/")
-        return false unless lib_path
+        # Match /app/ or app/ (shortened paths start without leading /), and
+        # the other host directories a Rails.root-relative frame can start with
+        return true if file_path.include?("/app/") || file_path.start_with?("app/", "config/", "db/")
 
-        !file_path.include?("/gems/") && !file_path.include?("/ruby/") &&
-          !file_path.start_with?("gems/") && !file_path.start_with?("ruby/")
+        # Match /lib/ or lib/ (the host's lib/, gems and stdlib excluded above)
+        file_path.include?("/lib/") || file_path.start_with?("lib/")
+      end
+
+      def ruby_code?(file_path)
+        file_path.include?("/ruby/") || file_path.start_with?("ruby/")
       end
 
       def gem_code?(file_path)

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}"