rails_pulse 0.1.1 → 0.1.3

data/app/jobs/rails_pulse/backfill_summaries_job.rb

@@ -0,0 +1,41 @@
+module RailsPulse
+  class BackfillSummariesJob < ApplicationJob
+    queue_as :low_priority
+
+    def perform(start_date, end_date, period_types = [ "hour", "day" ])
+      start_date = start_date.to_datetime
+      end_date = end_date.to_datetime
+
+      period_types.each do |period_type|
+        backfill_period(period_type, start_date, end_date)
+      end
+    end
+
+    private
+
+    def backfill_period(period_type, start_date, end_date)
+      current = Summary.normalize_period_start(period_type, start_date)
+      period_end = Summary.calculate_period_end(period_type, end_date)
+
+      while current <= period_end
+        Rails.logger.info "[RailsPulse] Backfilling #{period_type} summary for #{current}"
+
+        SummaryService.new(period_type, current).perform
+
+        current = advance_period(current, period_type)
+
+        # Add small delay to avoid overwhelming the database
+        sleep 0.1
+      end
+    end
+
+    def advance_period(time, period_type)
+      case period_type
+      when "hour"  then time + 1.hour
+      when "day"   then time + 1.day
+      when "week"  then time + 1.week
+      when "month" then time + 1.month
+      end
+    end
+  end
+end

data/app/jobs/rails_pulse/summary_job.rb

@@ -0,0 +1,53 @@
+module RailsPulse
+  class SummaryJob < ApplicationJob
+    queue_as :low_priority
+
+    def perform(target_hour = nil)
+      target_hour ||= 1.hour.ago.beginning_of_hour
+
+      # Always run hourly summary
+      process_hourly_summary(target_hour)
+
+      # Check if we should run daily summary (at the start of a new day)
+      if target_hour.hour == 0
+        process_daily_summary(target_hour.to_date - 1.day)
+
+        # Check if we should run weekly summary (Monday at midnight)
+        if target_hour.wday == 1
+          process_weekly_summary((target_hour.to_date - 1.week).beginning_of_week)
+        end
+
+        # Check if we should run monthly summary (first day of month)
+        if target_hour.day == 1
+          process_monthly_summary((target_hour.to_date - 1.month).beginning_of_month)
+        end
+      end
+    rescue => e
+      Rails.logger.error "[RailsPulse] Summary job failed: #{e.message}"
+      Rails.logger.error e.backtrace.join("\n")
+      raise
+    end
+
+    private
+
+    def process_hourly_summary(hour)
+      Rails.logger.info "[RailsPulse] Processing hourly summary for #{hour}"
+      SummaryService.new("hour", hour).perform
+    end
+
+    def process_daily_summary(date)
+      Rails.logger.info "[RailsPulse] Processing daily summary for #{date}"
+      SummaryService.new("day", date).perform
+    end
+
+    def process_weekly_summary(week_start)
+      Rails.logger.info "[RailsPulse] Processing weekly summary for week starting #{week_start}"
+      SummaryService.new("week", week_start).perform
+    end
+
+    def process_monthly_summary(month_start)
+      Rails.logger.info "[RailsPulse] Processing monthly summary for month starting #{month_start}"
+      SummaryService.new("month", month_start).perform
+    end
+  end
+end

data/app/models/rails_pulse/dashboard/charts/average_response_time.rb

@@ -8,17 +8,38 @@ module RailsPulse
           end_date = Time.current.to_date
           date_range = (start_date..end_date)
 
