rails_error_dashboard 0.14.4 → 0.16.0

data/lib/rails_error_dashboard/queries/co_occurring_errors.rb

@@ -16,6 +16,13 @@ module RailsErrorDashboard
     #     puts "#{result[:error].error_type} occurred #{result[:frequency]} times together"
     #   end
     class CoOccurringErrors
+      # The newest occurrences of the target error that are compared. This
+      # renders on every error page while the feature is on, and it used to run
+      # one window query per lifetime occurrence: 50k occurrences, 50k queries.
+      TARGET_OCCURRENCES = 500
+      # At most this many occurrences of other errors are read for those windows
+      NEARBY_OCCURRENCES = 20_000
+
       # Find co-occurring errors
       #
       # @param error_log_id [Integer] ID of target error
@@ -34,53 +41,72 @@ module RailsErrorDashboard
         @limit = limit.to_i
       end
 
+      # Four queries however many occurrences there are: the target exists, its
+      # newest occurrence times, other errors' occurrences in those windows, and
+      # the co-occurring errors themselves.
       def find_co_occurring
-        target_error = ErrorLog.find_by(id: @error_log_id)
-        return [] unless target_error
-
-        # Get all occurrences of the target error
-        target_occurrences = ErrorOccurrence.where(error_log_id: @error_log_id)
-        return [] if target_occurrences.empty?
-
-        # For each occurrence, find other errors in the time window
-        co_occurrence_data = Hash.new { |h, k| h[k] = { count: 0, delays: [] } }
+        return [] unless ErrorLog.exists?(id: @error_log_id)
 
-        target_occurrences.find_each do |occurrence|
-          window = @window_minutes.minutes
-          start_time = occurrence.occurred_at - window
-          end_time = occurrence.occurred_at + window
+        targets = ErrorOccurrence.where(error_log_id: @error_log_id)
+          .order(occurred_at: :desc).limit(TARGET_OCCURRENCES).pluck(:occurred_at).sort
+        return [] if targets.empty?
 
-          # Find other error occurrences in this time window
-          nearby_occurrences = ErrorOccurrence
-                                .in_time_window(start_time, end_time)
-                                .where.not(error_log_id: @error_log_id)
-                                .includes(:error_log)
+        window = @window_minutes.minutes
+        stats = Hash.new { |h, k| h[k] = { count: 0, delay_sum: 0.0 } }
 
-          nearby_occurrences.each do |nearby|
-            error_log_id = nearby.error_log_id
-            co_occurrence_data[error_log_id][:count] += 1
+        nearby_occurrences(merged_windows(targets, window)).each do |error_log_id, occurred_at|
+          # Each target occurrence within the window of this one is a pair, as
+          # before. Delay is negative when this error came first.
+          index = targets.bsearch_index { |target| target >= occurred_at - window }
+          next unless index
 
-            # Calculate delay (negative = before, positive = after target error)
-            delay = (nearby.occurred_at - occurrence.occurred_at).to_f
-            co_occurrence_data[error_log_id][:delays] << delay
+          while index < targets.size && targets[index] <= occurred_at + window
+            stats[error_log_id][:count] += 1
+            stats[error_log_id][:delay_sum] += (occurred_at - targets[index]).to_f
+            index += 1
           end
         end
 
-        # Filter by minimum frequency and build results
-        results = co_occurrence_data.select { |_id, data| data[:count] >= @min_frequency }.map do |error_log_id, data|
-          error = ErrorLog.find(error_log_id)
-          avg_delay = data[:delays].sum / data[:delays].size
+        frequent = stats.select { |_id, data| data[:count] >= @min_frequency }
+        errors = ErrorLog.where(id: frequent.keys).index_by(&:id)
 
-          {
-            error: error,
-            frequency: data[:count],
-            avg_delay_seconds: avg_delay.round(2)
-          }
+        results = frequent.filter_map do |error_log_id, data|
+          error = errors[error_log_id] or next
+          { error: error, frequency: data[:count], avg_delay_seconds: (data[:delay_sum] / data[:count]).round(2) }
         end
 
         # Sort by frequency (most common first) and limit results
         results.sort_by { |r| -r[:frequency] }.first(@limit)
       end
+
+      private
+
+      # The windows around each target time, overlapping ones merged, so a burst
+      # of target occurrences becomes one range
+      def merged_windows(targets, window)
+        targets.each_with_object([]) do |target, ranges|
+          from = target - window
+          to = target + window
+          if ranges.any? && from <= ranges.last[1]
+            ranges.last[1] = to
+          else
+            ranges << [ from, to ]
+          end
+        end
+      end
+
+      # [error_log_id, occurred_at] for other errors' occurrences in any window
+      def nearby_occurrences(ranges)
+        column = "#{ErrorOccurrence.table_name}.occurred_at"
+        in_a_window = ranges.map { "(#{column} BETWEEN ? AND ?)" }.join(" OR ")
+
+        ErrorOccurrence
+          .where.not(error_log_id: @error_log_id)
+          .where(in_a_window, *ranges.flatten)
+          .order(occurred_at: :desc)
+          .limit(NEARBY_OCCURRENCES)
+          .pluck(:error_log_id, :occurred_at)
+      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/queries/platform_comparison.rb

@@ -160,18 +160,25 @@ module RailsErrorDashboard
       def platform_stability_scores
         platforms = base_scope.distinct.pluck(:platform).compact
         error_rates = error_rate_by_platform
+        # A score compares platforms. With fewer than two that have errors in
+        # the window there is nothing to compare against, so none is rated (a
+        # lone platform used to come out Critical every time). The count is of
+        # platforms with errors in the window: the list above is every
+        # platform ever seen.
+        return {} if error_rates.size < 2
         resolution_times = resolution_time_by_platform
 
-        # Find max values for normalization
-        max_errors = error_rates.values.max || 1
+        total_errors = error_rates.values.sum
         max_resolution_time = resolution_times.values.compact.max || 1
 
         platforms.each_with_object({}) do |platform, result|
           error_count = error_rates[platform] || 0
           avg_resolution = resolution_times[platform] || 0
 
-          # Normalize to 0-1 scale (inverted - lower is better)
-          error_score = 1.0 - (error_count.to_f / max_errors)
+          # This platform's share of all errors, inverted. Against the busiest
+          # platform instead, the busiest always scored 0 here and so was always
+          # Critical.
+          error_score = total_errors.positive? ? 1.0 - (error_count.to_f / total_errors) : 1.0
           resolution_score = avg_resolution.positive? ? 1.0 - (avg_resolution / max_resolution_time) : 1.0
 
           # Weight: 70% error count, 30% resolution time
@@ -252,9 +259,10 @@ module RailsErrorDashboard
             critical_errors: critical_errors,
             unresolved_errors: unresolved_errors,
             resolution_rate: resolution_rate,
-            stability_score: stability_scores[platform] || 0,
+            # nil and :not_rated when there are fewer than two platforms
+            stability_score: stability_scores[platform],
             error_velocity: velocity, # Positive = increasing, negative = decreasing
-            health_status: determine_health_status(stability_scores[platform] || 0, velocity)
+            health_status: stability_scores.key?(platform) ? determine_health_status(stability_scores[platform], velocity) : :not_rated
           }
         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)