rails_pulse 0.1.0 → 0.1.2

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

@@ -7,44 +7,49 @@ module RailsPulse
         end
 
         def to_metric_card
-          requests = if @route
-            RailsPulse::Request.where(route: @route)
-          else
-            RailsPulse::Request.all
-          end
+          last_7_days = 7.days.ago.beginning_of_day
+          previous_7_days = 14.days.ago.beginning_of_day
 
-          requests = requests.where("occurred_at >= ?", 2.weeks.ago.beginning_of_day)
+          # Single query to get all count metrics with conditional aggregation
+          base_query = RailsPulse::Summary.where(
+            summarizable_type: "RailsPulse::Route",
+            period_type: "day",
+            period_start: 2.weeks.ago.beginning_of_day..Time.current
+          )
+          base_query = base_query.where(summarizable_id: @route.id) if @route
 
-          # Calculate total request count
-          total_request_count = requests.count
+          metrics = base_query.select(
+            "SUM(count) AS total_count",
+            "SUM(CASE WHEN period_start >= '#{last_7_days.strftime('%Y-%m-%d %H:%M:%S')}' THEN count ELSE 0 END) AS current_count",
+            "SUM(CASE WHEN period_start >= '#{previous_7_days.strftime('%Y-%m-%d %H:%M:%S')}' AND period_start < '#{last_7_days.strftime('%Y-%m-%d %H:%M:%S')}' THEN count ELSE 0 END) AS previous_count"
+          ).take
 
-          # Calculate trend by comparing last 7 days vs previous 7 days
-          last_7_days = 7.days.ago.beginning_of_day
-          previous_7_days = 14.days.ago.beginning_of_day
-          current_period_count = requests.where("occurred_at >= ?", last_7_days).count
-          previous_period_count = requests.where("occurred_at >= ? AND occurred_at < ?", previous_7_days, last_7_days).count
+          # Calculate metrics from single query result
+          total_request_count = metrics.total_count || 0
+          current_period_count = metrics.current_count || 0
+          previous_period_count = metrics.previous_count || 0
 
           percentage = previous_period_count.zero? ? 0 : ((previous_period_count - current_period_count) / previous_period_count.to_f * 100).abs.round(1)
           trend_icon = percentage < 0.1 ? "move-right" : current_period_count < previous_period_count ? "trending-down" : "trending-up"
           trend_amount = previous_period_count.zero? ? "0%" : "#{percentage}%"
 
-          sparkline_data = requests
-            .group_by_week(:occurred_at, time_zone: "UTC")
-            .count
-            .each_with_object({}) do |(date, count), hash|
-              formatted_date = date.strftime("%b %-d")
-              hash[formatted_date] = {
-                value: count
-              }
+          # Separate query for sparkline data - group by week using Rails
+          sparkline_data = base_query
+            .group_by_week(:period_start, time_zone: "UTC")
+            .sum(:count)
+            .each_with_object({}) do |(week_start, total_count), hash|
+              formatted_date = week_start.strftime("%b %-d")
+              value = total_count || 0
+              hash[formatted_date] = { value: value }
             end
 