-          # Get the actual data
-          requests = RailsPulse::Request.where("occurred_at >= ?", start_date.beginning_of_day)
-          actual_data = requests
-            .group_by_day(:occurred_at)
-            .average(:duration)
+          # Get the actual data from Summary records (routes)
+          summaries = RailsPulse::Summary.where(
+            summarizable_type: "RailsPulse::Route",
+            period_type: "day",
+            period_start: start_date.beginning_of_day..end_date.end_of_day
+          )
+
+          # Group by day manually for cross-database compatibility
+          actual_data = {}
+          summaries.each do |summary|
+            date = summary.period_start.to_date
+
+            if actual_data[date]
+              actual_data[date][:total_weighted] += (summary.avg_duration || 0) * (summary.count || 0)
+              actual_data[date][:total_count] += (summary.count || 0)
+            else
+              actual_data[date] = {
+                total_weighted: (summary.avg_duration || 0) * (summary.count || 0),
+                total_count: (summary.count || 0)
+              }
+            end
+          end
+
+          # Convert to final values
+          actual_data = actual_data.transform_values do |data|
+            data[:total_count] > 0 ? (data[:total_weighted] / data[:total_count]).round(0) : 0
+          end
 
           # Fill in all dates with zero values for missing days
           date_range.each_with_object({}) do |date, result|
             formatted_date = date.strftime("%b %-d")
-            avg_duration = actual_data[date]
-            result[formatted_date] = avg_duration&.round(0) || 0
+            result[formatted_date] = actual_data[date] || 0
           end
         end
       end

data/app/models/rails_pulse/dashboard/charts/p95_response_time.rb

@@ -3,32 +3,28 @@ module RailsPulse
     module Charts
       class P95ResponseTime
         def to_chart_data
-          start_date = 2.weeks.ago.beginning_of_day
+          # Create a range of all dates in the past 2 weeks
+          start_date = 2.weeks.ago.beginning_of_day.to_date
+          end_date = Time.current.to_date
+          date_range = (start_date..end_date)
 
-          # Performance optimization: Single query instead of N+1 queries (15 queries -> 1 query)
-          # Fetch all requests for 2-week period, pre-sorted by date and duration
-          # For optimal performance, ensure index exists: (occurred_at, duration)
-          requests_by_day = RailsPulse::Request
-            .where(occurred_at: start_date..)
-            .select("occurred_at, duration, DATE(occurred_at) as request_date")
-            .order("request_date, duration")
-            .group_by { |r| r.request_date.to_date }
+          # Get the actual data from Summary records (queries for P95)
+          summaries = RailsPulse::Summary.where(
+            summarizable_type: "RailsPulse::Query",
+            period_type: "day",
+            period_start: start_date.beginning_of_day..end_date.end_of_day
+          )
 
-          # Generate all dates in range and calculate P95 for each
-          (start_date.to_date..Time.current.to_date).each_with_object({}) do |date, hash|
-            day_requests = requests_by_day[date] || []
-
-            if day_requests.empty?
-              p95_value = 0
-            else
-              # Calculate P95 from in-memory sorted array (already sorted by DB)
-              count = day_requests.length
-              p95_index = (count * 0.95).ceil - 1
-              p95_value = day_requests[p95_index].duration.round(0)
-            end
+          actual_data = summaries
+            .group_by_day(:period_start, time_zone: Time.zone)
+            .average(:p95_duration)
+            .transform_keys { |date| date.to_date }
+            .transform_values { |avg| avg&.round(0) || 0 }
 
+          # Fill in all dates with zero values for missing days
+          date_range.each_with_object({}) do |date, result|
             formatted_date = date.strftime("%b %-d")
-            hash[formatted_date] = p95_value
+            result[formatted_date] = actual_data[date] || 0
           end
         end
       end

data/app/models/rails_pulse/dashboard/tables/slow_queries.rb

@@ -8,11 +8,22 @@ module RailsPulse
           this_week_start = 1.week.ago.beginning_of_week
           this_week_end = Time.current.end_of_week
 
