rails_pulse 0.3.3 → 0.4.0.pre.1

data/app/controllers/rails_pulse/requests_controller.rb

@@ -109,7 +109,7 @@ module RailsPulse
 
       # If filtering or sorting by route_path, we need to join the routes table
       needs_join = @ransack_query.sorts.any? { |sort| sort.name == "route_path" } ||
-                   params.dig(:q, :route_path_cont).present?
+                   ransack_params[:route_path_cont].present?
 
       if needs_join
         base_query = base_query.joins(:route)

data/app/controllers/rails_pulse/routes_controller.rb

@@ -54,7 +54,6 @@ module RailsPulse
       show_action? ? { route: @route } : {}
     end
 
-    # Filter to scope table results to a specific route on show pages
     def show_resource_filter
       { route_id_eq: @route.id }
     end
@@ -92,6 +91,8 @@ module RailsPulse
 
         # For PostgreSQL compatibility with DISTINCT + ORDER BY
         # we need to include computed columns in SELECT when ordering by them
+        base_query = base_query.joins(:route).preload(:route)
+
         if ordering_by_computed_column?
           base_query.select("rails_pulse_requests.*, #{status_indicator_sql} as status_indicator_value").distinct
         else
@@ -109,6 +110,11 @@ module RailsPulse
       end
     end
 
+    # Request/route-name filters that Summary chart queries don't join for.
+    def chart_filter_exclusions
+      %w[route_path_cont route_controller_action_cont controller_action_cont http_method_eq]
+    end
+
     def default_time_range_key
       :last_14_days
     end

data/app/controllers/rails_pulse/storage_controller.rb

@@ -0,0 +1,7 @@
+module RailsPulse
+  class StorageController < ApplicationController
+    def show
+      @status = RailsPulse::Dashboard::StorageStatus.new
+    end
+  end
+end

data/app/controllers/rails_pulse/tags_controller.rb

@@ -19,7 +19,7 @@ module RailsPulse
         flash[:alert] = "Failed to add tag"
       end
 
-      redirect_back(fallback_location: root_path)
+      redirect_back(fallback_location: root_path, allow_other_host: false)
     end
 
     def destroy
@@ -30,7 +30,7 @@ module RailsPulse
         flash[:alert] = "Failed to remove tag"
       end
 
-      redirect_back(fallback_location: root_path)
+      redirect_back(fallback_location: root_path, allow_other_host: false)
     end
 
     private

data/app/helpers/rails_pulse/application_helper.rb

@@ -1,5 +1,6 @@
 module RailsPulse
   module ApplicationHelper
+    include BacktraceHelper
     include BreadcrumbsHelper
     include ChartHelper
     include CspHelper

data/app/helpers/rails_pulse/backtrace_helper.rb

