rails_pulse 0.4.2 → 0.5.0.pre.1

data/app/controllers/rails_pulse/api/v1/routes_controller.rb

@@ -0,0 +1,98 @@
+module RailsPulse
+  module Api
+    module V1
+      class RoutesController < BaseController
+        SORT_COLUMNS = %w[request_count avg_duration error_count].freeze
+
+        def index
+          parsed_range = time_range
+          return unless parsed_range
+          since_start, until_end = parsed_range
+
+          sort = params[:sort].presence
+          if sort && !SORT_COLUMNS.include?(sort)
+            return render json: { error: "Invalid sort. Valid values: #{SORT_COLUMNS.join(', ')}" }, status: :bad_request
+          end
+
+          scope = RailsPulse::Route.all
+          if params[:search].present?
+            term = RailsPulse::LikePattern.containing(params[:search].downcase)
+            scope = scope.where(
+              "LOWER(path) LIKE :term #{RailsPulse::LikePattern::CLAUSE} " \
+              "OR LOWER(controller_action) LIKE :term #{RailsPulse::LikePattern::CLAUSE}",
+              term: term
+            )
+          end
+
+          if since_start || until_end || sort
+            since_start ||= 24.hours.ago if until_end.nil?
+            render_with_stats(scope, since_start..until_end, sort || "request_count")
+          else
+            data, meta = paginated(scope.order(:path, :id))
+            render json: { data: data.map { |route| RouteSerializer.serialize(route) }, meta: meta }
+          end
+        end
+
+        private
+
+        def render_with_stats(scope, range, sort)
+          base = RailsPulse::Request.where(occurred_at: range)
+          base = base.where(route_id: scope.select(:id)) if params[:search].present?
+
+          # HAVING rather than a filter over the fetched page: a route busy
+          # enough to qualify can rank below the limit, and dropping it after
+          # the fact returns nothing while an answer exists.
+          grouped = base.group(:route_id)
+          grouped = grouped.having("COUNT(*) >= ?", min_requests) if min_requests > 1
+
+          # Grouping yields one row per route, so counting the rows counts the
+          # routes that qualify.
+          routes_with_traffic = base.distinct.count(:route_id)
+          total = min_requests > 1 ? grouped.count.size : routes_with_traffic
+
+          # CASE WHEN on the boolean column itself is valid on SQLite, PostgreSQL
+          # and MySQL alike, so no adapter-specific literal is interpolated.
+          rows = grouped
+            .select(
+              "route_id, COUNT(*) AS request_count, AVG(duration) AS avg_duration, " \
+              "SUM(CASE WHEN is_error THEN 1 ELSE 0 END) AS error_count"
+            )
+            # route_id breaks ties so offset pages neither repeat nor skip rows.
+            .order(Arel.sql("#{sort} DESC, route_id ASC"))
+            .limit(limit)
+            .offset(offset)
+            .to_a
+
+          routes = RailsPulse::Route.where(id: rows.map(&:route_id)).index_by(&:id)
+          data = rows.filter_map do |row|
+            route = routes[row.route_id]
+            RouteSerializer.serialize(route, stats: stats_for(row)) if route
+          end
+
+          meta = { total: total, limit: limit, offset: offset }
+          # Lets a caller tell "nothing ran in this window" from "nothing ran
+          # often enough", which are different next steps, without asking again
+          # at a lower threshold.
+          if min_requests > 1
+            meta[:min_requests] = min_requests
+            meta[:routes_with_traffic] = routes_with_traffic
+          end
+
+          render json: { data: data, meta: meta }
+        end
+
+        def min_requests
+          integer_param(:min_requests, 1, 1..MAX_INTEGER)
+        end
+
+        def stats_for(row)
+          {
+            request_count:   row.request_count.to_i,
+            avg_duration_ms: row.avg_duration.to_f.round(1),
+            error_count:     row.error_count.to_i
+          }
+        end
+      end
+    end
+  end
+end

data/app/controllers/rails_pulse/application_controller.rb