-          # Fetch query data for this week
-          query_data = RailsPulse::Operation.joins(:query)
-            .where(occurred_at: this_week_start..this_week_end)
-            .group("rails_pulse_queries.id, rails_pulse_queries.normalized_sql")
-            .select("rails_pulse_queries.id, rails_pulse_queries.normalized_sql, AVG(rails_pulse_operations.duration) as avg_duration, COUNT(*) as request_count, MAX(rails_pulse_operations.occurred_at) as last_seen")
+          # Fetch query data from Summary records for this week
+          query_data = RailsPulse::Summary
+            .joins("INNER JOIN rails_pulse_queries ON rails_pulse_queries.id = rails_pulse_summaries.summarizable_id")
+            .where(
+              summarizable_type: "RailsPulse::Query",
+              period_type: "day",
+              period_start: this_week_start..this_week_end
+            )
+            .group("rails_pulse_summaries.summarizable_id, rails_pulse_queries.normalized_sql")
+            .select(
+              "rails_pulse_summaries.summarizable_id as query_id",
+              "rails_pulse_queries.normalized_sql",
+              "SUM(rails_pulse_summaries.avg_duration * rails_pulse_summaries.count) / SUM(rails_pulse_summaries.count) as avg_duration",
+              "SUM(rails_pulse_summaries.count) as request_count",
+              "MAX(rails_pulse_summaries.period_end) as last_seen"
+            )
             .order("avg_duration DESC")
             .limit(5)
 
