rails_pulse 0.4.0.pre.4 → 0.4.0

data/app/models/rails_pulse/exceptions/cards/exception_rate.rb

@@ -98,11 +98,7 @@ module RailsPulse
         def grouped_counts(scope)
           scoped = scope.where(period_type: @period_type, period_start: current_window_start..now)
 
-          if period_type_hours?
-            scoped.group_by_hour(:period_start).sum("rails_pulse_summaries.count")
-          else
-            scoped.group_by_date(:period_start).sum("rails_pulse_summaries.count")
-          end
+          bucket_by_period(scoped) { |relation| relation.sum("rails_pulse_summaries.count") }
         end
 
         def period_stat(exceptions, requests)

data/app/models/rails_pulse/exceptions/cards/open_groups.rb

@@ -25,10 +25,10 @@ module RailsPulse
             .where(first_seen_at: current_window_start..now)
             .count
 
-          grouped = RailsPulse::ExceptionGroup
-            .where(first_seen_at: current_window_start..now)
-            .group_by_date(:first_seen_at)
-            .count
+          grouped = bucket_by_period(
+            RailsPulse::ExceptionGroup.where(first_seen_at: current_window_start..now),
+            column: :first_seen_at
+          ) { |relation| relation.count }
 
           {
             id: "exceptions_open_groups",

data/app/models/rails_pulse/exceptions/cards/total_occurrences.rb

@@ -36,10 +36,9 @@ module RailsPulse
           # what it means on a throughput card.
           trend_icon, trend_amount = trend_for(current, previous) if show_trend?
 
-          grouped = base_query
-            .where(period_start: current_window_start..now)
-            .group_by_date(:period_start)
-            .sum("rails_pulse_summaries.count")
+          grouped = bucket_by_period(base_query.where(period_start: current_window_start..now)) do |relation|
+            relation.sum("rails_pulse_summaries.count")
+          end
 
           {
             id: "exceptions_total_occurrences",

data/app/models/rails_pulse/jobs/cards/failure_rate.rb

@@ -2,12 +2,14 @@ module RailsPulse
   module Jobs
     module Cards
       class FailureRate < RailsPulse::Cards::Base
-        def initialize(job: nil, disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day")
+        def initialize(job: nil, disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day", start_time: nil, end_time: nil)
           @job = job
           @disabled_tags = disabled_tags
           @show_non_tagged = show_non_tagged
           @period = period
           @period_type = period_type
+          @start_time = start_time
+          @end_time = end_time
         end
 
         def to_metric_card
@@ -52,13 +54,8 @@ module RailsPulse
             )
           sparkline_query = sparkline_query.where(summarizable_id: @job.id) if @job
 
-          if @period_type == "hour"
-            grouped_errors = sparkline_query.group_by_hour(:period_start).sum("rails_pulse_summaries.error_count")
-            grouped_counts = sparkline_query.group_by_hour(:period_start).sum("rails_pulse_summaries.count")
-          else
-            grouped_errors = sparkline_query.group_by_date(:period_start).sum("rails_pulse_summaries.error_count")
-            grouped_counts = sparkline_query.group_by_date(:period_start).sum("rails_pulse_summaries.count")
-          end
+          grouped_errors = bucket_by_period(sparkline_query) { |relation| relation.sum("rails_pulse_summaries.error_count") }
+          grouped_counts = bucket_by_period(sparkline_query) { |relation| relation.sum("rails_pulse_summaries.count") }
 
           sparkline_data = sparkline_from_failure_rates(grouped_errors, grouped_counts)
 
@@ -88,25 +85,15 @@ module RailsPulse
 
         def sparkline_from_failure_rates(errors_by_period, counts_by_period)
           if @period_type == "hour"
-            start_time = current_window_start.beginning_of_hour
-            end_time = now.beginning_of_hour
-            result = {}
-
-            current_time = start_time
-            while current_time <= end_time
+            sparkline_hours.each_with_object({}) do |current_time, result|
               errors = errors_by_period[current_time].to_f
               total = counts_by_period[current_time].to_f
               rate = total.zero? ? 0.0 : (errors / total * 100).round(1)
               # Use timestamp in milliseconds as key to preserve uniqueness across days
               result[current_time.to_i * 1000] = { value: rate }
-              current_time += 1.hour
             end
-            result
           else
-            start_date = current_window_start.to_date
-            end_date = now.to_date
-
-            (start_date..end_date).each_with_object({}) do |day, hash|
+            sparkline_dates.each_with_object({}) do |day, hash|
               errors = errors_by_period[day].to_f
               total = counts_by_period[day].to_f
               rate = total.zero? ? 0.0 : (errors / total * 100).round(1)

data/app/models/rails_pulse/jobs/cards/p95_duration.rb

@@ -2,12 +2,14 @@ module RailsPulse
   module Jobs
     module Cards
       class P95Duration < RailsPulse::Cards::Base
-        def initialize(job: nil, disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day")
+        def initialize(job: nil, disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day", start_time: nil, end_time: nil)
           @job = job
           @disabled_tags = disabled_tags
           @show_non_tagged = show_non_tagged
           @period = period
           @period_type = period_type
+          @start_time = start_time
+          @end_time = end_time
         end
 
         def to_metric_card
@@ -48,13 +50,8 @@ module RailsPulse
             trend_icon, trend_amount = trend_for(current_p95, previous_p95)
           end
 
-          grouped_weighted = base_query
-            .group_by_date(:period_start)
-            .sum(Arel.sql("rails_pulse_summaries.p95_duration * rails_pulse_summaries.count"))
-
-          grouped_counts = base_query
-            .group_by_date(:period_start)
-            .sum("rails_pulse_summaries.count")
+          grouped_weighted = bucket_by_period(base_query) { |relation| relation.sum(Arel.sql("rails_pulse_summaries.p95_duration * rails_pulse_summaries.count")) }
+          grouped_counts = bucket_by_period(base_query) { |relation| relation.sum("rails_pulse_summaries.count") }
 
           sparkline_data = sparkline_from_averages(grouped_weighted, grouped_counts)
 

data/app/models/rails_pulse/jobs/cards/total_runs.rb

@@ -2,12 +2,14 @@ module RailsPulse
   module Jobs
     module Cards
       class TotalRuns < RailsPulse::Cards::Base
-        def initialize(job: nil, disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day")
+        def initialize(job: nil, disabled_tags: [], show_non_tagged: true, period: 14, period_type: "day", start_time: nil, end_time: nil)
           @job = job
           @disabled_tags = disabled_tags
           @show_non_tagged = show_non_tagged
           @period = period
           @period_type = period_type
+          @start_time = start_time
+          @end_time = end_time
         end
 
         def to_metric_card
@@ -32,9 +34,7 @@ module RailsPulse
 
           trend_icon, trend_amount = trend_for(current_runs, previous_runs) if show_trend?
 
-          grouped_runs = base_query
-            .group_by_date(:period_start)
-            .sum("rails_pulse_summaries.count")
+          grouped_runs = bucket_by_period(base_query) { |relation| relation.sum("rails_pulse_summaries.count") }
 
           {
             id: "jobs_total_runs",

data/app/models/rails_pulse/queries/cards/average_query_times.rb

@@ -2,12 +2,14 @@ module RailsPulse
   module Queries
     module Cards
       class AverageQueryTimes < RailsPulse::Cards::Base
-        def initialize(query: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day")
+        def initialize(query: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day", start_time: nil, end_time: nil)
           @query = query
           @disabled_tags = disabled_tags
           @show_non_tagged = show_non_tagged
           @period = period
           @period_type = period_type
+          @start_time = start_time
+          @end_time = end_time
         end
 
         def to_metric_card
@@ -32,16 +34,11 @@ module RailsPulse
           trend_icon, trend_amount = trend_for(current_period_avg, previous_period_avg) if show_trend?
 
           # Sparkline data with zero-filled periods
-          grouped_weighted = base_query
-            .group_by_date(:period_start)
-            .sum(Arel.sql("avg_duration * count"))
-
-          grouped_counts = base_query
-            .group_by_date(:period_start)
-            .sum(:count)
+          grouped_weighted = bucket_by_period(base_query) { |relation| relation.sum(Arel.sql("avg_duration * count")) }
+          grouped_counts = bucket_by_period(base_query) { |relation| relation.sum(:count) }
 
           # Calculate weighted averages for each period
-          averages_by_period = grouped_weighted.transform_keys(&:to_date).transform_values.with_index do |(weighted, day), _|
+          averages_by_period = grouped_weighted.transform_values.with_index do |(weighted, day), _|
             count = grouped_counts[day] || 0
             count > 0 ? (weighted.to_f / count).round(0) : 0
           end

data/app/models/rails_pulse/queries/cards/database_load.rb

@@ -2,11 +2,13 @@ module RailsPulse
   module Queries
     module Cards
       class DatabaseLoad < RailsPulse::Cards::Base
-        def initialize(disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day")
+        def initialize(disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day", start_time: nil, end_time: nil)
           @disabled_tags = disabled_tags
           @show_non_tagged = show_non_tagged
           @period = period
           @period_type = period_type
+          @start_time = start_time
+          @end_time = end_time
         end
 
         def to_metric_card
@@ -63,8 +65,8 @@ module RailsPulse
 
           # Sparkline data - group by hour or day depending on period_type
           if period_type_hours?
-            start_time = current_window_start
-            end_time = now.beginning_of_hour
+            start_time = sparkline_hours.first
+            end_time = sparkline_hours.last
 
             # Create separate queries for sparkline data using only the current period
             sparkline_query_summaries = RailsPulse::Summary
@@ -91,8 +93,7 @@ module RailsPulse
               .transform_values { |summaries| summaries.sum { |s| s.total_duration || 0 } }
 
             sparkline_data = {}
-            current_time = start_time
-            while current_time <= end_time
+            sparkline_hours.each do |current_time|
               query_time = hourly_query_time[current_time] || 0
               request_time = hourly_request_time[current_time] || 0
               percentage = request_time > 0 ? (query_time.to_f / request_time * 100).round(1) : 0
@@ -111,12 +112,8 @@ module RailsPulse
                 value: percentage,
                 itemStyle: { color: color }
               }
-              current_time += 1.hour
             end
           else
-            start_day = current_window_start.to_date
-            end_day = now.to_date
-
             # Group by day
             daily_query_time = query_summaries.group_by { |s| s.period_start.to_date }
               .transform_values { |summaries| summaries.sum { |s| s.total_duration || 0 } }
@@ -125,7 +122,7 @@ module RailsPulse
               .transform_values { |summaries| summaries.sum { |s| s.total_duration || 0 } }
 
             sparkline_data = {}
-            (start_day..end_day).each do |day|
+            sparkline_dates.each do |day|
               query_time = daily_query_time[day] || 0
               request_time = daily_request_time[day] || 0
               percentage = request_time > 0 ? (query_time.to_f / request_time * 100).round(1) : 0

data/app/models/rails_pulse/queries/cards/execution_rate.rb

@@ -2,12 +2,14 @@ module RailsPulse
   module Queries
     module Cards
       class ExecutionRate < RailsPulse::Cards::Base
-        def initialize(query: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day")
+        def initialize(query: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day", start_time: nil, end_time: nil)
           @query = query
           @disabled_tags = disabled_tags
           @show_non_tagged = show_non_tagged
           @period = period
           @period_type = period_type
+          @start_time = start_time
+          @end_time = end_time
         end
 
         def to_metric_card
@@ -38,11 +40,7 @@ module RailsPulse
             )
           sparkline_query = sparkline_query.where(summarizable_id: @query.id) if @query
 
-          if period_type_hours?
-            grouped_data = sparkline_query.group_by_hour(:period_start).sum(:count)
-          else
-            grouped_data = sparkline_query.group_by_date(:period_start).sum(:count)
-          end
+          grouped_data = bucket_by_period(sparkline_query) { |relation| relation.sum(:count) }
 
           # Use base class sparkline generation (handles hour vs day automatically)
           sparkline_data = sparkline_from(grouped_data)

data/app/models/rails_pulse/queries/cards/percentile_query_times.rb

@@ -2,12 +2,14 @@ module RailsPulse
   module Queries
     module Cards
       class PercentileQueryTimes < RailsPulse::Cards::Base
-        def initialize(query: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day")
+        def initialize(query: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day", start_time: nil, end_time: nil)
           @query = query
           @disabled_tags = disabled_tags
           @show_non_tagged = show_non_tagged
           @period = period
           @period_type = period_type
+          @start_time = start_time
+          @end_time = end_time
         end
 
         def to_metric_card
@@ -44,13 +46,8 @@ module RailsPulse
             )
           sparkline_query = sparkline_query.where(summarizable_id: @query.id) if @query
 
-          if period_type_hours?
-            weighted_sums = sparkline_query.group_by_hour(:period_start).sum("p95_duration * count")
-            period_counts = sparkline_query.group_by_hour(:period_start).sum(:count)
-          else
-            weighted_sums = sparkline_query.group_by_date(:period_start).sum("p95_duration * count")
-            period_counts = sparkline_query.group_by_date(:period_start).sum(:count)
-          end
+          weighted_sums = bucket_by_period(sparkline_query) { |relation| relation.sum("p95_duration * count") }
+          period_counts = bucket_by_period(sparkline_query) { |relation| relation.sum(:count) }
 
           # Calculate weighted averages for each period
           averages_by_period = weighted_sums.each_with_object({}) do |(period, weighted), hash|

data/app/models/rails_pulse/route.rb

@@ -70,11 +70,17 @@ module RailsPulse
     # True when at least one stored route still has no action but the live
     # host router would assign one — the usual sign that schema migrated
     # without `rails rails_pulse:migrate_routes`.
+    # Runs on every dashboard page, so the common case (every route already
+    # has an action) must be one indexed query; router recognition only
+    # happens when there is something to recognise.
     def self.needs_action_backfill?
       return false unless column_names.include?("controller_action")
       return false unless column_names.include?("http_methods")
 
-      where(controller_action: [ nil, "" ]).limit(25).any? do |route|
+      blank_action = where(controller_action: [ nil, "" ])
+      return false unless blank_action.exists?
+
+      blank_action.limit(25).any? do |route|
         method = route.http_methods_list.first
         next false if method.blank?
 

data/app/models/rails_pulse/routes/cards/error_rates.rb

@@ -2,12 +2,14 @@ module RailsPulse
   module Routes
     module Cards
       class ErrorRates < RailsPulse::Cards::Base
-        def initialize(route: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day")
+        def initialize(route: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day", start_time: nil, end_time: nil)
           @route = route
           @disabled_tags = disabled_tags
           @show_non_tagged = show_non_tagged
           @period = period
           @period_type = period_type
+          @start_time = start_time
+          @end_time = end_time
         end
 
         def to_metric_card
@@ -76,22 +78,14 @@ module RailsPulse
 
         def sparkline_from_error_rates(errors_by_period, client_errors_by_period, counts_by_period)
           if @period_type == "hour"
-            start_time = current_window_start.beginning_of_hour
-            end_time   = now.beginning_of_hour
-            result = {}
-            current_time = start_time
-            while current_time <= end_time
+            sparkline_hours.each_with_object({}) do |current_time, result|
               errors = errors_by_period[current_time].to_f + client_errors_by_period[current_time].to_f
               total  = counts_by_period[current_time].to_f
               rate   = total.zero? ? 0.0 : (errors / total * 100).round(2)
               result[current_time.to_i * 1000] = { value: rate }
-              current_time += 1.hour
             end
-            result
           else
-            start_date = current_window_start.to_date
-            end_date   = now.to_date
-            (start_date..end_date).each_with_object({}) do |day, hash|
+            sparkline_dates.each_with_object({}) do |day, hash|
               errors = errors_by_period[day].to_f + client_errors_by_period[day].to_f
               total  = counts_by_period[day].to_f
               rate   = total.zero? ? 0.0 : (errors / total * 100).round(2)

data/app/models/rails_pulse/routes/cards/percentile_response_times.rb

@@ -2,12 +2,14 @@ module RailsPulse
   module Routes
     module Cards
       class PercentileResponseTimes < RailsPulse::Cards::Base
-        def initialize(route: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day")
+        def initialize(route: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day", start_time: nil, end_time: nil)
           @route = route
           @disabled_tags = disabled_tags
           @show_non_tagged = show_non_tagged
           @period = period
           @period_type = period_type
+          @start_time = start_time
+          @end_time = end_time
         end
 
         def to_metric_card

data/app/models/rails_pulse/routes/cards/request_count_totals.rb

@@ -2,12 +2,14 @@ module RailsPulse
   module Routes
     module Cards
       class RequestCountTotals < RailsPulse::Cards::Base
-        def initialize(route: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day")
+        def initialize(route: nil, disabled_tags: [], show_non_tagged: true, period: 7, period_type: "day", start_time: nil, end_time: nil)
           @route = route
           @disabled_tags = disabled_tags
           @show_non_tagged = show_non_tagged
           @period = period
           @period_type = period_type
+          @start_time = start_time
+          @end_time = end_time
         end
 
         def to_metric_card
@@ -42,11 +44,7 @@ module RailsPulse
             )
           sparkline_query = sparkline_query.where(summarizable_id: @route.id) if @route
 
-          if period_type_hours?
-            grouped_data = sparkline_query.group_by_hour(:period_start).sum(:count)
-          else
-            grouped_data = sparkline_query.group_by_date(:period_start).sum(:count)
-          end
+          grouped_data = bucket_by_period(sparkline_query) { |relation| relation.sum(:count) }
 
           # Use base class sparkline generation (handles hour vs day automatically)
           sparkline_data = sparkline_from(grouped_data)

data/app/models/rails_pulse/summary.rb

@@ -55,26 +55,21 @@ module RailsPulse
       # Return early if no filters are applied
       return all if actual_disabled_tags.empty? && show_non_tagged
 
-      # Get filtered IDs from TagFilterService
-      filtered_ids = TagFilterService.filter_all(disabled_tags, show_non_tagged)
-
-      route_ids = filtered_ids[:route_ids].presence || [ -1 ]
-      query_ids = filtered_ids[:query_ids].presence || [ -1 ]
-      job_ids = filtered_ids[:job_ids].presence || [ -1 ]
+      # One subquery per summarizable kind. This scope runs on every card and
+      # chart query, so the alternative (plucking every matching route, query
+      # and job id and inlining the lists) cost three extra statements per
+      # call and grew each statement with the size of the tables.
+      table = arel_table
+      keep_for = lambda do |type, model|
+        matching = TagFilterService.scope(model, actual_disabled_tags, show_non_tagged).select(:id).arel
+        table[:summarizable_type].eq(type).and(table[:summarizable_id].in(matching))
+      end
 
-      # Apply filters: include only summaries for filtered routes/queries/jobs
-      # Use -1 as an impossible ID when no items match the filter
       where(
-        "(" \
-        "  (summarizable_type = 'RailsPulse::Route' AND summarizable_id IN (?)) OR " \
-        "  (summarizable_type = 'RailsPulse::Query' AND summarizable_id IN (?)) OR " \
-        "  (summarizable_type = 'RailsPulse::Job' AND summarizable_id IN (?)) OR " \
-        "  (summarizable_type = 'RailsPulse::Request') OR " \
-        "  (summarizable_type = 'RailsPulse::ExceptionGroup')" \
-        ")",
-        route_ids,
-        query_ids,
-        job_ids
+        keep_for.call("RailsPulse::Route", Route)
+          .or(keep_for.call("RailsPulse::Query", Query))
+          .or(keep_for.call("RailsPulse::Job", Job))
+          .or(table[:summarizable_type].in([ "RailsPulse::Request", "RailsPulse::ExceptionGroup" ]))
       )
     }
 

data/app/models/rails_pulse/time_range_preference.rb

@@ -0,0 +1,28 @@
+module RailsPulse
+  # Normalizes the time range preference stored in the session so every
+  # reader sees the same shape regardless of which session store wrote it.
+  #
+  # The cookie store round-trips through JSON and stringifies hash keys, but a
+  # Marshal-backed store (activerecord-session_store's default) hands back the
+  # symbol keys the writer used. Readers that only knew one shape raised
+  # NoMethodError on the other and locked the dashboard into 500s for the rest
+  # of the browser session.
+  module TimeRangePreference
+    # A preset name as a String, a custom range as a string-keyed Hash, or nil
+    # for anything unrecognized so callers fall back to their defaults.
+    def self.normalize(value)
+      case value
+      when Hash
+        value.to_h.transform_keys(&:to_s)
+      when String, Symbol
+        value.to_s
+      else
+        nil
+      end
+    end
+
+    def self.custom?(preference)
+      preference.is_a?(Hash) && preference["type"] == "custom"
+    end
+  end
+end

data/app/models/rails_pulse/time_window.rb

@@ -0,0 +1,61 @@
+module RailsPulse
+  # A resolved start/end range plus the bucketing helpers charts and cards
+  # need: day count, calendar dates/hour-starts inside it, and the
+  # equal-length prior window for comparisons.
+  class TimeWindow
+    attr_reader :start_time, :end_time
+
+    # nil (not raised) when either bound is missing — callers already have
+    # a "no range selected" fallback to use instead.
+    def self.build(start_time, end_time)
+      return nil if start_time.nil? || end_time.nil?
+
+      new(start_time, end_time)
+    end
+
+    def initialize(start_time, end_time)
+      @start_time = coerce(start_time)
+      @end_time = coerce(end_time)
+    end
+
+    # Whole days spanned, rounded rather than truncated (a range a few
+    # seconds short of N days still counts as N). Always at least 1.
+    def days
+      [ ((end_time - start_time) / 1.day).round, 1 ].max
+    end
+
+    # Every full calendar day inside the window, ascending. Skips a leading
+    # day whose midnight falls before the window start.
+    def dates
+      first_date = start_time.beginning_of_day == start_time ? start_time.to_date : (start_time.to_date + 1)
+      return [] if first_date > end_time.to_date
+
+      (first_date..end_time.to_date).to_a
+    end
+
+    # Every hour-start inside the window, ascending.
+    def hour_starts
+      starts = []
+      current = start_time.beginning_of_hour
+      current += 1.hour if current < start_time
+      while current <= end_time
+        starts << current
+        current += 1.hour
+      end
+      starts
+    end
+
+    # The window of the same length immediately preceding this one, for
+    # period-over-period comparisons. `unit` is "day" or "hour".
+    def previous(unit)
+      span = unit == "hour" ? (end_time - start_time) : days.days
+      self.class.new(start_time - span, start_time)
+    end
+
+    private
+
+    def coerce(value)
+      value.is_a?(Numeric) ? Time.zone.at(value) : value.in_time_zone
+    end
+  end
+end