@@ -102,7 +102,7 @@ module RailsPulse
     private
 
     # The original string if it is short enough to live in the session and
-    # Time.parse accepts it (TimeRangeConcern parses it back the same way);
+    # Time.parse accepts it (RailsPulse::TimeRange parses it back the same way);
     # nil otherwise.
     def valid_time_param(value)
       value = value.to_s.strip

data/app/controllers/rails_pulse/dashboard_controller.rb

@@ -1,22 +1,16 @@
 module RailsPulse
   class DashboardController < ApplicationController
-    include TimeRangeConcern
     include DeploymentMarkersConcern
 
     def index
-      # Use TimeRangeConcern to get time range (supports time range selector + all other filters)
-      @start_time, @end_time, @selected_time_range, @time_diff = setup_time_range
+      @time_range = RailsPulse::TimeRange.resolve(
+        params: params, session: session, default_key: default_time_range_key
+      )
       populate_deployment_markers
 
-      # Rounded rather than truncated, so a range a few seconds short of N
-      # whole days still counts as N. Cards/charts also get @start_time/
-      # @end_time directly so they bucket the exact range, not "the last
-      # @period days ending now".
-      @period = RailsPulse::TimeWindow.new(@start_time, @end_time).days
-
-      # Determine period type based on time range
-      # If 24 hours or less, use hourly summaries, otherwise use daily
-      @period_type = @period <= 1 ? "hour" : "day"
+      window = @time_range.window
+      period = window.days
+      period_type = @time_range.period_type
 
       # Get tag filter values from session
       disabled_tags = session_disabled_tags
@@ -24,13 +18,13 @@ module RailsPulse
 
       card_and_chart_options = {
         disabled_tags: disabled_tags, show_non_tagged: show_non_tagged,
-        period: @period, period_type: @period_type,
-        start_time: @start_time, end_time: @end_time
+        period: period, period_type: period_type,
+        window: window
       }
 
-      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: nil, **card_and_chart_options).to_metric_card
-      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: nil, **card_and_chart_options).to_metric_card
-      @error_rates_metric_card = RailsPulse::Routes::Cards::ErrorRates.new(route: nil, **card_and_chart_options).to_metric_card
+      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(**card_and_chart_options).to_metric_card
+      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(**card_and_chart_options).to_metric_card
+      @error_rates_metric_card = RailsPulse::Routes::Cards::ErrorRates.new(**card_and_chart_options).to_metric_card
       @job_failure_rate_metric_card = RailsPulse::Jobs::Cards::FailureRate.new(**card_and_chart_options).to_metric_card if RailsPulse.configuration.track_jobs
 
       # Generate chart data for inline rendering
@@ -38,19 +32,25 @@ module RailsPulse
       @throughput_and_errors_chart_data = RailsPulse::Dashboard::Charts::ThroughputAndErrors.new(**card_and_chart_options).to_chart_data
 
       # Needs Attention panel
-      @needs_attention = RailsPulse::Dashboard::NeedsAttention.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, start_time: @start_time, end_time: @end_time).to_attention_data
+      @needs_attention = RailsPulse::Dashboard::NeedsAttention.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: period, window: window).to_attention_data
 
       # System Health bar
-      @health_summary = RailsPulse::Dashboard::HealthSummary.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: @period, start_time: @start_time, end_time: @end_time).to_health_data
+      @health_summary = RailsPulse::Dashboard::HealthSummary.new(disabled_tags: disabled_tags, show_non_tagged: show_non_tagged, period: period, window: window).to_health_data
 
       @storage_status = RailsPulse::Dashboard::StorageStatus.new(cached_sizes: true)
 
       # Deployments panel — scoped to the same window as the chart markers so
       # the panel and the markers drawn on the charts always agree.
-      deployments_in_range = RailsPulse::Deployment.for_range(Time.zone.at(@start_time), Time.zone.at(@end_time))
+      deployments_in_range = RailsPulse::Deployment.for_range(window.start_time, window.end_time)
       @deployment_count = deployments_in_range.count
       @recent_deployments = deployments_in_range.recent.limit(4)
       @last_deployment = RailsPulse::Deployment.recent.first
     end
