rails_pulse 0.1.1 → 0.1.3

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

@@ -2,109 +2,35 @@ module RailsPulse
   module Queries
     module Charts
       class AverageQueryTimes
-        def initialize(ransack_query:, group_by: :group_by_day, query: nil)
+        def initialize(ransack_query:, period_type: nil, query: nil, start_time: nil, end_time: nil, start_duration: nil)
           @ransack_query = ransack_query
-          @group_by = group_by
+          @period_type = period_type
           @query = query
+          @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 @query
-            @ransack_query.result(distinct: false)
-              .public_send(@group_by, "occurred_at", series: true, time_zone: "UTC")
-              .average(:duration)
-          else
-            @ransack_query.result(distinct: false)
-              .left_joins(:operations)
-              .public_send(
-                @group_by,
-                "rails_pulse_operations.occurred_at",
-                series: true,
-                time_zone: "UTC"
-              )
-              .average("rails_pulse_operations.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 @query
-            # For specific query, 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 operations, look for rails_pulse_operations_occurred_at conditions
-            start_condition = conditions.find { |c| c.a.first == "rails_pulse_operations_occurred_at" && c.p == "gteq" }
-            end_condition = conditions.find { |c| c.a.first == "rails_pulse_operations_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::Query",
+            period_type: @period_type
+          )
+
+          summaries = summaries.where(summarizable_id: @query.id) if @query
+          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/queries/tables/index.rb

@@ -0,0 +1,74 @@
+module RailsPulse
+  module Queries
+    module Tables
+      class Index
+        def initialize(ransack_query:, period_type: nil, start_time:, params:, query: nil)
+          @ransack_query = ransack_query
+          @period_type = period_type
+          @start_time = start_time
+          @params = params
+          @query = query
+        end
+
+        def to_table
+          # Check if we have explicit ransack sorts
+          has_sorts = @ransack_query.sorts.any?
+
+          base_query = @ransack_query.result(distinct: false)
+            .joins("INNER JOIN rails_pulse_queries ON rails_pulse_queries.id = rails_pulse_summaries.summarizable_id")
+            .where(
+              summarizable_type: "RailsPulse::Query",
+              period_type: @period_type
+            )
+
+          base_query = base_query.where(summarizable_id: @query.id) if @query
+
+          # Apply grouping and aggregation
+          grouped_query = base_query
+            .group(
+              "rails_pulse_summaries.summarizable_id",
+              "rails_pulse_summaries.summarizable_type",
+              "rails_pulse_queries.id",
+              "rails_pulse_queries.normalized_sql"
+            )
+            .select(
+              "rails_pulse_summaries.summarizable_id",
+              "rails_pulse_summaries.summarizable_type",
+              "rails_pulse_queries.id as query_id",
+              "rails_pulse_queries.normalized_sql",
+              "AVG(rails_pulse_summaries.avg_duration) as avg_duration",
+              "MAX(rails_pulse_summaries.max_duration) as max_duration",
+              "SUM(rails_pulse_summaries.count) as execution_count",
+              "SUM(rails_pulse_summaries.count * rails_pulse_summaries.avg_duration) as total_time_consumed"
+            )
+
+          # 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
+
+            case sort.name
+            when "avg_duration_sort"
+              grouped_query = grouped_query.order(Arel.sql("AVG(rails_pulse_summaries.avg_duration)").send(direction))
+            when "execution_count_sort"
+              grouped_query = grouped_query.order(Arel.sql("SUM(rails_pulse_summaries.count)").send(direction))
+            when "total_time_consumed_sort"
+              grouped_query = grouped_query.order(Arel.sql("SUM(rails_pulse_summaries.count * rails_pulse_summaries.avg_duration)").send(direction))
+            when "normalized_sql"
+              grouped_query = grouped_query.order(Arel.sql("rails_pulse_queries.normalized_sql").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
+            grouped_query = grouped_query.order(Arel.sql("AVG(rails_pulse_summaries.avg_duration)").desc)
+          end
+
+          grouped_query
+        end
+      end
+    end
+  end
+end

data/app/models/rails_pulse/query.rb

@@ -4,10 +4,18 @@ module RailsPulse
 
     # Associations
     has_many :operations, class_name: "RailsPulse::Operation", inverse_of: :query
+    has_many :summaries, as: :summarizable, class_name: "RailsPulse::Summary", dependent: :destroy
 
     # Validations
     validates :normalized_sql, presence: true, uniqueness: true
 
+    # JSON serialization for analysis columns
+    serialize :issues, type: Array, coder: JSON
+    serialize :metadata, type: Hash, coder: JSON
+    serialize :query_stats, type: Hash, coder: JSON
+    serialize :backtrace_analysis, type: Hash, coder: JSON
+    serialize :suggestions, type: Array, coder: JSON
+
     def self.ransackable_attributes(auth_object = nil)
       %w[id normalized_sql average_query_time_ms execution_count total_time_consumed performance_status occurred_at]
     end
@@ -51,6 +59,45 @@ module RailsPulse
       Arel.sql("MAX(rails_pulse_operations.occurred_at)")
     end
 
+    # Analysis helper methods
+    def analyzed?
+      analyzed_at.present?
+    end
+
+    def has_recent_operations?
+      operations.where("occurred_at > ?", 48.hours.ago).exists?
+    end
+
+    def needs_reanalysis?
+      return true unless analyzed?
+
+      # Check if there are new operations since analysis
+      last_operation_time = operations.maximum(:occurred_at)
+      return false unless last_operation_time
+
+      last_operation_time > analyzed_at
+    end
+
+    def analysis_status
+      return "not_analyzed" unless analyzed?
+      return "needs_update" if needs_reanalysis?
+      "current"
+    end
+
+    def issues_by_severity
+      return {} unless analyzed? && issues.present?
+
+      issues.group_by { |issue| issue["severity"] || "unknown" }
+    end
+
+    def critical_issues_count
+      issues_by_severity["critical"]&.count || 0
+    end
+
+    def warning_issues_count
+      issues_by_severity["warning"]&.count || 0
+    end
+
     def to_s
       id
     end

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

@@ -2,96 +2,35 @@ module RailsPulse
   module Requests
     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 = @ransack_query.result(distinct: false)
-            .public_send(
-              @group_by,
-              "rails_pulse_requests.occurred_at",
-              series: true,
-              time_zone: "UTC"
-            )
-            .average("rails_pulse_requests.duration")
-
-          # 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
-
-          # For requests, look for occurred_at conditions on rails_pulse_requests
-          start_condition = conditions.find { |c| c.a.first == "rails_pulse_requests_occurred_at" && c.p == "gteq" }
-          end_condition = conditions.find { |c| c.a.first == "rails_pulse_requests_occurred_at" && c.p == "lt" }
-
-          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/route.rb

@@ -4,6 +4,7 @@ module RailsPulse
 
     # Associations
     has_many :requests, class_name: "RailsPulse::Request", foreign_key: "route_id", dependent: :restrict_with_exception
+    has_many :summaries, as: :summarizable, class_name: "RailsPulse::Summary", dependent: :destroy
 
     # Validations
     validates :method, presence: true
@@ -56,12 +57,6 @@ module RailsPulse
       Arel.sql("COUNT(rails_pulse_requests.id)")
     end
 
-    # Remove the problematic ransacker that causes SQL syntax errors
-    # The status_indicator will be handled differently or removed from filtering
-    # ransacker :status_indicator do
-    #   # Removed to fix SQL generation issues in tests
-    # end
-
     def to_breadcrumb
       path
     end

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

@@ -7,39 +7,59 @@ 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 aggregated metrics with conditional sums
+          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 overall average response time
-          average_response_time = requests.average(:duration)&.round(0) || 0
+          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 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 = requests.where("occurred_at >= ?", last_7_days).average(:duration) || 0
-          previous_period_avg = requests.where("occurred_at >= ? AND occurred_at < ?", previous_7_days, last_7_days).average(:duration) || 0
+          # Calculate metrics from single query result
+          average_response_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"
+          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 = requests
-            .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
+          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)
+
+          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_response_times",
+            context: "routes",
             title: "Average Response Time",
             summary: "#{average_response_time} ms",
             line_chart_data: sparkline_data,

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

@@ -7,60 +7,58 @@ module RailsPulse
         end
 
         def to_metric_card
-          # Calculate error rate for each route or a specific route
-          routes = if @route
-            RailsPulse::Route.where(id: @route)
-          else
-            RailsPulse::Route.all
-          end
+          last_7_days = 7.days.ago.beginning_of_day
+          previous_7_days = 14.days.ago.beginning_of_day
 
-          routes = routes.where("occurred_at >= ?", 2.weeks.ago.beginning_of_day)
+          # Single query to get all error 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
 
-          error_rates = routes.joins(:requests)
-            .select("rails_pulse_routes.id, rails_pulse_routes.path, COUNT(rails_pulse_requests.id) as total_requests, SUM(CASE WHEN rails_pulse_requests.is_error = true THEN 1 ELSE 0 END) as error_count")
-            .group("rails_pulse_routes.id, rails_pulse_routes.path")
-            .map do |route|
-              error_rate = route.error_count.to_f / route.total_requests * 100
-              {
-                path: route.path,
-                error_rate: error_rate.round(2)
-              }
-            end
+          metrics = base_query.select(
+            "SUM(error_count) AS total_errors",
+            "SUM(count) AS total_requests",
+            "SUM(CASE WHEN period_start >= '#{last_7_days.strftime('%Y-%m-%d %H:%M:%S')}' THEN error_count ELSE 0 END) AS current_errors",
+            "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 error_count ELSE 0 END) AS previous_errors"
+          ).take
 
-          # Calculate overall error rate summary as errors per day
-          requests = @route ? RailsPulse::Request.where(route: @route) : RailsPulse::Request.all
-          total_errors = requests.where(is_error: true).count
-          min_time = requests.minimum(:occurred_at)
-          max_time = requests.maximum(:occurred_at)
-          total_days = min_time && max_time && min_time != max_time ? (max_time - min_time) / 1.day : 1
-          errors_per_day = total_errors / total_days
-          error_rate_summary = "#{errors_per_day.round(2)} / day"
+          # Calculate metrics from single query result
+          total_errors = metrics.total_errors || 0
+          total_requests = metrics.total_requests || 0
+          current_period_errors = metrics.current_errors || 0
+          previous_period_errors = metrics.previous_errors || 0
 
-          # Generate sparkline data
-          sparkline_data = requests
-            .where(is_error: true)
-            .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 overall error rate percentage
+          overall_error_rate = total_requests > 0 ? (total_errors.to_f / total_requests * 100).round(2) : 0
 
-          # Determine trend direction and amount
-          last_7_days = 7.days.ago.beginning_of_day
-          previous_7_days = 14.days.ago.beginning_of_day
-          current_period_errors = requests.where("occurred_at >= ? AND is_error = ?", last_7_days, true).count
-          previous_period_errors = requests.where("occurred_at >= ? AND occurred_at < ? AND is_error = ?", previous_7_days, last_7_days, true).count
+          # Calculate trend
+          percentage = previous_period_errors.zero? ? 0 : ((previous_period_errors - current_period_errors) / previous_period_errors.to_f * 100).abs.round(1)
+          trend_icon = percentage < 0.1 ? "move-right" : current_period_errors < previous_period_errors ? "trending-down" : "trending-up"
+          trend_amount = previous_period_errors.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")
+            .sum(:error_count)
 
-          trend_amount = previous_period_errors.zero? ? "0%" : "#{((current_period_errors - previous_period_errors) / previous_period_errors.to_f * 100).round(1)}%"
-          trend_icon = trend_amount.to_f < 0.1 ? "move-right" : current_period_errors < previous_period_errors ? "trending-down" : "trending-up"
+          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
 
           {
+            id: "error_rate_per_route",
+            context: "routes",
             title: "Error Rate Per Route",
-            data: error_rates,
-            summary: error_rate_summary,
+            summary: "#{overall_error_rate}%",
             line_chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,