rails_pulse 0.1.2 → 0.1.4

data/app/models/rails_pulse/query.rb

@@ -9,6 +9,13 @@ module RailsPulse
     # 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
@@ -52,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/request.rb

@@ -52,7 +52,7 @@ module RailsPulse
     end
 
     def to_s
-      occurred_at.strftime("%b %d, %Y %l:%M %p")
+      occurred_at.getlocal.strftime("%b %d, %Y %l:%M %p")
     end
 
     private

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

@@ -13,11 +13,11 @@ module RailsPulse
 
         def to_rails_chart
           summaries = @ransack_query.result(distinct: false).where(
-            summarizable_type: "RailsPulse::Route",
+            summarizable_type: "RailsPulse::Request",
+            summarizable_id: 0,  # Overall request summaries
             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)

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

@@ -0,0 +1,77 @@
+module RailsPulse
+  module Requests
+    module Tables
+      class Index
+        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
+          # Check if we have explicit ransack sorts
+          has_sorts = @ransack_query.sorts.any?
+
+          base_query = @ransack_query.result(distinct: false)
+            .where(
+              summarizable_type: "RailsPulse::Request",
+              summarizable_id: 0,  # Overall request summaries
+              period_type: @period_type
+            )
+
+          # Apply grouping and aggregation for time periods
+          grouped_query = base_query
+            .group(
+              "rails_pulse_summaries.period_start",
+              "rails_pulse_summaries.period_end",
+              "rails_pulse_summaries.period_type"
+            )
+            .select(
+              "rails_pulse_summaries.period_start",
+              "rails_pulse_summaries.period_end",
+              "rails_pulse_summaries.period_type",
+              "AVG(rails_pulse_summaries.avg_duration) as avg_duration",
+              "MAX(rails_pulse_summaries.max_duration) as max_duration",
+              "MIN(rails_pulse_summaries.min_duration) as min_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"
+            )
+
+          # 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"
+              grouped_query = grouped_query.order(Arel.sql("AVG(rails_pulse_summaries.avg_duration)").send(direction))
+            when "max_duration"
+              grouped_query = grouped_query.order(Arel.sql("MAX(rails_pulse_summaries.max_duration)").send(direction))
+            when "min_duration"
+              grouped_query = grouped_query.order(Arel.sql("MIN(rails_pulse_summaries.min_duration)").send(direction))
+            when "count"
+              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 "period_start"
+              grouped_query = grouped_query.order(period_start: direction)
+            else
+              # Unknown sort field, fallback to default
+              grouped_query = grouped_query.order(period_start: :desc)
+            end
+          else
+            # Apply default sort when no explicit sort is provided (matches controller default_table_sort)
+            grouped_query = grouped_query.order(period_start: :desc)
+          end
+
+          grouped_query
+        end
+      end
+    end
+  end
+end

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

@@ -36,27 +36,25 @@ module RailsPulse
           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}%"
 
-          # Separate query for sparkline data - manually calculate weighted averages by week
-          sparkline_data = {}
-          base_query.each do |summary|
-            week_start = summary.period_start.beginning_of_week
-            formatted_date = week_start.strftime("%b %-d")
+          # 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"))
 
-            if sparkline_data[formatted_date]
-              sparkline_data[formatted_date][:total_weighted] += (summary.avg_duration || 0) * (summary.count || 0)
-              sparkline_data[formatted_date][:total_count] += (summary.count || 0)
-            else
-              sparkline_data[formatted_date] = {
-                total_weighted: (summary.avg_duration || 0) * (summary.count || 0),
-                total_count: (summary.count || 0)
-              }
-            end
-          end
+          grouped_counts = base_query
+            .group_by_day(:period_start, time_zone: "UTC")
+            .sum(:count)
 
-          # Convert to final format
-          sparkline_data = sparkline_data.transform_values do |data|
-            weighted_avg = data[:total_count] > 0 ? (data[:total_weighted] / data[:total_count]).round(0) : 0
-            { value: weighted_avg }
+          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
 
           {
@@ -64,7 +62,7 @@ module RailsPulse
             context: "routes",
             title: "Average Response Time",
             summary: "#{average_response_time} ms",
-            line_chart_data: sparkline_data,
+            chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,
             trend_text: "Compared to last week"

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

@@ -39,22 +39,27 @@ module RailsPulse
           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}%"
 