@@ -0,0 +1,85 @@
+module RailsPulse
+  module BacktraceHelper
+    APP_FRAME_PATTERN = %r{/app/|/config/|/lib/}
+    GEM_FRAME_PATTERN = %r{/gems/|/rubygems/|/bundler/|/lib/ruby/}
+
+    def app_frame?(frame)
+      file = frame["file"].to_s
+      file.match?(APP_FRAME_PATTERN) && !file.match?(GEM_FRAME_PATTERN)
+    end
+
+    # Strip everything before /app/, /lib/, /config/ so paths are relative.
+    # Falls back to gem-name/rest for gem frames, or just basename for stdlib.
+    def frame_display_path(frame)
+      file = frame["file"].to_s
+      # Gem frames: /…/gems/[ruby-ver]/gems/[gem-name]/lib/… → gem-name/lib/…
+      if (match = file.match(%r{/gems/[^/]+/gems/([^/]+)/(.+)}))
+        "#{match[1]}/#{match[2]}"
+      # Bundler path gems: /…/gems/[gem-name]/lib/… → gem-name/lib/…
+      elsif (match = file.match(%r{/gems/([^/]+)/(.+)}))
+        "#{match[1]}/#{match[2]}"
+      # App frames: strip absolute prefix, keep /app/…, /lib/…, /config/…
+      elsif (match = file.match(%r{(/(?:app|lib|config)/.+)}))
+        match[1]
+      else
+        File.basename(file)
+      end
+    end
+
+    def frame_dirname(frame)
+      File.dirname(frame_display_path(frame)) + "/"
+    end
+
+    def frame_basename(frame)
+      File.basename(frame_display_path(frame))
+    end
+
+    # Directories (relative to Rails.root) whose source may be shown, and the
+    # file types within them. Everything else under Rails.root — initializers
+    # with inline keys, credentials, database.yml, .env, tmp/ — stays
+    # unreadable even when a backtrace frame points at it.
+    SOURCE_ALLOWED_DIRECTORIES = %w[app/ lib/].freeze
+    SOURCE_ALLOWED_FILES = %w[config/routes.rb].freeze
+    SOURCE_ALLOWED_EXTENSIONS = %w[.rb .erb .rake .haml .slim .jbuilder].freeze
+
+    def frame_source_lines(frame, radius: 3)
+      file = frame["file"].to_s
+      line = frame["line"].to_i
+      return nil if file.blank? || line < 1
+      return nil unless File.exist?(file) && File.file?(file)
+      return nil unless source_readable?(file)
+
+      first_line = [ line - radius, 1 ].max
+      last_line  = line + radius
+
+      lines = {}
+      File.foreach(file).with_index(1) do |content, lineno|
+        break if lineno > last_line
+        lines[lineno] = content.rstrip if lineno >= first_line
+      end
+      lines
+    rescue Errno::EACCES, Errno::ENOENT
+      nil
+    end
+
+    private
+
+    # Only read source for code files under Rails.root's app/ and lib/ (plus
+    # config/routes.rb). Resolved through realpath so symlinks cannot point
+    # outside, and matched on the relative path so a directory merely named
+    # "app" elsewhere on disk does not qualify.
+    def source_readable?(file)
+      real = File.realpath(file)
+      root = "#{Rails.root.realpath}#{File::SEPARATOR}"
+      return false unless real.start_with?(root)
+
+      relative = real.delete_prefix(root)
+      return false unless SOURCE_ALLOWED_EXTENSIONS.include?(File.extname(relative))
+
+      SOURCE_ALLOWED_FILES.include?(relative) ||
+        SOURCE_ALLOWED_DIRECTORIES.any? { |dir| relative.start_with?(dir) }
+    rescue Errno::ENOENT
+      false
+    end
+  end
+end

data/app/helpers/rails_pulse/breadcrumbs_helper.rb

@@ -3,7 +3,9 @@ module RailsPulse
     # Maps singularized path segments to their actual model class names
     # when the default classify convention doesn't match
     SEGMENT_CLASS_OVERRIDES = {
-      "run" => "JobRun"
+      "run" => "JobRun",
+      "exception" => "ExceptionGroup",
+      "occurrence" => "ExceptionOccurrence"
     }.freeze
 
     def breadcrumbs
@@ -88,6 +90,7 @@ module RailsPulse
 
       crumbs
     end
+
     def page_title
       crumbs = breadcrumbs
       return "Rails Pulse" if crumbs.empty?

data/app/helpers/rails_pulse/chart_helper.rb

@@ -43,9 +43,6 @@ module RailsPulse
           axisPointer: { type: "shadow" },
           formatter: tooltip_formatter
         },
