rails_pulse 0.1.1 → 0.1.2

data/app/controllers/concerns/time_range_concern.rb

@@ -6,8 +6,7 @@ module TimeRangeConcern
     const_set(:TIME_RANGE_OPTIONS, [
       [ "Last 24 hours", :last_day ],
       [ "Last Week", :last_week ],
-      [ "Last Month", :last_month ],
-      [ "All Time", :all_time ]
+      [ "Last Month", :last_month ]
     ].freeze)
   end
 
@@ -18,23 +17,19 @@ module TimeRangeConcern
 
     ransack_params = params[:q] || {}
 
-    if ransack_params[:requests_occurred_at_gteq].present?
-      # Custom time range from routes index chart zoom which filters requests through an association
-      start_time = parse_time_param(ransack_params[:requests_occurred_at_gteq])
-      end_time = parse_time_param(ransack_params[:requests_occurred_at_lt])
-    elsif ransack_params[:occurred_at_gteq].present?
+    if ransack_params[:occurred_at_gteq].present?
       # Custom time range from chart zoom where there is no association
       start_time = parse_time_param(ransack_params[:occurred_at_gteq])
       end_time = parse_time_param(ransack_params[:occurred_at_lt])
-    elsif ransack_params[:occurred_at_range]
+    elsif ransack_params[:period_start_range]
       # Predefined time range from dropdown
-      selected_time_range = ransack_params[:occurred_at_range]
+      selected_time_range = ransack_params[:period_start_range]
       start_time =
         case selected_time_range.to_sym
         when :last_day then 1.day.ago
         when :last_week then 1.week.ago
         when :last_month then 1.month.ago
-        when :all_time then 100.years.ago
+        else 1.day.ago # Default fallback
         end
     end
 

data/app/controllers/concerns/zoom_range_concern.rb

@@ -35,6 +35,6 @@ module ZoomRangeConcern
       end_time = end_time_obj&.end_of_day || end_time_obj
     end
 
-    [ start_time, end_time ]
+    [ start_time.to_i, end_time.to_i ]
   end
 end

data/app/controllers/rails_pulse/application_controller.rb

@@ -2,8 +2,9 @@ module RailsPulse
   class ApplicationController < ActionController::Base
     before_action :authenticate_rails_pulse_user!
 
-    def set_pagination_limit
-      session[:pagination_limit] = params[:limit].to_i if params[:limit].present?
+    def set_pagination_limit(limit = nil)
+      limit = limit || params[:limit]
+      session[:pagination_limit] = limit.to_i if limit.present?
       render json: { status: "ok" }
     end
 
@@ -54,8 +55,11 @@ module RailsPulse
     end
 
     def session_pagination_limit
-      # Keep default small for optimal performance
-      session[:pagination_limit] || 10
+      # Use URL param if present, otherwise session, otherwise default
+      limit = params[:limit].presence || session[:pagination_limit] || 10
+      # Update session if URL param was used
+      session[:pagination_limit] = limit.to_i if params[:limit].present?
+      limit.to_i
     end
 
     def store_pagination_limit(limit)

data/app/controllers/rails_pulse/dashboard_controller.rb

@@ -1,6 +1,18 @@
 module RailsPulse
   class DashboardController < ApplicationController
     def index
+      @average_query_times_metric_card = RailsPulse::Routes::Cards::AverageResponseTimes.new(route: nil).to_metric_card
+      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: nil).to_metric_card
+      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: nil).to_metric_card
+      @error_rate_per_route_metric_card = RailsPulse::Routes::Cards::ErrorRatePerRoute.new(route: nil).to_metric_card
+
+      # Generate chart data for inline rendering
+      @average_response_time_chart_data = RailsPulse::Dashboard::Charts::AverageResponseTime.new.to_chart_data
+      @p95_response_time_chart_data = RailsPulse::Dashboard::Charts::P95ResponseTime.new.to_chart_data
+
+      # Generate table data for inline rendering
+      @slow_routes_table_data = RailsPulse::Dashboard::Tables::SlowRoutes.new.to_table_data
+      @slow_queries_table_data = RailsPulse::Dashboard::Tables::SlowQueries.new.to_table_data
     end
   end
 end