@@ -20,8 +31,8 @@ module RailsPulse
           data_rows = query_data.map do |record|
             {
               query_text: truncate_query(record.normalized_sql),
-              query_id: record.id,
-              query_link: "/rails_pulse/queries/#{record.id}",
+              query_id: record.query_id,
+              query_link: "/rails_pulse/queries/#{record.query_id}",
               average_time: record.avg_duration.to_f.round(0),
               request_count: record.request_count,
               last_request: time_ago_in_words(record.last_seen)

data/app/models/rails_pulse/dashboard/tables/slow_routes.rb

@@ -5,58 +5,51 @@ module RailsPulse
         include RailsPulse::FormattingHelper
 
         def to_table_data
-          # Get data for this week and last week
+          # Get data for this week
           this_week_start = 1.week.ago.beginning_of_week
           this_week_end = Time.current.end_of_week
-          last_week_start = 2.weeks.ago.beginning_of_week
-          last_week_end = 1.week.ago.beginning_of_week
 
-          # Get this week's data
-          this_week_data = RailsPulse::Request.joins(:route)
-            .where(occurred_at: this_week_start..this_week_end)
-            .group("rails_pulse_routes.path, rails_pulse_routes.id")
-            .select("rails_pulse_routes.path, rails_pulse_routes.id, AVG(rails_pulse_requests.duration) as avg_duration, COUNT(*) as request_count")
+          # Fetch route data from Summary records for this week
+          route_data = RailsPulse::Summary
+            .joins("INNER JOIN rails_pulse_routes ON rails_pulse_routes.id = rails_pulse_summaries.summarizable_id")
+            .where(
+              summarizable_type: "RailsPulse::Route",
+              period_type: "day",
+              period_start: this_week_start..this_week_end
+            )
+            .group("rails_pulse_summaries.summarizable_id, rails_pulse_routes.path")
+            .select(
+              "rails_pulse_summaries.summarizable_id as route_id",
+              "rails_pulse_routes.path",
+              "SUM(rails_pulse_summaries.avg_duration * rails_pulse_summaries.count) / SUM(rails_pulse_summaries.count) as avg_duration",
+              "SUM(rails_pulse_summaries.count) as request_count",
+              "MAX(rails_pulse_summaries.period_end) as last_seen"
+            )
             .order("avg_duration DESC")
             .limit(5)
 
-          # Get last week's data for comparison
-          last_week_averages = RailsPulse::Request.joins(:route)
-            .where(occurred_at: last_week_start..last_week_end)
-            .group("rails_pulse_routes.path")
-            .average("rails_pulse_requests.duration")
-
-          # Build result array matching test expectations
-          this_week_data.map do |record|
-            this_week_avg = record.avg_duration.to_f.round(0)
-            last_week_avg = last_week_averages[record.path]&.round(0) || 0
-
-            # Calculate percentage change
-            percentage_change = if last_week_avg == 0
-              this_week_avg > 0 ? 100.0 : 0.0
-            else
-              ((this_week_avg - last_week_avg) / last_week_avg.to_f * 100).round(1)
-            end
-
-            # Determine trend (worse = slower response times)
-            trend = if last_week_avg == 0
-              this_week_avg > 0 ? "worse" : "stable"
-            elsif this_week_avg > last_week_avg
-              "worse"  # Slower = worse
-            elsif this_week_avg < last_week_avg
-              "better" # Faster = better
-            else
-              "stable"
-            end
-
+          # Build data rows
+          data_rows = route_data.map do |record|
             {
               route_path: record.path,
-              this_week_avg: this_week_avg,
-              last_week_avg: last_week_avg,
-              percentage_change: percentage_change,
+              route_id: record.route_id,
+              route_link: "/rails_pulse/routes/#{record.route_id}",
+              average_time: record.avg_duration.to_f.round(0),
               request_count: record.request_count,
-              trend: trend
+              last_request: time_ago_in_words(record.last_seen)
             }
           end
+
+          # Return new structure with columns and data
+          {
+            columns: [
+              { field: :route_path, label: "Route", link_to: :route_link, class: "w-auto" },
+              { field: :average_time, label: "Average Time", class: "w-32" },
+              { field: :request_count, label: "Requests", class: "w-24" },
+              { field: :last_request, label: "Last Request", class: "w-32" }
+            ],
+            data: data_rows
+          }
         end
       end
     end

data/app/models/rails_pulse/operation.rb

@@ -34,7 +34,7 @@ module RailsPulse
     before_validation :associate_query
 
     def self.ransackable_attributes(auth_object = nil)
-      %w[id occurred_at label duration start_time average_query_time_ms query_count operation_type]
+      %w[id occurred_at label duration start_time average_query_time_ms query_count operation_type query_id]
     end
 
     def self.ransackable_associations(auth_object = nil)

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

@@ -2,42 +2,66 @@ module RailsPulse
   module Queries
     module Cards
       class AverageQueryTimes
-        def initialize(query:)
+        def initialize(query: nil)
           @query = query
         end
 
         def to_metric_card
-          operations = if @query
-            RailsPulse::Operation.where(query: @query)
-          else
-            RailsPulse::Operation.all
-          end
-
-          # Calculate overall average response time
-          average_query_time = operations.average(:duration)&.round(0) || 0
-
-          # 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_avg = operations.where("occurred_at >= ?", last_7_days).average(:duration) || 0
-          previous_period_avg = operations.where("occurred_at >= ? AND occurred_at < ?", previous_7_days, last_7_days).average(:duration) || 0
 
-          percentage = previous_period_avg.zero? ?  0 : ((previous_period_avg - current_period_avg) / previous_period_avg * 100).abs.round(1)
-          trend_icon = percentage < 0.1 ?  "move-right" : current_period_avg < previous_period_avg ? "trending-down" : "trending-up"
+          # Single query to get all aggregated metrics with conditional sums
+          base_query = RailsPulse::Summary.where(
+            summarizable_type: "RailsPulse::Query",
+            period_type: "day",
+            period_start: 2.weeks.ago.beginning_of_day..Time.current
+          )
+          base_query = base_query.where(summarizable_id: @query.id) if @query
+
+          metrics = base_query.select(
+            "SUM(avg_duration * count) AS total_weighted_duration",
+            "SUM(count) AS total_requests",
+            "SUM(CASE WHEN period_start >= '#{last_7_days.strftime('%Y-%m-%d %H:%M:%S')}' THEN avg_duration * count ELSE 0 END) AS current_weighted_duration",
+            "SUM(CASE WHEN period_start >= '#{last_7_days.strftime('%Y-%m-%d %H:%M:%S')}' THEN count ELSE 0 END) AS current_requests",
+            "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 avg_duration * count ELSE 0 END) AS previous_weighted_duration",
+            "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_requests"
+          ).take
+
+          # Calculate metrics from single query result
+          average_query_time = metrics.total_requests.to_i > 0 ? (metrics.total_weighted_duration / metrics.total_requests).round(0) : 0
+          current_period_avg = metrics.current_requests.to_i > 0 ? (metrics.current_weighted_duration / metrics.current_requests) : 0
+          previous_period_avg = metrics.previous_requests.to_i > 0 ? (metrics.previous_weighted_duration / metrics.previous_requests) : 0
+
+          percentage = previous_period_avg.zero? ? 0 : ((previous_period_avg - current_period_avg) / previous_period_avg * 100).abs.round(1)
+          trend_icon = percentage < 0.1 ? "move-right" : current_period_avg < previous_period_avg ? "trending-down" : "trending-up"
           trend_amount = previous_period_avg.zero? ? "0%" : "#{percentage}%"
 
-          sparkline_data = operations
-            .group_by_week(:occurred_at, time_zone: "UTC")
-            .average(:duration)
-            .each_with_object({}) do |(date, avg), hash|
-              formatted_date = date.strftime("%b %-d")
-              value = avg&.round(0) || 0
-              hash[formatted_date] = {
-                value: value
-              }
-            end
+          # Sparkline data by day with zero-filled days over the last 14 days
+          # Use Groupdate to get grouped sums and compute weighted averages per day
+          grouped_weighted = base_query
+            .group_by_day(:period_start, time_zone: "UTC")
+            .sum(Arel.sql("avg_duration * count"))
+
+          grouped_counts = base_query
+            .group_by_day(:period_start, time_zone: "UTC")
+            .sum(:count)
+
+          # Build a continuous 14-day range, fill missing days with 0
+          start_day = 2.weeks.ago.beginning_of_day.to_date
+          end_day = Time.current.to_date
+
+          sparkline_data = {}
+          (start_day..end_day).each do |day|
+            weighted_sum = grouped_weighted[day] || 0
+            count_sum = grouped_counts[day] || 0
+            avg = count_sum > 0 ? (weighted_sum.to_f / count_sum).round(0) : 0
+            label = day.strftime("%b %-d")
+            sparkline_data[label] = { value: avg }
+          end
 
           {
+            id: "average_query_times",
+            context: "queries",
             title: "Average Query Time",
             summary: "#{average_query_time} ms",
             line_chart_data: sparkline_data,

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

@@ -7,44 +7,56 @@ module RailsPulse
         end
 
         def to_metric_card
-          operations = if @query
-            RailsPulse::Operation.where(query: @query)
-          else
-            RailsPulse::Operation.all
-          end
-
-          # Calculate total request count
-          total_request_count = operations.count
-
-          # 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 = operations.where("occurred_at >= ?", last_7_days).count
-          previous_period_count = operations.where("occurred_at >= ? AND occurred_at < ?", previous_7_days, last_7_days).count
+
+          # Single query to get all count metrics with conditional aggregation
+          base_query = RailsPulse::Summary.where(
+            summarizable_type: "RailsPulse::Query",
+            period_type: "day",
+            period_start: 2.weeks.ago.beginning_of_day..Time.current
+          )
+          base_query = base_query.where(summarizable_id: @query.id) if @query
+
+          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 metrics from single query result
+          total_execution_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 = operations
-            .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
-              }
-            end
-
-          # Calculate average operations per minute
-          min_time = operations.minimum(:occurred_at)
-          max_time = operations.maximum(:occurred_at)
-          total_minutes = min_time && max_time && min_time != max_time ? (max_time - min_time) / 60.0 : 1
-          average_operations_per_minute = total_request_count / total_minutes
+          # Sparkline data by day with zero-filled days over the last 14 days
+          grouped_daily = base_query
+            .group_by_day(:period_start, time_zone: "UTC")
+            .sum(:count)
+
+          start_day = 2.weeks.ago.beginning_of_day.to_date
+          end_day = Time.current.to_date
+
+          sparkline_data = {}
+          (start_day..end_day).each do |day|
+            total = grouped_daily[day] || 0
+            label = day.strftime("%b %-d")
+            sparkline_data[label] = { value: total }
+          end
+
+          # Calculate average executions per minute over 2-week period
+          total_minutes = 2.weeks / 1.minute
+          average_executions_per_minute = total_execution_count / total_minutes
 
           {
+            id: "execution_rate",
+            context: "queries",
             title: "Execution Rate",
-            summary: "#{average_operations_per_minute.round(2)} / min",
+            summary: "#{average_executions_per_minute.round(2)} / min",
             line_chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,

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

@@ -7,58 +7,52 @@ module RailsPulse
         end
 
         def to_metric_card
-          operations = if @query
-            RailsPulse::Operation.where(query: @query)
-          else
-            RailsPulse::Operation.all
-          end
-
-          # Calculate overall 95th percentile response time
-          count = operations.count
-          percentile_95th = if count > 0
-            operations.select("duration").order("duration").limit(1).offset((count * 0.95).floor).pluck(:duration).first || 0
-          else
-            0
-          end
-
-          # Calculate trend by comparing last 7 days vs previous 7 days for 95th percentile
           last_7_days = 7.days.ago.beginning_of_day
           previous_7_days = 14.days.ago.beginning_of_day
 
-          current_period = operations.where("occurred_at >= ?", last_7_days)
-          current_count = current_period.count
-          current_period_95th = if current_count > 0
-            current_period.select("duration").order("duration").limit(1).offset((current_count * 0.95).floor).pluck(:duration).first || 0
-          else
-            0
-          end
+          # Single query to get all P95 metrics with conditional aggregation
+          base_query = RailsPulse::Summary.where(
+            summarizable_type: "RailsPulse::Query",
+            period_type: "day",
+            period_start: 2.weeks.ago.beginning_of_day..Time.current
+          )
+          base_query = base_query.where(summarizable_id: @query.id) if @query
 
-          previous_period = operations.where("occurred_at >= ? AND occurred_at < ?", previous_7_days, last_7_days)
-          previous_count = previous_period.count
-          previous_period_95th = if previous_count > 0
-            previous_period.select("duration").order("duration").limit(1).offset((previous_count * 0.95).floor).pluck(:duration).first || 0
-          else
-            0
-          end
+          metrics = base_query.select(
+            "AVG(p95_duration) AS overall_p95",
+            "AVG(CASE WHEN period_start >= '#{last_7_days.strftime('%Y-%m-%d %H:%M:%S')}' THEN p95_duration ELSE NULL END) AS current_p95",
+            "AVG(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 p95_duration ELSE NULL END) AS previous_p95"
+          ).take
+
+          # Calculate metrics from single query result
+          p95_query_time = (metrics.overall_p95 || 0).round(0)
+          current_period_p95 = metrics.current_p95 || 0
+          previous_period_p95 = metrics.previous_p95 || 0
+
+          percentage = previous_period_p95.zero? ? 0 : ((previous_period_p95 - current_period_p95) / previous_period_p95 * 100).abs.round(1)
+          trend_icon = percentage < 0.1 ? "move-right" : current_period_p95 < previous_period_p95 ? "trending-down" : "trending-up"
+          trend_amount = previous_period_p95.zero? ? "0%" : "#{percentage}%"
 
-          percentage = previous_period_95th.zero? ?  0 : ((previous_period_95th - current_period_95th) / previous_period_95th * 100).abs.round(1)
-          trend_icon = percentage < 0.1 ?  "move-right" : current_period_95th < previous_period_95th ? "trending-down" : "trending-up"
-          trend_amount = previous_period_95th.zero? ? "0%" : "#{percentage}%"
+          # Sparkline data by day with zero-filled days over the last 14 days
+          grouped_daily = base_query
+            .group_by_day(:period_start, time_zone: "UTC")
+            .average(:p95_duration)
 
-          sparkline_data = operations
-            .group_by_week(:occurred_at, time_zone: "UTC")
-            .average(:duration)
-            .each_with_object({}) do |(date, avg), hash|
-              formatted_date = date.strftime("%b %-d")
-              value = avg&.round(0) || 0
-              hash[formatted_date] = {
-                value: value
-              }
-            end
+          start_day = 2.weeks.ago.beginning_of_day.to_date
+          end_day = Time.current.to_date
+
+          sparkline_data = {}
+          (start_day..end_day).each do |day|
+            avg = grouped_daily[day]&.round(0) || 0
+            label = day.strftime("%b %-d")
+            sparkline_data[label] = { value: avg }
+          end
 
           {
+            id: "percentile_query_times",
+            context: "queries",
             title: "95th Percentile Query Time",
-            summary: "#{percentile_95th} ms",
+            summary: "#{p95_query_time} ms",
             line_chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,