-        toolbox: {
-          feature: { saveAsImage: { show: false } }
-        },
         xAxis: {
           axisLine: { show: false },
           axisTick: { show: false },

data/app/helpers/rails_pulse/route_helper.rb

@@ -25,24 +25,16 @@ module RailsPulse
         RailsPulse::Engine.routes.url_helpers.respond_to?(method, include_private) || super
       end
 
-      # Generate asset paths using Rails asset pipeline
-      # This allows assets to work with CDN, digests, and precompiled manifests
+      # After `assets:precompile`, files live in public/assets with a digest
+      # so config.asset_host / CDN-only CSP work. Until then (development,
+      # or hosts with no pipeline) serve from the gem via AssetServer.
+      # Always pass the result to tag.link / tag.script, not stylesheet_link_tag:
+      # a middleware path must not be rewritten onto the CDN.
       def asset_path(asset_name)
-        # Only use asset pipeline if we have Sprockets/Propshaft configured
-        # Otherwise fall back to middleware serving
-        if defined?(::Sprockets) || defined?(::Propshaft)
-          # Use the main application's asset_path helper to ensure we get
-          # the correct digested paths from the precompiled manifest
-          begin
-            ActionController::Base.helpers.asset_path(asset_name)
-          rescue => e
-            # Fallback to direct path if asset pipeline is not available
-            Rails.logger.warn "[Rails Pulse] Asset pipeline error for #{asset_name}: #{e.message}"
-            "/rails-pulse-assets/#{asset_name}"
-          end
+        if (packaged = RailsPulse::PackagedAssets.url_path(asset_name))
+          ActionController::Base.helpers.asset_path(packaged)
         else
-          # No asset pipeline - use middleware serving
-          "/rails-pulse-assets/#{asset_name}"
+          "/rails-pulse-assets/#{RailsPulse::VERSION}/#{asset_name}"
         end
       end
     end

data/app/javascript/rails_pulse/application.js

@@ -1,24 +1,48 @@
-import * as echarts from "echarts";
-import "./theme";
+// Only the chart types and components Rails Pulse actually renders are pulled in.
+// Importing the "echarts" barrel instead would bundle every chart type (sankey,
+// gauge, map, ...) and roughly quintuple the bundle.
+import * as echarts from "echarts/core";
+import { BarChart, LineChart } from "echarts/charts";
+import {
+  DataZoomComponent,
+  GridComponent,
+  LegendComponent,
+  MarkAreaComponent,
+  MarkLineComponent,
+  TooltipComponent
+} from "echarts/components";
+import { CanvasRenderer } from "echarts/renderers";
 import { Application } from "@hotwired/stimulus";
 
+// TooltipComponent installs AxisPointer itself, so `axisPointer` options work.
+echarts.use([
+  BarChart,
+  LineChart,
+  DataZoomComponent,
+  GridComponent,
+  LegendComponent,
+  MarkAreaComponent,
+  MarkLineComponent,
+  TooltipComponent,
+  CanvasRenderer
+]);
+
 // CSS Zero Controllers
 import ContextMenuController from "./controllers/context_menu_controller";
 import DatePickerController from "./controllers/datepicker_controller";
 import DialogController from "./controllers/dialog_controller";
 import MenuController from "./controllers/menu_controller";
 import PopoverController from "./controllers/popover_controller";
-import FormController from "./controllers/form_controller";
 
 // Rails Pulse Controllers
 import ChartController from "./controllers/chart_controller";
 import IndexController from "./controllers/index_controller";
 import ColorSchemeController from "./controllers/color_scheme_controller";
 import PaginationController from "./controllers/pagination_controller";
-import TimezoneController from "./controllers/timezone_controller";
 import IconController from "./controllers/icon_controller";
 import ExpandableRowsController from "./controllers/expandable_rows_controller";
 import CollapsibleController from "./controllers/collapsible_controller";
+import ClipboardController from "./controllers/clipboard_controller";
 import TableSortController from "./controllers/table_sort_controller";
 import GlobalFiltersController from "./controllers/global_filters_controller";
 import CustomRangeController from "./controllers/custom_range_controller"
@@ -26,7 +50,6 @@ import SeriesToggleController from "./controllers/series_toggle_controller";
 import DeploymentMarkersToggleController from "./controllers/deployment_markers_toggle_controller";
 import FlameGraphController from "./controllers/flame_graph_controller";
 import ChartSwitcherController from "./controllers/chart_switcher_controller";
-import PeriodSelectorController from "./controllers/period_selector_controller";
 import TimeRangeController from "./controllers/time_range_controller";
 const application = Application.start();
 
@@ -42,16 +65,15 @@ application.register("rails-pulse--datepicker", DatePickerController);
 application.register("rails-pulse--dialog", DialogController);
 application.register("rails-pulse--menu", MenuController);
 application.register("rails-pulse--popover", PopoverController);
-application.register("rails-pulse--form", FormController);
 
 application.register("rails-pulse--chart", ChartController);
 application.register("rails-pulse--index", IndexController);
 application.register("rails-pulse--color-scheme", ColorSchemeController);
 application.register("rails-pulse--pagination", PaginationController);
-application.register("rails-pulse--timezone", TimezoneController);
 application.register("rails-pulse--icon", IconController);
 application.register("rails-pulse--expandable-rows", ExpandableRowsController);
 application.register("rails-pulse--collapsible", CollapsibleController);
+application.register("rails-pulse--clipboard", ClipboardController);
 application.register("rails-pulse--table-sort", TableSortController);
 application.register("rails-pulse--global-filters", GlobalFiltersController);
 application.register("rails-pulse--custom-range", CustomRangeController);
@@ -59,7 +81,6 @@ application.register("rails-pulse--series-toggle", SeriesToggleController);
 application.register("rails-pulse--deployment-markers-toggle", DeploymentMarkersToggleController);
 application.register("rails-pulse--flame-graph", FlameGraphController);
 application.register("rails-pulse--chart-switcher", ChartSwitcherController);
-application.register("rails-pulse--period-selector", PeriodSelectorController);
 application.register("rails-pulse--time-range", TimeRangeController);
 
 // Register ECharts theme for Rails Pulse

data/app/javascript/rails_pulse/controllers/clipboard_controller.js

@@ -0,0 +1,58 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["source"]
+  static values = {
+    label: { type: String, default: "copy" },
+    copiedLabel: { type: String, default: "copied!" },
+    errorLabel: { type: String, default: "copy failed" },
+    resetDelay: { type: Number, default: 1500 }
+  }
+
+  disconnect() {
+    if (this.resetTimeout) clearTimeout(this.resetTimeout)
+  }
+
+  async copy(event) {
+    const button = event.currentTarget
+    const text = this.hasSourceTarget ? this.sourceTarget.textContent : ""
+
+    try {
+      await this.write(text)
+      this.flash(button, this.copiedLabelValue)
+    } catch {
+      this.flash(button, this.errorLabelValue)
+    }
+  }
+
+  // navigator.clipboard is undefined on insecure origins, which is where a
+  // mounted dashboard often lives (http://staging.internal). Fall back to the
+  // legacy execCommand path there rather than silently doing nothing.
+  async write(text) {
+    if (navigator.clipboard && window.isSecureContext) {
+      return navigator.clipboard.writeText(text)
+    }
+
+    const textarea = document.createElement("textarea")
+    textarea.value = text
+    textarea.setAttribute("readonly", "")
+    textarea.style.position = "fixed"
+    textarea.style.opacity = "0"
+    document.body.appendChild(textarea)
+    textarea.select()
+
+    try {
+      if (!document.execCommand("copy")) throw new Error("execCommand copy failed")
+    } finally {
+      document.body.removeChild(textarea)
+    }
+  }
+
+  flash(button, message) {
+    button.textContent = message
+    if (this.resetTimeout) clearTimeout(this.resetTimeout)
+    this.resetTimeout = setTimeout(() => {
+      button.textContent = this.labelValue
+    }, this.resetDelayValue)
+  }
+}