-          # Calculate average requests per minute
-          min_time = requests.minimum(:occurred_at)
-          max_time = requests.maximum(:occurred_at)
-          total_minutes = min_time && max_time && min_time != max_time ? (max_time - min_time) / 60.0 : 1
+          # Calculate average requests per minute over 2-week period
+          total_minutes = 2.weeks / 1.minute
           average_requests_per_minute = total_request_count / total_minutes
 
           {
+            id: "request_count_totals",
+            context: "routes",
             title: "Request Count Total",
             summary: "#{average_requests_per_minute.round(2)} / min",
             line_chart_data: sparkline_data,

data/app/models/rails_pulse/routes/charts/average_response_times.rb

@@ -2,112 +2,35 @@ module RailsPulse
   module Routes
     module Charts
       class AverageResponseTimes
-        def initialize(ransack_query:, group_by: :group_by_day, route: nil)
+        def initialize(ransack_query:, period_type: nil, route: nil, start_time: nil, end_time: nil, start_duration: nil)
           @ransack_query = ransack_query
-          @group_by = group_by
+          @period_type = period_type
           @route = route
+          @start_time = start_time
+          @end_time = end_time
+          @start_duration = start_duration
         end
 
         def to_rails_chart
-          # Get actual data using existing logic
-          actual_data = if @route
-            # These are the requests for the specific route so it will just be a collection of Requests that we can
-            # filter and sort using the attributes on each Request
-            @ransack_query.result(distinct: false)
-              .public_send(@group_by, "occurred_at", series: true, time_zone: "UTC")
-              .average(:duration)
-          else
-            # Use the existing query structure with left_joins from ransack
-            @ransack_query.result(distinct: false)
-              .left_joins(:requests)
-              .public_send(
-                @group_by,
-                "rails_pulse_requests.occurred_at",
-                series: true,
-                time_zone: "UTC"
-              )
-              .average("rails_pulse_requests.duration")
-          end
-
-          # Create full time range and fill in missing periods
-          fill_missing_periods(actual_data)
-        end
-
-        private
-
-        def fill_missing_periods(actual_data)
-          # Extract actual time range from ransack query conditions
-          start_time, end_time = extract_time_range_from_ransack
-
-          # Create time range based on grouping type
-          case @group_by
-          when :group_by_hour
-            time_range = generate_hour_range(start_time, end_time)
-          else # :group_by_day
-            time_range = generate_day_range(start_time, end_time)
-          end
-
-          # Fill in all periods with zero values for missing periods
-          time_range.each_with_object({}) do |period, result|
-            occurred_at = period.is_a?(String) ? Time.parse(period) : period
-            occurred_at = (occurred_at.is_a?(Time) || occurred_at.is_a?(Date)) ? occurred_at : Time.current
-
-            normalized_occurred_at =
-              case @group_by
-              when :group_by_hour
-                occurred_at&.beginning_of_hour || occurred_at
-              when :group_by_day
-                occurred_at&.beginning_of_day || occurred_at
-              else
-                occurred_at
-              end
-
-            # Use actual data if available, otherwise default to 0
-            average_duration = actual_data[period] || 0
-            result[normalized_occurred_at.to_i] = {
-              value: average_duration.to_f
-            }
-          end
-        end
-
-        def generate_day_range(start_time, end_time)
-          (start_time.to_date..end_time.to_date).map(&:beginning_of_day)
-        end
-
-        def generate_hour_range(start_time, end_time)
-          current = start_time
-          hours = []
-          while current <= end_time
-            hours << current
-            current += 1.hour
-          end
-          hours
-        end
-
-        def extract_time_range_from_ransack
-          # Extract time range from ransack conditions
-          conditions = @ransack_query.conditions
-
-          if @route
-            # For specific route queries, look for occurred_at conditions
-            start_condition = conditions.find { |c| c.a.first == "occurred_at" && c.p == "gteq" }
-            end_condition = conditions.find { |c| c.a.first == "occurred_at" && c.p == "lt" }
-          else
-            # For general route queries, look for requests_occurred_at conditions
-            start_condition = conditions.find { |c| c.a.first == "requests_occurred_at" && c.p == "gteq" }
-            end_condition = conditions.find { |c| c.a.first == "requests_occurred_at" && c.p == "lt" }
-          end
-
-          start_time = start_condition&.v || 2.weeks.ago
-          end_time = end_condition&.v || Time.current
-
-          # Normalize time boundaries based on grouping
-          case @group_by
-          when :group_by_hour
-            [ start_time.beginning_of_hour, end_time.beginning_of_hour ]
-          else
-            [ start_time.beginning_of_day, end_time.beginning_of_day ]
+          summaries = @ransack_query.result(distinct: false).where(
+            summarizable_type: "RailsPulse::Route",
+            period_type: @period_type
+          )
+
+          summaries = summaries.where(summarizable_id: @route.id) if @route
+          summaries = summaries
+            .group(:period_start)
+            .having("AVG(avg_duration) > ?", @start_duration || 0)
+            .average(:avg_duration)
+            .transform_keys(&:to_i)
+
+          # Pad missing data points with zeros
+          step = @period_type == :hour ? 1.hour : 1.day
+          data = {}
+          (@start_time.to_i..@end_time.to_i).step(step) do |timestamp|
+            data[timestamp.to_i] = summaries[timestamp.to_i].to_f.round(2)
           end
+          data
         end
       end
     end

data/app/models/rails_pulse/routes/tables/index.rb

@@ -2,60 +2,77 @@ module RailsPulse
   module Routes
     module Tables
       class Index
-        def initialize(ransack_query:, start_time:, params:)
+        def initialize(ransack_query:, period_type: nil, start_time:, params:)
           @ransack_query = ransack_query
+          @period_type = period_type
           @start_time = start_time
           @params = params
         end
 
         def to_table
-          # Pre-calculate values to avoid SQL injection and improve readability
-          minutes_elapsed = calculate_minutes_elapsed
+          # Check if we have explicit ransack sorts
+          has_sorts = @ransack_query.sorts.any?
 
-          # Get thresholds with safe defaults to avoid nil access errors
-          config = RailsPulse.configuration rescue nil
-          thresholds = config&.route_thresholds || { slow: 500, very_slow: 1500, critical: 3000 }
-
-          requests_per_minute_divisor = minutes_elapsed > 0 ? minutes_elapsed : 1
+          base_query = @ransack_query.result(distinct: false)
+            .joins("INNER JOIN rails_pulse_routes ON rails_pulse_routes.id = rails_pulse_summaries.summarizable_id")
+            .where(
+              summarizable_type: "RailsPulse::Route",
+              period_type: @period_type
+            )
 
-          status_sql = build_status_sql(thresholds)
+          base_query = base_query.where(summarizable_id: @route.id) if @route
 
-          @ransack_query.result(distinct: false)
-            .left_joins(:requests)
-            .group("rails_pulse_routes.id")
+          # Apply grouping and aggregation
+          grouped_query = base_query
+            .group(
+              "rails_pulse_summaries.summarizable_id",
+              "rails_pulse_summaries.summarizable_type",
+              "rails_pulse_routes.id",
+              "rails_pulse_routes.path",
+              "rails_pulse_routes.method"
+            )
             .select(
-              "rails_pulse_routes.*",
-              "COALESCE(AVG(rails_pulse_requests.duration), 0) AS average_response_time_ms",
-              "COUNT(rails_pulse_requests.id) AS request_count",
-              "COALESCE(COUNT(rails_pulse_requests.id) / #{requests_per_minute_divisor}, 0) AS requests_per_minute",
-              "COALESCE(SUM(CASE WHEN rails_pulse_requests.is_error = true THEN 1 ELSE 0 END), 0) AS error_count",
-              "CASE WHEN COUNT(rails_pulse_requests.id) > 0 THEN ROUND((COALESCE(SUM(CASE WHEN rails_pulse_requests.is_error = true THEN 1 ELSE 0 END), 0) * 100.0) / COUNT(rails_pulse_requests.id), 2) ELSE 0 END AS error_rate_percentage",
-              "COALESCE(MAX(rails_pulse_requests.duration), 0) AS max_response_time_ms",
-              "#{status_sql} AS status_indicator"
+              "rails_pulse_summaries.summarizable_id",
+              "rails_pulse_summaries.summarizable_type",
+              "rails_pulse_routes.id as route_id",
+              "rails_pulse_routes.path",
+              "rails_pulse_routes.method as route_method",
+              "AVG(rails_pulse_summaries.avg_duration) as avg_duration",
+              "MAX(rails_pulse_summaries.max_duration) as max_duration",
+              "SUM(rails_pulse_summaries.count) as count",
+              "SUM(rails_pulse_summaries.error_count) as error_count",
+              "SUM(rails_pulse_summaries.success_count) as success_count"
             )
-        end
-
-        private
 
-        def calculate_minutes_elapsed
-          start_timestamp = Time.at(@start_time.to_i).utc
-          ((Time.current.utc - start_timestamp) / 60.0).round(2)
-        end
+          # Apply sorting based on ransack sorts or use default
+          if has_sorts
+            # Apply custom sorting based on ransack parameters
+            sort = @ransack_query.sorts.first
+            direction = sort.dir == "desc" ? :desc : :asc
 
-        def build_status_sql(thresholds)
-          # Ensure all thresholds have default values
-          slow = thresholds[:slow] || 500
-          very_slow = thresholds[:very_slow] || 1500
-          critical = thresholds[:critical] || 3000
+            case sort.name
+            when "avg_duration_sort"
+              grouped_query = grouped_query.order(Arel.sql("AVG(rails_pulse_summaries.avg_duration)").send(direction))
+            when "max_duration_sort"
+              grouped_query = grouped_query.order(Arel.sql("MAX(rails_pulse_summaries.max_duration)").send(direction))
+            when "count_sort"
+              grouped_query = grouped_query.order(Arel.sql("SUM(rails_pulse_summaries.count)").send(direction))
+            when "requests_per_minute"
+              grouped_query = grouped_query.order(Arel.sql("SUM(rails_pulse_summaries.count) / 60.0").send(direction))
+            when "error_rate_percentage"
+              grouped_query = grouped_query.order(Arel.sql("(SUM(rails_pulse_summaries.error_count) * 100.0) / SUM(rails_pulse_summaries.count)").send(direction))
+            when "route_path"
+              grouped_query = grouped_query.order(Arel.sql("rails_pulse_routes.path").send(direction))
+            else
+              # Unknown sort field, fallback to default
+              grouped_query = grouped_query.order(Arel.sql("AVG(rails_pulse_summaries.avg_duration)").desc)
+            end
+          else
+            # Apply default sort when no explicit sort is provided (matches controller default_table_sort)
+            grouped_query = grouped_query.order(Arel.sql("AVG(rails_pulse_summaries.avg_duration)").desc)
+          end
 
-          <<-SQL.squish
-            CASE
-              WHEN COALESCE(AVG(rails_pulse_requests.duration), 0) >= #{critical} THEN 3
-              WHEN COALESCE(AVG(rails_pulse_requests.duration), 0) >= #{very_slow} THEN 2
-              WHEN COALESCE(AVG(rails_pulse_requests.duration), 0) >= #{slow} THEN 1
-              ELSE 0
-            END
-          SQL
+          grouped_query
         end
       end
     end

data/app/models/rails_pulse/summary.rb

@@ -0,0 +1,143 @@
+module RailsPulse
+  class Summary < RailsPulse::ApplicationRecord
+    self.table_name = "rails_pulse_summaries"
+
+    PERIOD_TYPES = %w[hour day week month].freeze
+
+    # Polymorphic association
+    belongs_to :summarizable, polymorphic: true, optional: true  # Optional for Request summaries
+
+    # Convenience associations for easier querying
+    belongs_to :route, -> { where(rails_pulse_summaries: { summarizable_type: "RailsPulse::Route" }) },
+               foreign_key: "summarizable_id", class_name: "RailsPulse::Route", optional: true
+    belongs_to :query, -> { where(rails_pulse_summaries: { summarizable_type: "RailsPulse::Query" }) },
+               foreign_key: "summarizable_id", class_name: "RailsPulse::Query", optional: true
+
+    # Validations
+    validates :period_type, inclusion: { in: PERIOD_TYPES }
+    validates :period_start, presence: true
+    validates :period_end, presence: true
+
+    # Scopes
+    scope :for_period_type, ->(type) { where(period_type: type) }
+    scope :for_date_range, ->(start_date, end_date) {
+      where(period_start: start_date..end_date)
+    }
+    scope :for_requests, -> { where(summarizable_type: "RailsPulse::Request") }
+    scope :for_routes, -> { where(summarizable_type: "RailsPulse::Route") }
+    scope :for_queries, -> { where(summarizable_type: "RailsPulse::Query") }
+    scope :recent, -> { order(period_start: :desc) }
+
+    # Special scope for overall request summaries
+    scope :overall_requests, -> {
+      where(summarizable_type: "RailsPulse::Request", summarizable_id: 0)
+    }
+
+    # Ransack configuration
+    def self.ransackable_attributes(auth_object = nil)
+      %w[
+        period_start period_end avg_duration max_duration count error_count
+        requests_per_minute error_rate_percentage route_path_cont
+        execution_count total_time_consumed normalized_sql
+      ]
+    end
+
+    def self.ransackable_associations(auth_object = nil)
+      %w[route query]
+    end
+
+    # Custom ransackers for calculated fields (designed to work with GROUP BY queries)
+    ransacker :count do
+      Arel.sql("SUM(rails_pulse_summaries.count)")  # Use SUM for proper grouping
+    end
+
+    ransacker :requests_per_minute do
+      Arel.sql("SUM(rails_pulse_summaries.count) / 60.0")  # Use SUM for consistency
+    end
+
+    ransacker :error_rate_percentage do
+      Arel.sql("(SUM(rails_pulse_summaries.error_count) * 100.0) / SUM(rails_pulse_summaries.count)")  # Use SUM for both
+    end
+
+
+    # Ransacker for route path sorting (when joined with routes table)
+    ransacker :route_path do
+      Arel.sql("rails_pulse_routes.path")
+    end
+
+    # Ransacker for route path filtering using subquery (works without JOIN)
+    ransacker :route_path_cont do |parent|
+      Arel.sql(<<-SQL)
+        rails_pulse_summaries.summarizable_id IN (
+          SELECT id FROM rails_pulse_routes
+          WHERE rails_pulse_routes.path LIKE '%' || ? || '%'
+        )
+      SQL
+    end
+
+    # Sorting-specific ransackers for GROUP BY compatibility (used only in ORDER BY)
+    # These use different names to avoid conflicts with filtering
+    ransacker :avg_duration_sort do
+      Arel.sql("AVG(rails_pulse_summaries.avg_duration)")
+    end
+
+    ransacker :max_duration_sort do
+      Arel.sql("MAX(rails_pulse_summaries.max_duration)")
+    end
+
+    ransacker :count_sort do
+      Arel.sql("SUM(rails_pulse_summaries.count)")
+    end
+
+    ransacker :error_count_sort do
+      Arel.sql("SUM(rails_pulse_summaries.error_count)")
+    end
+
+    ransacker :success_count_sort do
+      Arel.sql("SUM(rails_pulse_summaries.success_count)")
+    end
+
+    ransacker :total_time_consumed_sort do
+      Arel.sql("SUM(rails_pulse_summaries.count * rails_pulse_summaries.avg_duration)")
+    end
+
+    # Alias execution_count_sort to count_sort for queries table compatibility
+    ransacker :execution_count_sort do
+      Arel.sql("SUM(rails_pulse_summaries.count)")
+    end
+
+    # Ransackers for queries table calculated fields
+    ransacker :execution_count do
+      Arel.sql("SUM(rails_pulse_summaries.count)")  # Total executions
+    end
+
+    ransacker :total_time_consumed do
+      Arel.sql("SUM(rails_pulse_summaries.count * rails_pulse_summaries.avg_duration)")  # Total time consumed
+    end
+
+    # Ransacker for query SQL sorting (when joined with queries table)
+    ransacker :normalized_sql do
+      Arel.sql("rails_pulse_queries.normalized_sql")
+    end
+
+    class << self
+      def calculate_period_end(period_type, start_time)
+        case period_type
+        when "hour"  then start_time.end_of_hour
+        when "day"   then start_time.end_of_day
+        when "week"  then start_time.end_of_week
+        when "month" then start_time.end_of_month
+        end
+      end
+
+      def normalize_period_start(period_type, time)
+        case period_type
+        when "hour"  then time.beginning_of_hour
+        when "day"   then time.beginning_of_day
+        when "week"  then time.beginning_of_week
+        when "month" then time.beginning_of_month
+        end
+      end
+    end
+  end
+end

data/app/services/rails_pulse/summary_service.rb

@@ -0,0 +1,199 @@
+
+module RailsPulse
+  class SummaryService
+    attr_reader :period_type, :start_time, :end_time
+
+    def initialize(period_type, start_time)
+      @period_type = period_type
+      @start_time = Summary.normalize_period_start(period_type, start_time)
+      @end_time = Summary.calculate_period_end(period_type, @start_time)
+    end
+
+    def perform
+      Rails.logger.info "[RailsPulse] Starting #{period_type} summary for #{start_time}"
+
+      ActiveRecord::Base.transaction do
+        aggregate_requests  # Overall system metrics
+        aggregate_routes    # Per-route metrics
+        aggregate_queries   # Per-query metrics
+      end
+
+      Rails.logger.info "[RailsPulse] Completed #{period_type} summary"
+    rescue => e
+      Rails.logger.error "[RailsPulse] Summary failed: #{e.message}"
+      raise
+    end
+
+    private
+
+    def aggregate_requests
+      # Create a single summary for ALL requests in this period
+      requests = Request.where(occurred_at: start_time...end_time)
+
+      return if requests.empty?
+
+      # Get all durations and statuses for percentile calculations
+      request_data = requests.pluck(:duration, :status)
+      durations = request_data.map(&:first).compact.sort
+      statuses = request_data.map(&:second)
+
+      # Find or create the overall request summary
+      summary = Summary.find_or_initialize_by(
+        summarizable_type: "RailsPulse::Request",
+        summarizable_id: 0,  # Use 0 as a special ID for overall summaries
+        period_type: period_type,
+        period_start: start_time
+      )
+
+      summary.assign_attributes(
+        period_end: end_time,
+        count: durations.size,
+        avg_duration: durations.any? ? durations.sum.to_f / durations.size : 0,
+        min_duration: durations.min,
+        max_duration: durations.max,
+        total_duration: durations.sum,
+        p50_duration: calculate_percentile(durations, 0.5),
+        p95_duration: calculate_percentile(durations, 0.95),
+        p99_duration: calculate_percentile(durations, 0.99),
+        stddev_duration: calculate_stddev(durations, durations.sum.to_f / durations.size),
+        error_count: statuses.count { |s| s >= 400 },
+        success_count: statuses.count { |s| s < 400 },
+        status_2xx: statuses.count { |s| s.between?(200, 299) },
+        status_3xx: statuses.count { |s| s.between?(300, 399) },
+        status_4xx: statuses.count { |s| s.between?(400, 499) },
+        status_5xx: statuses.count { |s| s >= 500 }
+      )
+
+      summary.save!
+    end
+
+    private
+
+    def aggregate_routes
+      # Use ActiveRecord for cross-database compatibility
+      route_groups = Request
+        .where(occurred_at: start_time...end_time)
+        .where.not(route_id: nil)
+        .group(:route_id)
+
+      # Calculate basic aggregates
+      basic_stats = route_groups.pluck(
+        :route_id,
+        Arel.sql("COUNT(*) as request_count"),
+        Arel.sql("AVG(duration) as avg_duration"),
+        Arel.sql("MIN(duration) as min_duration"),
+        Arel.sql("MAX(duration) as max_duration"),
+        Arel.sql("SUM(duration) as total_duration")
+      )
+
+      basic_stats.each do |stats|
+        route_id = stats[0]
+
+        # Calculate percentiles and status counts separately for cross-DB compatibility
+        durations = Request
+          .where(occurred_at: start_time...end_time)
+          .where(route_id: route_id)
+          .pluck(:duration, :status)
+
+        sorted_durations = durations.map(&:first).compact.sort
+        statuses = durations.map(&:last)
+
+        summary = Summary.find_or_initialize_by(
+          summarizable_type: "RailsPulse::Route",
+          summarizable_id: route_id,
+          period_type: period_type,
+          period_start: start_time
+        )
+
+        summary.assign_attributes(
+          period_end: end_time,
+          count: stats[1],
+          avg_duration: stats[2],
+          min_duration: stats[3],
+          max_duration: stats[4],
+          total_duration: stats[5],
+          p50_duration: calculate_percentile(sorted_durations, 0.5),
+          p95_duration: calculate_percentile(sorted_durations, 0.95),
+          p99_duration: calculate_percentile(sorted_durations, 0.99),
+          stddev_duration: calculate_stddev(sorted_durations, stats[2]),
+          error_count: statuses.count { |s| s >= 400 },
+          success_count: statuses.count { |s| s < 400 },
+          status_2xx: statuses.count { |s| s.between?(200, 299) },
+          status_3xx: statuses.count { |s| s.between?(300, 399) },
+          status_4xx: statuses.count { |s| s.between?(400, 499) },
+          status_5xx: statuses.count { |s| s >= 500 }
+        )
+
+        summary.save!
+      end
+    end
+
+    def aggregate_queries
+      query_groups = Operation
+        .where(occurred_at: start_time...end_time)
+        .where.not(query_id: nil)
+        .group(:query_id)
+
+      basic_stats = query_groups.pluck(
+        :query_id,
+        Arel.sql("COUNT(*) as execution_count"),
+        Arel.sql("AVG(duration) as avg_duration"),
+        Arel.sql("MIN(duration) as min_duration"),
+        Arel.sql("MAX(duration) as max_duration"),
+        Arel.sql("SUM(duration) as total_duration")
+      )
+
+      basic_stats.each do |stats|
+        query_id = stats[0]
+
+        # Calculate percentiles separately
+        durations = Operation
+          .where(occurred_at: start_time...end_time)
+          .where(query_id: query_id)
+          .pluck(:duration)
+          .compact
+          .sort
+
+        summary = Summary.find_or_initialize_by(
+          summarizable_type: "RailsPulse::Query",
+          summarizable_id: query_id,
+          period_type: period_type,
+          period_start: start_time
+        )
+
+        summary.assign_attributes(
+          period_end: end_time,
+          count: stats[1],
+          avg_duration: stats[2],
+          min_duration: stats[3],
+          max_duration: stats[4],
+          total_duration: stats[5],
+          p50_duration: calculate_percentile(durations, 0.5),
+          p95_duration: calculate_percentile(durations, 0.95),
+          p99_duration: calculate_percentile(durations, 0.99),
+          stddev_duration: calculate_stddev(durations, stats[2])
+        )
+
+        summary.save!
+      end
+    end
+
+    def calculate_percentile(sorted_array, percentile)
+      return nil if sorted_array.empty?
+
+      k = (percentile * (sorted_array.length - 1)).floor
+      f = (percentile * (sorted_array.length - 1)) - k
+
+      return sorted_array[k] if f == 0 || k + 1 >= sorted_array.length
+
+      sorted_array[k] + (sorted_array[k + 1] - sorted_array[k]) * f
+    end
+
+    def calculate_stddev(values, mean)
+      return nil if values.empty? || values.size == 1
+
+      sum_of_squares = values.sum { |v| (v - mean) ** 2 }
+      Math.sqrt(sum_of_squares / (values.size - 1))
+    end
+  end
+end