+
+    private
+
+    def default_time_range_key
+      :last_24_hours
+    end
   end
 end

data/app/controllers/rails_pulse/deployments_controller.rb

@@ -6,7 +6,10 @@ module RailsPulse
     # widen the hole the 0.4.0 audit closed.
     skip_before_action :authenticate_rails_pulse_user!, only: %i[create finish]
     skip_before_action :verify_authenticity_token, only: %i[create finish]
-    before_action :authenticate_deployment_request!, only: %i[create finish]
+    # Prepended so the token is checked before the inherited callbacks run:
+    # the schema check would otherwise show an anonymous caller the list of
+    # missing tables, and the dashboard callbacks would query on its behalf.
+    prepend_before_action :authenticate_deployment_request!, only: %i[create finish]
 
     def index
       @ransack_query = Deployment.ransack(ransack_params)
@@ -53,19 +56,26 @@ module RailsPulse
 
     private
 
+    # Only config.deployment_token authorizes a write here. config.api_token
+    # reads the JSON API and is the credential given to CLI callers and coding
+    # agents, so accepting it would let any of them record a release.
+    #
+    # The dashboard login is never accepted instead. CSRF protection is off for
+    # these actions so CI can post, and a browser attaches a saved login (HTTP
+    # Basic in particular) to a request another site triggers, so a login
+    # fallback would let any page an admin visits record a release. A header
+    # token cannot be sent cross-site. The rake tasks run inside the app and
+    # need no token.
     def authenticate_deployment_request!
-      token = RailsPulse.configuration.deployment_api_token
-      if token.present?
-        provided = request.headers["X-Rails-Pulse-Token"].to_s
-        unless ActiveSupport::SecurityUtils.secure_compare(provided, token)
-          render json: { error: "Unauthorized" }, status: :unauthorized
-        end
-      elsif RailsPulse.configuration.authentication_enabled
-        authenticate_rails_pulse_user!
-      else
-        # No token configured and authentication disabled — fail closed.
-        # Without a token there is no way to verify the caller.
-        render json: { error: "Unauthorized — set deployment_api_token or enable authentication" }, status: :unauthorized
+      token = RailsPulse.configuration.deployment_token.to_s
+      if token.empty?
+        render json: { error: "Unauthorized — set config.deployment_token to record deployments over HTTP" }, status: :unauthorized
+        return
+      end
+
+      provided = request.headers["X-Rails-Pulse-Token"].to_s
+      unless ActiveSupport::SecurityUtils.secure_compare(provided, token)
+        render json: { error: "Unauthorized" }, status: :unauthorized
       end
     end
 

data/app/controllers/rails_pulse/exceptions_controller.rb

@@ -1,6 +1,6 @@
 module RailsPulse
   class ExceptionsController < ApplicationController
-    include TimeRangeConcern
+    include RansackParamsConcern
     include TagFilterConcern
     include DeploymentMarkersConcern
 
@@ -38,22 +38,20 @@ module RailsPulse
     # without them the page can say what is failing but not whether it is
     # getting worse, which is the question users actually arrive with.
     def setup_frequency_view
-      # Timestamps, not Times, to match every other index controller — the
-      # shared concerns and helpers that read @start_time expect integers.
-      @start_time, @end_time, @selected_time_range, @time_diff_hours = setup_time_range
+      @time_range = RailsPulse::TimeRange.resolve(
+        params: params, session: session, default_key: default_time_range_key
+      )
 
-      @period_type = @time_diff_hours <= 25 ? "hour" : "day"
-      period_days  = window_days_for(@selected_time_range)
+      period_days = window_days_for(@time_range.selected_time_range, @time_range.window)
 
       populate_deployment_markers
 
       @occurrence_volume_chart = Exceptions::Charts::OccurrenceVolume.new(
-        start_time: Time.zone.at(@start_time),
-        end_time: Time.zone.at(@end_time),
-        period_type: @period_type
+        window: @time_range.window,
+        period_type: @time_range.period_type
       ).to_chart_data
 