data/app/javascript/rails_pulse/controllers/index_controller.js

@@ -40,6 +40,16 @@ export default class extends Controller {
     this.handleChartInitialized = this.onChartInitialized.bind(this);
 
     document.addEventListener('stimulus:echarts:rendered', this.handleChartInitialized);
+
+    // Releasing the mouse outside the chart still ends a drag-zoom. This is not
+    // chart-specific, so it is bound once per controller rather than in
+    // setupChartEventListeners — that runs again on every chart switch and used
+    // to stack a new document listener each time.
+    this.handleDocumentMouseUp = () => {
+      if (!this.chart || !this.visibleData) return;
+      this.handleZoomChange();
+    };
+    document.addEventListener('mouseup', this.handleDocumentMouseUp);
   }
 
   disconnect() {
@@ -226,12 +236,6 @@ export default class extends Controller {
       this.handleZoomChange();
     });
 
-    // When releasing the mouse button outside the chart, we want to check if the visible data has changed
-    this.handleDocumentMouseUp = () => {
-      this.handleZoomChange();
-    };
-    document.addEventListener('mouseup', this.handleDocumentMouseUp);
-
     // Use ZRender (the underlying canvas renderer) to catch clicks anywhere in the
     // chart grid — not just on data point markers — then map the pixel position back
     // to the nearest x-axis bucket so any click in a column triggers filtering.