data/app/controllers/rails_pulse/queries_controller.rb

@@ -5,21 +5,23 @@ module RailsPulse
     before_action :set_query, only: :show
 
     def index
+      setup_metric_cards
       setup_chart_and_table_data
     end
 
     def show
+      setup_metric_cards
       setup_chart_and_table_data
     end
 
     private
 
     def chart_model
-      show_action? ? Operation : Query
+      Summary
     end
 
     def table_model
-      show_action? ? Operation : Query
+      show_action? ? Operation : Summary
     end
 
     def chart_class
@@ -31,73 +33,67 @@ module RailsPulse
     end
 
     def build_chart_ransack_params(ransack_params)
-      base_params = ransack_params.except(:s)
+      base_params = ransack_params.except(:s).merge(
+        period_start_gteq: Time.at(@start_time),
+        period_start_lt: Time.at(@end_time)
+      )
+
+      # Only add duration filter if we have a meaningful threshold
+      base_params[:avg_duration_gteq] = @start_duration if @start_duration && @start_duration > 0
 
       if show_action?
-        base_params.merge(
-          query_id_eq: @query.id,
-          occurred_at_gteq: @start_time,
-          occurred_at_lt: @end_time,
-          duration_gteq: @start_duration
-        )
+        base_params.merge(summarizable_id_eq: @query.id)
       else
-        base_params.merge(
-          operations_occurred_at_gteq: @start_time,
-          operations_occurred_at_lt: @end_time,
-          operations_duration_gteq: @start_duration
-        )
+        base_params
       end
     end
 
     def build_table_ransack_params(ransack_params)
       if show_action?