-      card_params = { period: period_days, period_type: @period_type }
+      card_params = { period: period_days, period_type: @time_range.period_type }
 
       @total_occurrences_metric_card = Exceptions::Cards::TotalOccurrences.new(**card_params).to_metric_card
       @exception_rate_metric_card    = Exceptions::Cards::ExceptionRate.new(**card_params).to_metric_card
@@ -67,13 +65,13 @@ module RailsPulse
     # The card copy ("compared to previous N days") has to name the range the
     # user picked. Measuring the span instead reads one day long, because the
     # range runs from the start of the first day to the end of the last.
-    def window_days_for(selected_range)
+    def window_days_for(selected_range, window)
       case selected_range.to_s
       when "last_24_hours" then 1
       when "last_7_days"   then 7
       when "last_14_days"  then 14
       when "last_30_days"  then 30
-      else [ ((@end_time - @start_time) / 1.day.to_i).round, 1 ].max
+      else window.days
       end
     end
 

data/app/controllers/rails_pulse/jobs_controller.rb

@@ -57,7 +57,7 @@ module RailsPulse
 
     # Pass the job to chart classes on show pages
     def chart_options
-      show_action? ? { job: @job } : {}
+      show_action? ? { subject: @job } : {}
     end
 
     # Jobs use polymorphic summaries, so we need to filter by type