-          # Separate query for sparkline data - group by week using Rails
-          sparkline_data = base_query
-            .group_by_week(:period_start, time_zone: "UTC")
+          # 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)
-            .each_with_object({}) do |(week_start, total_errors), hash|
-              formatted_date = week_start.strftime("%b %-d")
-              value = total_errors || 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|
+            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",
             summary: "#{overall_error_rate}%",
-            line_chart_data: sparkline_data,
+            chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,
             trend_text: "Compared to last week"

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

@@ -33,22 +33,27 @@ module RailsPulse
           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}%"
 
-          # Separate query for sparkline data - group by week using Rails
-          sparkline_data = base_query
-            .group_by_week(:period_start, time_zone: "UTC")
+          # 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)
-            .each_with_object({}) do |(week_start, avg_p95), hash|
-              formatted_date = week_start.strftime("%b %-d")
-              value = (avg_p95 || 0).round(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_response_times",
             context: "routes",
             title: "95th Percentile Response Time",
             summary: "#{p95_response_time} ms",
-            line_chart_data: sparkline_data,
+            chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,
             trend_text: "Compared to last week"

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

@@ -33,26 +33,42 @@ module RailsPulse
           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}%"
 
-          # Separate query for sparkline data - group by week using Rails
-          sparkline_data = base_query
-            .group_by_week(:period_start, time_zone: "UTC")
+          # 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)
-            .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 over 2-week period
-          total_minutes = 2.weeks / 1.minute
-          average_requests_per_minute = total_request_count / total_minutes
+          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 appropriate rate display based on frequency
+          total_minutes = 2.weeks / 1.minute.to_f
+          requests_per_minute = total_request_count.to_f / total_minutes
+
+          # Choose appropriate time unit for display
+          if requests_per_minute >= 1
+            summary = "#{requests_per_minute.round(2)} / min"
+          elsif requests_per_minute * 60 >= 1
+            requests_per_hour = requests_per_minute * 60
+            summary = "#{requests_per_hour.round(2)} / hour"
+          else
+            requests_per_day = requests_per_minute * 60 * 24
+            summary = "#{requests_per_day.round(2)} / day"
+          end
 
           {
             id: "request_count_totals",
             context: "routes",
             title: "Request Count Total",
-            summary: "#{average_requests_per_minute.round(2)} / min",
-            line_chart_data: sparkline_data,
+            summary: summary,
+            chart_data: sparkline_data,
             trend_icon: trend_icon,
             trend_amount: trend_amount,
             trend_text: "Compared to last week"

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

@@ -13,7 +13,9 @@ module RailsPulse
           # Check if we have explicit ransack sorts
           has_sorts = @ransack_query.sorts.any?
 
-          base_query = @ransack_query.result(distinct: false)
+          # Store sorts for later and get result without ordering
+          # This prevents PostgreSQL GROUP BY issues with ORDER BY columns
+          base_query = @ransack_query.result(distinct: false).reorder(nil)
             .joins("INNER JOIN rails_pulse_routes ON rails_pulse_routes.id = rails_pulse_summaries.summarizable_id")
             .where(
               summarizable_type: "RailsPulse::Route",
@@ -55,7 +57,7 @@ module RailsPulse
               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"
+            when "count_sort", "request_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))

data/app/models/rails_pulse/summary.rb

@@ -36,9 +36,10 @@ module RailsPulse
     # Ransack configuration
     def self.ransackable_attributes(auth_object = nil)
       %w[
-        period_start period_end avg_duration max_duration count error_count
+        period_start period_end avg_duration min_duration max_duration count error_count
         requests_per_minute error_rate_percentage route_path_cont
         execution_count total_time_consumed normalized_sql
+        summarizable_id summarizable_type
       ]
     end
 
@@ -46,17 +47,16 @@ module RailsPulse
       %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
+    # Note: Basic fields like count, avg_duration, min_duration, max_duration
+    # are handled automatically by Ransack using actual database columns
 
+    # Custom ransackers for calculated fields only
     ransacker :requests_per_minute do
-      Arel.sql("SUM(rails_pulse_summaries.count) / 60.0")  # Use SUM for consistency
+      Arel.sql("rails_pulse_summaries.count / 60.0")
     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
+      Arel.sql("(rails_pulse_summaries.error_count * 100.0) / rails_pulse_summaries.count")
     end
 
 

data/app/services/rails_pulse/analysis/backtrace_analyzer.rb

@@ -0,0 +1,256 @@
+# Analyzes execution backtraces to identify code hotspots and execution patterns.
+# Tracks most common execution locations, controller/model usage, and framework layer distribution.
+module RailsPulse
+  module Analysis
+    class BacktraceAnalyzer < BaseAnalyzer
+      def analyze
+        backtraces = extract_backtraces
+
+        {
+          total_executions: operations.count,
+          unique_locations: backtraces.uniq.count,
+          most_common_location: find_most_common_location(backtraces),
+          potential_n_plus_one: detect_simple_n_plus_one_pattern,
+          execution_frequency: calculate_execution_frequency,
+          location_distribution: calculate_location_distribution(backtraces),
+          code_hotspots: identify_code_hotspots(backtraces),
+          execution_contexts: analyze_execution_contexts(backtraces)
+        }
+      end
+
+      private
+
+      def extract_backtraces
+        operations.filter_map(&:codebase_location).compact
+      end
+
+      def find_most_common_location(backtraces)
+        return nil if backtraces.empty?
+
+        frequency = backtraces.tally
+        most_common = frequency.max_by { |_, count| count }
+
+        return nil unless most_common
+
+        {
+          location: most_common[0],
+          count: most_common[1],
+          percentage: (most_common[1].to_f / backtraces.length * 100).round(1)
+        }
+      end
+
+      def detect_simple_n_plus_one_pattern
+        # Simple N+1 detection: many operations with same query in short time
+        time_window = 1.minute
+        groups = operations.group_by { |op| op.occurred_at.beginning_of_minute }
+
+        suspicious_groups = groups.select { |_, ops| ops.count > 10 }
+
+        {
+          detected: suspicious_groups.any?,
+          suspicious_periods: suspicious_groups.map do |time, ops|
+            {
+              period: time.strftime("%Y-%m-%d %H:%M"),
+              count: ops.count,
+              avg_duration: ops.sum(&:duration) / ops.count
+            }
+          end
+        }
+      end
+
+      def calculate_execution_frequency
+        return 0 if operations.empty? || operations.count < 2
+
+        time_span = operations.last.occurred_at - operations.first.occurred_at
+        return operations.count if time_span <= 0
+
+        (operations.count / time_span.in_hours).round(2)
+      end
+
+      def calculate_location_distribution(backtraces)
+        return {} if backtraces.empty?
+
+        total = backtraces.length
+        distribution = backtraces.tally.transform_values { |count| (count.to_f / total * 100).round(1) }
+
+        # Sort by frequency and return top locations
+        distribution.sort_by { |_, percentage| -percentage }.first(10).to_h
+      end
+
+      def identify_code_hotspots(backtraces)
+        return [] if backtraces.empty?
+
+        # Group by file/method to identify hotspots
+        hotspots = []
+
+        # Group by controller actions
+        controller_hotspots = group_by_controller_actions(backtraces)
+        hotspots.concat(controller_hotspots)
+
+        # Group by model methods
+        model_hotspots = group_by_model_methods(backtraces)
+        hotspots.concat(model_hotspots)
+
+        # Group by file
+        file_hotspots = group_by_files(backtraces)
+        hotspots.concat(file_hotspots)
+
+        # Sort by frequency and return top hotspots
+        hotspots.sort_by { |hotspot| -hotspot[:count] }.first(10)
+      end
+
+      def group_by_controller_actions(backtraces)
+        controller_traces = backtraces.select { |trace| trace.include?("app/controllers/") }
+
+        controller_actions = controller_traces.filter_map do |trace|
+          match = trace.match(%r{app/controllers/(.+?)\.rb.*in `(.+?)'})
+          next unless match
+
+          controller = match[1].gsub("_controller", "").humanize
+          action = match[2]
+          "#{controller}##{action}"
+        end
+
+        build_hotspot_data(controller_actions, "controller_action")
+      end
+
+      def group_by_model_methods(backtraces)
+        model_traces = backtraces.select { |trace| trace.include?("app/models/") }
+
+        model_methods = model_traces.filter_map do |trace|
+          match = trace.match(%r{app/models/(.+?)\.rb.*in `(.+?)'})
+          next unless match
+
+          model = match[1].classify
+          method = match[2]
+          "#{model}.#{method}"
+        end
+
+        build_hotspot_data(model_methods, "model_method")
+      end
+
+      def group_by_files(backtraces)
+        files = backtraces.filter_map do |trace|
+          match = trace.match(%r{(app/[^:]+)})
+          match[1] if match
+        end
+
+        build_hotspot_data(files, "file")
+      end
+
+      def build_hotspot_data(items, type)
+        return [] if items.empty?
+
+        item_counts = items.tally
+        total_operations = operations.count
+
+        item_counts.map do |item, count|
+          {
+            type: type,
+            location: item,
+            count: count,
+            percentage: (count.to_f / total_operations * 100).round(1),
+            operations_per_execution: (count.to_f / item_counts.values.sum * total_operations).round(2)
+          }
+        end
+      end
+
+      def analyze_execution_contexts(backtraces)
+        return {} if backtraces.empty?
+
+        contexts = {
+          framework_layers: analyze_framework_layers(backtraces),
+          application_layers: analyze_application_layers(backtraces),
+          gem_usage: analyze_gem_usage(backtraces),
+          database_access_patterns: analyze_database_access_patterns(backtraces)
+        }
+
+        contexts
+      end
+
+      def analyze_framework_layers(backtraces)
+        layers = {
+          controller: backtraces.count { |trace| trace.include?("app/controllers/") },
+          model: backtraces.count { |trace| trace.include?("app/models/") },
+          view: backtraces.count { |trace| trace.include?("app/views/") },
+          service: backtraces.count { |trace| trace.include?("app/services/") },
+          job: backtraces.count { |trace| trace.include?("app/jobs/") },
+          rails_framework: backtraces.count { |trace| trace.include?("railties") || trace.include?("actionpack") },
+          activerecord: backtraces.count { |trace| trace.include?("activerecord") }
+        }
+
+        total = backtraces.count
+        layers.transform_values { |count| { count: count, percentage: (count.to_f / total * 100).round(1) } }
+      end
+
+      def analyze_application_layers(backtraces)
+        app_traces = backtraces.select { |trace| trace.include?("app/") }
+
+        layers = {}
+        app_traces.each do |trace|
+          layer = extract_app_layer(trace)
+          layers[layer] ||= 0
+          layers[layer] += 1
+        end
+
+        total = app_traces.count
+        layers.transform_values { |count| { count: count, percentage: (count.to_f / total * 100).round(1) } }
+      end
+
+      def extract_app_layer(trace)
+        case trace
+        when /app\/controllers/ then :controllers
+        when /app\/models/ then :models
+        when /app\/services/ then :services
+        when /app\/jobs/ then :jobs
+        when /app\/mailers/ then :mailers
+        when /app\/helpers/ then :helpers
+        when /app\/views/ then :views
+        when /app\/lib/ then :lib
+        else :other
+        end
+      end
+
+      def analyze_gem_usage(backtraces)
+        gem_traces = backtraces.reject { |trace| trace.include?("app/") || trace.include?("config/") }
+
+        gems = gem_traces.filter_map do |trace|
+          # Extract gem name from path like "/gems/gem_name-version/lib/..."
+          match = trace.match(%r{/gems/([^/]+)/})
+          match[1].split("-").first if match
+        end
+
+        gem_counts = gems.tally
+        total = gem_traces.count
+
+        gem_counts.transform_values { |count| { count: count, percentage: (count.to_f / total * 100).round(1) } }
+                 .sort_by { |_, data| -data[:count] }
+                 .first(5)
+                 .to_h
+      end
+
+      def analyze_database_access_patterns(backtraces)
+        db_traces = backtraces.select { |trace|
+          trace.include?("activerecord") ||
+          trace.include?("execute_query") ||
+          trace.include?("adapter")
+        }
+
+        {
+          total_db_operations: db_traces.count,
+          percentage_db_operations: (db_traces.count.to_f / backtraces.count * 100).round(1),
+          common_db_methods: extract_common_db_methods(db_traces)
+        }
+      end
+
+      def extract_common_db_methods(db_traces)
+        methods = db_traces.filter_map do |trace|
+          match = trace.match(/in `(.+?)'/)
+          match[1] if match
+        end
+
+        methods.tally.sort_by { |_, count| -count }.first(5).to_h
+      end
+    end
+  end
+end