-        ransack_params.merge(
-          query_id_eq: @query.id,
-          occurred_at_gteq: @table_start_time,
-          occurred_at_lt: @table_end_time,
-          duration_gteq: @start_duration
+        # For Operation model on show page
+        params = ransack_params.merge(
+          occurred_at_gteq: Time.at(@table_start_time),
+          occurred_at_lt: Time.at(@table_end_time),
+          query_id_eq: @query.id
         )
+        params[:duration_gteq] = @start_duration if @start_duration && @start_duration > 0
+        params
       else
-        ransack_params.merge(
-          operations_occurred_at_gteq: @table_start_time,
-          operations_occurred_at_lt: @table_end_time,
-          operations_duration_gteq: @start_duration
+        # For Summary model on index page
+        params = ransack_params.merge(
+          period_start_gteq: Time.at(@table_start_time),
+          period_start_lt: Time.at(@table_end_time)
         )
+        params[:avg_duration_gteq] = @start_duration if @start_duration && @start_duration > 0
+        params
       end
     end
 
     def default_table_sort
-      "occurred_at desc"
+      show_action? ? "occurred_at desc" : "period_start desc"
     end
 
     def build_table_results
       if show_action?
-        @ransack_query.result.select("id", "occurred_at", "duration")
+        @ransack_query.result
       else
-        # Optimized query: Use INNER JOIN since we only want queries with operations in time range
-        # This dramatically reduces the dataset before aggregation
-        @ransack_query.result(distinct: false)
-          .joins("INNER JOIN rails_pulse_operations ON rails_pulse_operations.query_id = rails_pulse_queries.id")
-          .where("rails_pulse_operations.occurred_at >= ? AND rails_pulse_operations.occurred_at < ?",
-                 @table_start_time, @table_end_time)
-          .group("rails_pulse_queries.id, rails_pulse_queries.normalized_sql, rails_pulse_queries.created_at, rails_pulse_queries.updated_at")
-          .select(
-            "rails_pulse_queries.*",
-            optimized_aggregations_sql
-          )
+        Queries::Tables::Index.new(
+          ransack_query: @ransack_query,
+          period_type: period_type,
+          start_time: @start_time,
+          params: params
+        ).to_table
       end
     end
 
     private
 
-    def optimized_aggregations_sql
-      # Efficient aggregations that work with our composite indexes
-      [
-        "COALESCE(AVG(rails_pulse_operations.duration), 0) AS average_query_time_ms",
-        "COUNT(rails_pulse_operations.id) AS execution_count",
-        "COALESCE(SUM(rails_pulse_operations.duration), 0) AS total_time_consumed",
-        "MAX(rails_pulse_operations.occurred_at) AS occurred_at"
-      ].join(", ")
+    def setup_metric_cards
+      return if turbo_frame_request?
+
+      @average_query_times_metric_card = RailsPulse::Queries::Cards::AverageQueryTimes.new(query: @query).to_metric_card
+      @percentile_query_times_metric_card = RailsPulse::Queries::Cards::PercentileQueryTimes.new(query: @query).to_metric_card
+      @execution_rate_metric_card = RailsPulse::Queries::Cards::ExecutionRate.new(query: @query).to_metric_card
     end
 
     def show_action?
@@ -108,14 +104,33 @@ module RailsPulse
       show_action? ? :set_pagination_limit : :store_pagination_limit
     end
 
-    def set_query
-      @query = Query.find(params[:id])
+    def setup_table_data(ransack_params)
+      table_ransack_params = build_table_ransack_params(ransack_params)
+      @ransack_query = table_model.ransack(table_ransack_params)
+
+      # Only apply default sort if not using Queries::Tables::Index (which handles its own sorting)
+      if show_action?
+        @ransack_query.sorts = default_table_sort if @ransack_query.sorts.empty?
+      end
+
+      table_results = build_table_results
+      handle_pagination
+
+      @pagy, @table_data = pagy(table_results, limit: session_pagination_limit)
+    end
+
+    def handle_pagination
+      method = pagination_method
+      send(method, params[:limit]) if params[:limit].present?
     end
 
-    def setup_metic_cards
-      @average_query_times_card = Queries::Cards::AverageQueryTimes.new(query: @query).to_metric_card
-      @percentile_response_times_card = Queries::Cards::PercentileQueryTimes.new(query: @query).to_metric_card
-      @execution_rate_card = Queries::Cards::ExecutionRate.new(query: @query).to_metric_card
+    def setup_time_and_response_ranges
+      @start_time, @end_time, @selected_time_range, @time_diff_hours = setup_time_range
+      @start_duration, @selected_response_range = setup_duration_range(:query)
+    end
+
+    def set_query
+      @query = Query.find(params[:id])
     end
   end
 end

data/app/controllers/rails_pulse/requests_controller.rb

@@ -5,6 +5,13 @@ module RailsPulse
     before_action :set_request, only: :show
 
     def index
+      unless turbo_frame_request?
+        @average_response_times_metric_card = RailsPulse::Routes::Cards::AverageResponseTimes.new(route: nil).to_metric_card
+        @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: nil).to_metric_card
+        @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: nil).to_metric_card
+        @error_rate_per_route_metric_card = RailsPulse::Routes::Cards::ErrorRatePerRoute.new(route: nil).to_metric_card
+      end
+
       setup_chart_and_table_data
     end
 
@@ -15,7 +22,7 @@ module RailsPulse
     private
 
     def chart_model
-      Request
+      Summary
     end
 
     def table_model
@@ -27,23 +34,27 @@ module RailsPulse
     end
 
     def chart_options
-      { route: true }
+      {}
     end
 
     def build_chart_ransack_params(ransack_params)