@@ -102,7 +102,6 @@ module RailsPulse
         Jobs::Tables::Index.new(
           ransack_query: @ransack_query,
           period_type: period_type,
-          start_time: @start_time,
           params: params,
           disabled_tags: session_disabled_tags,
           show_non_tagged: session[:show_non_tagged] != false,

data/app/controllers/rails_pulse/queries_controller.rb

@@ -30,8 +30,7 @@ module RailsPulse
 
       # Database load chart doesn't use ransack_query, so generate it separately
       @database_load_chart_data = Queries::Charts::DatabaseLoad.new(
-        start_time: @start_time,
-        end_time: @end_time,
+        window: @time_range&.window,
         period_type: period_type,
         disabled_tags: session_disabled_tags,
         show_non_tagged: session[:show_non_tagged] != false
@@ -55,10 +54,13 @@ module RailsPulse
 
       # Database load card only shows on index page and doesn't accept query param
       if current_resource.nil?
+        window = @time_range&.window
+        period_days = window ? ((window.end_time - window.start_time) / 1.day).round : 7
+
         @database_load_metric_card = Queries::Cards::DatabaseLoad.new(
           disabled_tags: session_disabled_tags,
           show_non_tagged: session[:show_non_tagged] != false,
-          period: ((@end_time - @start_time) / 1.day).round,
+          period: period_days,
           period_type: period_type.to_s
         ).to_metric_card
       end
@@ -87,7 +89,7 @@ module RailsPulse
 
     # Pass the query to chart classes on show pages
     def chart_options
-      show_action? ? { query: @query } : {}
+      show_action? ? { subject: @query } : {}
     end
 
     # Queries use polymorphic summaries, so we need to filter by type
@@ -127,7 +129,6 @@ module RailsPulse
         Queries::Tables::Index.new(
           ransack_query: @ransack_query,
           period_type: period_type,
-          start_time: @start_time,
           params: params,
           disabled_tags: session_disabled_tags,
           show_non_tagged: session[:show_non_tagged] != false

data/app/controllers/rails_pulse/requests_controller.rb

@@ -40,23 +40,23 @@ module RailsPulse
 
     # Override: Requests aggregate all request data (summarizable_id: 0)
     # rather than scoping to a specific resource
-    # Also handles "recent" mode where @start_time may be nil
     def build_chart_ransack_params(ransack_params)
       base_params = ransack_params.except(:s).merge(
         summarizable_type_eq: "RailsPulse::Request",
         summarizable_id_eq: 0
       )
 
-      # Add time filters if we have time boundaries (not in "recent" mode)
-      if @start_time && @end_time
+      if @time_range&.window
         base_params.merge!(
-          period_start_gteq: Time.at(@start_time),
-          period_start_lt: Time.at(@end_time)
+          period_start_gteq: @time_range.window.start_time,
+          period_start_lt: @time_range.window.end_time
         )
       end
 
       # Only add duration filter if we have a meaningful threshold
-      base_params[:avg_duration_gteq] = @start_duration if @start_duration && @start_duration > 0
+      if @time_range&.start_duration && @time_range.start_duration > 0
+        base_params[:avg_duration_gteq] = @time_range.start_duration
+      end
       base_params
     end
 
@@ -67,25 +67,26 @@ module RailsPulse
       # Handle time mode - check if recent mode is selected
       time_mode = params[:period_start_range] || "recent"
 
-      if time_mode != "recent" && @table_start_time && @table_end_time
+      if time_mode != "recent" && @time_range&.table_window
         # Custom mode - apply time filters
         params.merge!(
-          occurred_at_gteq: Time.at(@table_start_time),
-          occurred_at_lt: Time.at(@table_end_time)
+          occurred_at_gteq: @time_range.table_window.start_time,
+          occurred_at_lt: @time_range.table_window.end_time
         )
       end
       # else: Recent mode - no time filters, just rely on sort + pagination
 
-      # Duration filter - convert symbol to numeric threshold or use @start_duration
+      start_duration = @time_range&.start_duration
+      # Duration filter - convert symbol to numeric threshold or use start_duration
       if params[:duration_gteq].present?
         # If it's a symbol like :slow, convert it to the numeric threshold
         if params[:duration_gteq].to_s.in?(%w[slow very_slow critical])
-          params[:duration_gteq] = @start_duration
+          params[:duration_gteq] = start_duration
         end
         # else: it's already a number, keep it as is
-      elsif @start_duration && @start_duration > 0
-        # No duration_gteq param, use @start_duration from concern
-        params[:duration_gteq] = @start_duration
+      elsif start_duration && start_duration > 0
+        # No duration_gteq param, use start_duration from @time_range
+        params[:duration_gteq] = start_duration
       end
 
       # Min response size filter - input is in KB, convert to bytes for the column

data/app/controllers/rails_pulse/routes_controller.rb

@@ -52,7 +52,7 @@ module RailsPulse
 
     # Pass the route to chart classes on show pages
     def chart_options
-      show_action? ? { route: @route } : {}
+      show_action? ? { subject: @route } : {}
     end
 
     def show_resource_filter
@@ -103,7 +103,6 @@ module RailsPulse
         Routes::Tables::Index.new(
           ransack_query: @ransack_query,
           period_type: period_type,
-          start_time: @start_time,
           params: params,
           disabled_tags: session_disabled_tags,
           show_non_tagged: session[:show_non_tagged] != false
@@ -135,17 +134,14 @@ module RailsPulse
     # day/week/month periods) so the table isn't just blank for old ranges.
     def setup_archived_summary_data
       cutoff = retention_cutoff
-      window_start = @page_timings&.table_start_time
+      table_window = @time_range&.table_window
 
-      scope = if cutoff && window_start && Time.at(window_start) < cutoff
+      scope = if cutoff && table_window && table_window.start_time < cutoff
         scope = Summary.for_routes
           .where(summarizable_id: @route.id)
           .where(period_type: period_type)
           .where("period_start < ?", cutoff)
-
-        if @page_timings&.table_end_time
-          scope = scope.where("period_start < ?", Time.at(@page_timings.table_end_time))
-        end
+          .where("period_start < ?", table_window.end_time)
 
         scope.order(period_start: :desc)
       else

data/app/helpers/rails_pulse/application_helper.rb

@@ -28,6 +28,21 @@ module RailsPulse
       end
     end
 
+    # Tooltip text for the chart-panel zone badge: the exact resolved interval
+    # (when a controller has resolved one) plus the aggregation zone every
+    # chart — hourly or daily — is consistently labeled in.
+    def time_range_zone_tooltip
+      zone = RailsPulse::TimeRange.aggregation_zone_label
+      lines = []
+
+      if (window = @time_range&.window)
+        lines << "Showing #{window.start_time.strftime('%b %-d, %Y %l:%M %p')} – #{window.end_time.strftime('%b %-d, %Y %l:%M %p')} (#{zone})"
+      end
+
+      lines << "All times are shown in #{zone}."
+      lines.join("\n")
+    end
+
     def page_url(page_number)
       url_for(request.query_parameters.merge(page: page_number))
     end

data/app/helpers/rails_pulse/chart_helper.rb

@@ -22,7 +22,14 @@ module RailsPulse
         rails_pulse__chart_type_value: type,
         rails_pulse__chart_data_value: data.to_json,
         rails_pulse__chart_options_value: chart_options.to_json,
-        rails_pulse__chart_theme_value: theme
+        rails_pulse__chart_theme_value: theme,
+        # Lets the chart format daily labels/tooltips in the zone summaries
+        # were actually bucketed in, instead of the browser's zone (which can
+        # land a daily boundary on the wrong calendar day — see #303). The
+        # short label keeps sparkline tooltips readable; the full zone name
+        # is in the badge's title next to each chart.
+        rails_pulse__chart_timezone_value: RailsPulse::TimeRange.aggregation_zone_iana,
+        rails_pulse__chart_timezone_label_value: RailsPulse::TimeRange.aggregation_zone_short_label
       }
 
       content_tag(:div, "",
@@ -34,7 +41,7 @@ module RailsPulse
 
     # Base chart options shared across all chart types
     def base_chart_options(units: nil, zoom: false)
-      hourly = @period_type == "hour" || (@time_diff_hours && @time_diff_hours <= 25)
+      hourly = @time_range&.period_type == "hour"
       x_formatter = hourly ? "time" : "timestamp_to_date"
       tooltip_formatter = units == "%" ? "tooltip_with_timestamp_rate" : "tooltip_with_timestamp"
       {

data/app/helpers/rails_pulse/formatting_helper.rb

@@ -2,20 +2,19 @@ module RailsPulse
   module FormattingHelper
     def human_readable_occurred_at(occurred_at)
       return "" unless occurred_at.present?
-      time = occurred_at.is_a?(String) ? Time.parse(occurred_at) : occurred_at
-      # Convert to local system timezone (same as charts use)
-      time.getlocal.strftime("%b %d, %Y %l:%M %p")
+      # Time.zone, not the server's OS zone — the same zone charts label as
+      # the aggregation zone, so this and the charts always agree.
+      time = occurred_at.is_a?(String) ? Time.zone.parse(occurred_at) : occurred_at
+      return "" if time.nil?
+      time.strftime("%b %d, %Y %l:%M %p")
     end
 
     def time_ago_in_words(time)
       return "Unknown" if time.blank?
 
-      # Convert to Time object if it's a string
-      time = Time.parse(time.to_s) if time.is_a?(String)
-      # Convert to local system timezone for consistent calculation
-      time = time.getlocal
+      time = Time.zone.parse(time.to_s) if time.is_a?(String)
 
-      seconds_ago = [ Time.now - time, 0 ].max
+      seconds_ago = [ Time.current - time, 0 ].max
 
       case seconds_ago
       when 0..59
@@ -37,10 +36,10 @@ module RailsPulse
     def human_readable_summary_period(summary)
       return "" unless summary&.period_start&.present? && summary&.period_end&.present?
 
-      # Convert UTC times to local system timezone to match chart display
-      start_time = summary.period_start.getlocal
-      end_time = summary.period_end.getlocal
-
+      # Already Time.zone-aware from ActiveRecord — the same aggregation
+      # zone charts label, so no conversion needed.
+      start_time = summary.period_start
+      end_time = summary.period_end
 
       case summary.period_type
       when "hour"