@@ -398,8 +402,8 @@ export default class extends Controller {
       }
 
       if (this.getAxisType(currentOption) === 'time') {
-        const startValue = dataZoom.startValue || xAxisData[0];
-        const endValue = dataZoom.endValue || xAxisData[xAxisData.length - 1];
+        const startValue = dataZoom.startValue ?? xAxisData[0];
+        const endValue = dataZoom.endValue ?? xAxisData[xAxisData.length - 1];
 
         return {
           xAxis: xAxisData.filter(value => value >= startValue && value <= endValue),
@@ -410,8 +414,10 @@ export default class extends Controller {
         };
       }
 
-      const startValue = dataZoom.startValue || 0;
-      const endValue = dataZoom.endValue || xAxisData.length - 1;
+      // ?? not ||: index 0 is a valid category position, and `0 || fallback`
+      // silently widens the range back to the full axis.
+      const startValue = dataZoom.startValue ?? 0;
+      const endValue = dataZoom.endValue ?? xAxisData.length - 1;
 
       return {
         xAxis: xAxisData.slice(startValue, endValue + 1),

data/app/javascript/rails_pulse/controllers/pagination_controller.js

@@ -28,11 +28,15 @@ export default class extends Controller {
 
   // Restore the pagination limit from URL or session storage on page load
   restorePaginationLimit() {
+    // hasLimitTarget, not truthiness: accessing a missing Stimulus target throws
+    // rather than returning undefined, which would break connect() outright.
+    if (!this.hasLimitTarget) return
+
     // URL params take precedence over session storage
     const urlParams = new URLSearchParams(window.location.search)
     const urlLimit = urlParams.get('limit')
 
-    if (urlLimit && this.limitTarget) {
+    if (urlLimit) {
       // Sync sessionStorage with URL param
       sessionStorage.setItem(this.storageKeyValue, urlLimit)
       if (this.limitTarget.value !== urlLimit) {
@@ -41,7 +45,7 @@ export default class extends Controller {
     } else {
       // Fall back to sessionStorage if no URL param
       const savedLimit = sessionStorage.getItem(this.storageKeyValue)
-      if (savedLimit && this.limitTarget && this.limitTarget.value !== savedLimit) {
+      if (savedLimit && this.limitTarget.value !== savedLimit) {
         this.limitTarget.value = savedLimit
       }
     }

data/app/javascript/rails_pulse/controllers/popover_controller.js

@@ -42,6 +42,10 @@ export default class extends Controller {
   }
 
   disconnect() {
+    // A pending debouncedShow would otherwise fire showPopover() on an element
+    // that has already been removed (e.g. the table was replaced by a fetch).
+    clearTimeout(this.#showTimer)
+    clearTimeout(this.#hideTimer)
     this.cleanup()
   }
 

data/app/models/concerns/rails_pulse/taggable.rb

@@ -5,20 +5,25 @@ module RailsPulse
     # Tag validation constants
     TAG_NAME_REGEX = /\A[a-z0-9_-]+\z/i
     MAX_TAG_LENGTH = 50
+    # Escape character for LIKE patterns over the serialized tags column.
+    # Never appears in a valid tag name, and needs no quoting on any adapter.
+    LIKE_ESCAPE = "!".freeze
 
     included do
       # Callbacks
       before_save :ensure_tags_is_array
 
-      # Scopes with table name qualification to avoid ambiguity
-      # Note: LIKE patterns are sanitized to prevent SQL injection via wildcards
+      # Scopes with table name qualification to avoid ambiguity.
+      # LIKE patterns are sanitized so `_`/`%` in a tag are matched literally.
+      # The ESCAPE clause is explicit because SQLite has no default escape
+      # character — without it `my\_tag` matches a literal backslash there
+      # and the filter silently matches nothing. `!` is used rather than `\`
+      # because MySQL and PostgreSQL disagree on how to quote a backslash.
       scope :with_tag, ->(tag) {
-        sanitized_tag = sanitize_sql_like(tag.to_s, "\\")
-        where("#{table_name}.tags LIKE ?", "%\"#{sanitized_tag}\"%")
+        where("#{table_name}.tags LIKE ? ESCAPE '!'", "%\"#{sanitize_sql_like(tag.to_s, LIKE_ESCAPE)}\"%")
       }
       scope :without_tag, ->(tag) {
-        sanitized_tag = sanitize_sql_like(tag.to_s, "\\")
-        where.not("#{table_name}.tags LIKE ?", "%\"#{sanitized_tag}\"%")
+        where.not("#{table_name}.tags LIKE ? ESCAPE '!'", "%\"#{sanitize_sql_like(tag.to_s, LIKE_ESCAPE)}\"%")
       }
       scope :with_tags, -> { where("#{table_name}.tags IS NOT NULL AND #{table_name}.tags != '[]'") }
     end

data/app/models/rails_pulse/cards/base.rb

@@ -173,6 +173,59 @@ module RailsPulse
         [ icon, format_percentage(percentage.abs, precision) ]
       end
 
+      # Compares a subject against its own history rather than against the
+      # immediately preceding window.
+      #
+      # The period-over-period arrow above answers "is this week worse than last
+      # week?", which is noisy — last week may itself have been unusual. This
+      # answers "is this worse than how this normally behaves?", which is the
+      # question the number is actually being read for.
+      #
+      # Only available where there is a single subject to have a history. Index
+      # pages aggregate across every route or query, so they keep the
+      # period-over-period arrow.
+      #
+      # @return [Array(String, String, String), nil] icon, amount, caption
+      def baseline_trend_for(subject, metric:)
+        return nil if subject.nil?
+
+        comparison = RailsPulse::Operations::Compare.call(subject, metric: metric)
+        return nil unless comparison.sufficient_data?
+
+        percentage = comparison.percent_change
+
+        icon = if percentage.abs < 0.1
+          "move-right"
+        elsif percentage.positive?
+          "trending-up"
+        else
+          "trending-down"
+        end
+
+        [ icon, format_percentage(percentage.abs, 1), baseline_caption(comparison) ]
+      end
+
+      # Names the change point only when there is a regression to explain. On a
+      # healthy metric "since Aug 26" would be noise, and locating it costs a
+      # second query that is not worth spending to say nothing.
+      def baseline_caption(comparison)
+        caption = "Compared to its #{baseline_window_text} normal"
+        return caption unless comparison.regression?
+
+        change_point = RailsPulse::Operations::ChangePoint.call(
+          comparison.subject, metric: comparison.metric
+        )
+        return caption if change_point.nil?
+
+        stamp = change_point.hourly? ? change_point.at.strftime("%b %-d %H:%M") : change_point.at.strftime("%b %-d")
+        "#{caption} · since #{stamp}"
+      end
+
+      def baseline_window_text
+        days = (RailsPulse.configuration.baseline_window / 1.day).round
+        "#{days}-day"
+      end
+
       # Existing format helpers (keep as-is)
       def format_percentage(value, precision = 1)
         "#{value.round(precision)}%"

data/app/models/rails_pulse/dashboard/health_summary.rb

@@ -11,6 +11,7 @@ module RailsPulse
         @route_thresholds = RailsPulse.configuration.route_thresholds
         @query_thresholds = RailsPulse.configuration.query_thresholds
         @job_thresholds   = RailsPulse.configuration.job_thresholds
+        @exception_thresholds = RailsPulse.configuration.exception_thresholds
       end
 
       def to_health_data
@@ -18,6 +19,7 @@ module RailsPulse
           routes:   route_counts,
           queries:  query_counts,
           jobs:     job_counts,
+          exceptions: exception_counts,
           storage:  storage_counts
         }
       end
@@ -108,6 +110,56 @@ module RailsPulse
 
         { healthy: healthy, slow: slow, critical: critical }
       end
+
+      # Exception groups classified by how often they fired over the dashboard
+      # period, read from summaries rather than from ExceptionGroup's lifetime
+      # occurrence_count — a group that fired ten thousand times last year and
+      # is now silent is not a critical problem today.
+      #
+      # A group with occurrences in the period but below the warning threshold
+      # counts as "slow" rather than "healthy": an exception happening at all is
+      # not healthy, it is just not yet urgent.
+      def exception_counts
+        return nil unless RailsPulse.configuration.track_exceptions
+        return nil unless exception_summaries_available?
+
+        start, finish = period_range
+
+        counts = RailsPulse::Summary
+          .for_exceptions
+          .where.not(summarizable_id: 0)
+          .where(period_start: start..finish)
+          .group(:summarizable_id)
+          .sum(:count)
+
+        healthy = slow = critical = 0
+
+        open_group_ids.each do |group_id|
+          occurrences = counts[group_id].to_i
+
+          if occurrences >= @exception_thresholds[:critical]
+            critical += 1
+          elsif occurrences >= @exception_thresholds[:warning]
+            slow += 1
+          elsif occurrences.positive?
+            slow += 1
+          else
+            healthy += 1
+          end
+        end
+
+        { healthy: healthy, slow: slow, critical: critical }
+      end
+
+      def open_group_ids
+        RailsPulse::ExceptionGroup.where(status: "open").pluck(:id)
+      end
+
+      def exception_summaries_available?
+        RailsPulse::ExceptionGroup.table_exists?
+      rescue ActiveRecord::ActiveRecordError
+        false
+      end
     end
   end
 end