-      ransack_params.except(:s).merge(
-        occurred_at_gteq: @start_time,
-        occurred_at_lt: @end_time,
-        duration_gteq: @start_duration
+      base_params = ransack_params.except(:s).merge(
+        period_start_gteq: Time.at(@start_time),
+        period_start_lt: Time.at(@end_time)
       )
+
+      # Only add duration filter if we have a meaningful threshold
+      base_params[:avg_duration_gteq] = @start_duration if @start_duration && @start_duration > 0
+      base_params
     end
 
     def build_table_ransack_params(ransack_params)
-      ransack_params.merge(
-        occurred_at_gteq: @table_start_time,
-        occurred_at_lt: @table_end_time,
-        duration_gteq: @start_duration
+      params = ransack_params.merge(
+        occurred_at_gteq: Time.at(@table_start_time),
+        occurred_at_lt: Time.at(@table_end_time)
       )
+      params[:duration_gteq] = @start_duration if @start_duration && @start_duration > 0
+      params
     end
 
     def default_table_sort
@@ -52,13 +63,14 @@ module RailsPulse
 
     def build_table_results
       @ransack_query.result
-        .includes(:route)
+        .joins(:route)
         .select(
           "rails_pulse_requests.id",
           "rails_pulse_requests.occurred_at",
           "rails_pulse_requests.duration",
           "rails_pulse_requests.status",
-          "rails_pulse_requests.route_id"
+          "rails_pulse_requests.route_id",
+          "rails_pulse_routes.path"
         )
     end
 

data/app/controllers/rails_pulse/routes_controller.rb

@@ -5,21 +5,32 @@ module RailsPulse
     before_action :set_route, only: :show
 
     def index
+      setup_metric_cards
       setup_chart_and_table_data
     end
 
     def show
+      setup_metric_cards
       setup_chart_and_table_data
     end
 
     private
 
+    def setup_metric_cards
+      return if turbo_frame_request?
+
+      @average_query_times_metric_card = RailsPulse::Routes::Cards::AverageResponseTimes.new(route: @route).to_metric_card
+      @percentile_response_times_metric_card = RailsPulse::Routes::Cards::PercentileResponseTimes.new(route: @route).to_metric_card
+      @request_count_totals_metric_card = RailsPulse::Routes::Cards::RequestCountTotals.new(route: @route).to_metric_card
+      @error_rate_per_route_metric_card = RailsPulse::Routes::Cards::ErrorRatePerRoute.new(route: @route).to_metric_card
+    end
+
     def chart_model
-      show_action? ? Request : Route
+      Summary
     end
 
     def table_model
-      show_action? ? Request : Route
+      show_action? ? Request : Summary
     end
 
     def chart_class
@@ -31,49 +42,53 @@ module RailsPulse
     end
 
     def build_chart_ransack_params(ransack_params)
-      base_params = ransack_params.except(:s).merge(duration_field => @start_duration)
+      base_params = ransack_params.except(:s).merge(
+        period_start_gteq: Time.at(@start_time),
+        period_start_lt: Time.at(@end_time)
+      )
+
+      # Only add duration filter if we have a meaningful threshold
+      base_params[:avg_duration_gteq] = @start_duration if @start_duration && @start_duration > 0
 
       if show_action?
-        base_params.merge(
-          route_id_eq: @route.id,
-          occurred_at_gteq: @start_time,
-          occurred_at_lt: @end_time
-        )
+        base_params.merge(summarizable_id_eq: @route.id)
       else
-        base_params.merge(
-          requests_occurred_at_gteq: @start_time,
-          requests_occurred_at_lt: @end_time
-        )
+        base_params
       end
     end
 
     def build_table_ransack_params(ransack_params)
-      base_params = ransack_params.merge(duration_field => @start_duration)
-
       if show_action?
-        base_params.merge(
-          route_id_eq: @route.id,
-          occurred_at_gteq: @table_start_time,
-          occurred_at_lt: @table_end_time
+        # For Request model on show page
+        params = ransack_params.merge(
+          occurred_at_gteq: Time.at(@table_start_time),
+          occurred_at_lt: Time.at(@table_end_time),
+          route_id_eq: @route.id
         )
+        params[:duration_gteq] = @start_duration if @start_duration && @start_duration > 0
+        params
       else
-        base_params.merge(
-          requests_occurred_at_gteq: @table_start_time,
-          requests_occurred_at_lt: @table_end_time
+        # For Summary model on index page
+        params = ransack_params.merge(
+          period_start_gteq: Time.at(@table_start_time),
+          period_start_lt: Time.at(@table_end_time)
         )
+        params[:avg_duration_gteq] = @start_duration if @start_duration && @start_duration > 0
+        params
       end
     end
 
     def default_table_sort
-      show_action? ? "occurred_at desc" : "average_response_time_ms desc"
+      show_action? ? "occurred_at desc" : "avg_duration desc"
     end
 
     def build_table_results
       if show_action?
-        @ransack_query.result.select("id", "route_id", "occurred_at", "duration", "status")
+        @ransack_query.result
       else
         Routes::Tables::Index.new(
           ransack_query: @ransack_query,
+          period_type: period_type,
           start_time: @start_time,
           params: params
         ).to_table
@@ -81,13 +96,33 @@ module RailsPulse
     end
 
     def duration_field
-      show_action? ? :duration_gteq : :requests_duration_gteq
+      :avg_duration
     end
 
     def show_action?
       action_name == "show"
     end
 
+    def setup_table_data(ransack_params)
+      table_ransack_params = build_table_ransack_params(ransack_params)
+      @ransack_query = table_model.ransack(table_ransack_params)
+
+      # Only apply default sort if not using Routes::Tables::Index (which handles its own sorting)
+      if show_action?
+        @ransack_query.sorts = default_table_sort if @ransack_query.sorts.empty?
+      end
+
+      table_results = build_table_results
+      handle_pagination
+
+      @pagy, @table_data = pagy(table_results, limit: session_pagination_limit)
+    end
+
+    def handle_pagination
+      method = pagination_method
+      send(method, params[:limit]) if params[:limit].present?
+    end
+
     def pagination_method
       show_action? ? :set_pagination_limit : :store_pagination_limit
     end

data/app/helpers/rails_pulse/application_helper.rb

@@ -3,7 +3,6 @@ module RailsPulse
     include Pagy::Frontend
 
     include BreadcrumbsHelper
-    include CachedComponentHelper
     include ChartHelper
     include FormattingHelper
     include StatusHelper

data/app/helpers/rails_pulse/chart_formatters.rb

@@ -1,6 +1,6 @@
 module RailsPulse
   module ChartFormatters
-    def self.occurred_at_as_time_or_date(time_diff_hours)
+    def self.period_as_time_or_date(time_diff_hours)
       if time_diff_hours <= 25
         <<~JS
           function(value) {
@@ -25,7 +25,7 @@ module RailsPulse
             const data = params[0];
             const date = new Date(data.axisValue * 1000);
             const dateString = date.getHours().toString().padStart(2, '0') + ':00';
-            return `${dateString} <br /> ${data.marker} ${parseInt(data.data.value)} ms`;
+            return `${dateString} <br /> ${data.marker} ${parseInt(data.data)} ms`;
           }
         JS
       else
@@ -34,7 +34,7 @@ module RailsPulse
             const data = params[0];
             const date = new Date(data.axisValue * 1000);
             const dateString = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
-            return `${dateString} <br /> ${data.marker} ${parseInt(data.data.value)} ms`;
+            return `${dateString} <br /> ${data.marker} ${parseInt(data.data)} ms`;
           }
         JS
       end

data/app/helpers/rails_pulse/chart_helper.rb

@@ -117,9 +117,13 @@ module RailsPulse
         # Chart data is a hash like: { 1234567890 => { value: 123.45 } }
         chart_timestamps = chart_data.keys
 
+        # Convert zoom parameters to integers (timestamps)
+        zoom_start_int = zoom_start.respond_to?(:to_i) ? zoom_start.to_i : zoom_start
+        zoom_end_int = zoom_end.respond_to?(:to_i) ? zoom_end.to_i : zoom_end
+
         if chart_timestamps.any?
-          closest_start = chart_timestamps.min_by { |ts| (ts - zoom_start).abs }
-          closest_end = chart_timestamps.min_by { |ts| (ts - zoom_end).abs }
+          closest_start = chart_timestamps.min_by { |ts| (ts - zoom_start_int).abs }
+          closest_end = chart_timestamps.min_by { |ts| (ts - zoom_end_int).abs }
 
           # Find the array indices of these timestamps
           start_index = chart_timestamps.index(closest_start)

data/app/helpers/rails_pulse/status_helper.rb

@@ -256,13 +256,19 @@ module RailsPulse
 
     def event_color(operation_type)
       case operation_type
-      when "sql" then "#92c282;"
-      when "template", "partial", "layout", "collection" then "#b77cbf"
-      when "controller" then "#00adc4"
-      else "gray"
+      when "sql"
+        "#d27d6b"
+      when "template", "partial", "layout", "collection"
+        "#6c7ab9"
+      when "controller"
+        "#5ba6b0"
+      else
+        "#a6a6a6"
       end
     end
 
+
+
     def duration_options(type = :route)
       thresholds = RailsPulse.configuration.public_send("#{type}_thresholds")