rails_pulse 0.1.1 → 0.1.3

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

@@ -0,0 +1,217 @@
+# Consolidates analysis results into prioritized, actionable optimization suggestions.
+# Combines insights from all analyzers and categorizes suggestions by impact and implementation complexity.
+module RailsPulse
+  module Analysis
+    class SuggestionGenerator
+      attr_reader :analysis_results
+
+      def initialize(analysis_results)
+        @analysis_results = analysis_results
+      end
+
+      def generate
+        suggestions = []
+
+        # Suggestions from pattern issues
+        suggestions.concat(generate_issue_suggestions)
+
+        # Suggestions from index recommendations
+        suggestions.concat(generate_index_suggestions)
+
+        # Suggestions from N+1 analysis
+        suggestions.concat(generate_n_plus_one_suggestions)
+
+        # Suggestions from query characteristics
+        suggestions.concat(generate_query_characteristic_suggestions)
+
+        # Suggestions from explain plan issues
+        suggestions.concat(generate_explain_plan_suggestions)
+
+        # Prioritize and deduplicate suggestions
+        prioritize_suggestions(suggestions)
+      end
+
+      private
+
+      def generate_issue_suggestions
+        issues = analysis_results.dig(:query_characteristics, :pattern_issues) || []
+
+        issues.map do |issue|
+          case issue[:type]
+          when "select_star"
+            {
+              type: "optimization",
+              action: "Specify only needed columns instead of SELECT *",
+              benefit: "Reduced memory usage and faster data transfer",
+              priority: "medium",
+              category: "sql_optimization"
+            }
+          when "missing_limit"
+            {
+              type: "optimization",
+              action: "Add LIMIT clause to prevent large result sets",
+              benefit: "Controlled memory usage and faster response times",
+              priority: "high",
+              category: "sql_optimization"
+            }
+          when "missing_where_clause"
+            {
+              type: "optimization",
+              action: "Add WHERE clause to filter results",
+              benefit: "Avoid full table scans and reduce data transfer",
+              priority: "high",
+              category: "sql_optimization"
+            }
+          when "complex_where_clause"
+            {
+              type: "refactoring",
+              action: "Simplify WHERE clause by breaking into multiple queries or using views",
+              benefit: "Easier maintenance and potentially better performance",
+              priority: "medium",
+              category: "code_quality"
+            }
+          end
+        end.compact
+      end
+
+      def generate_index_suggestions
+        recommendations = analysis_results[:index_recommendations] || []
+
+        recommendations.map do |rec|
+          {
+            type: "index",
+            action: "Add #{rec[:type]} index: #{rec[:migration_code]}",
+            benefit: rec[:estimated_benefit],
+            priority: rec[:priority],
+            migration_code: rec[:migration_code],
+            table: rec[:table],
+            columns: rec[:columns],
+            category: "database_optimization"
+          }
+        end
+      end
+
+      def generate_n_plus_one_suggestions
+        n_plus_one = analysis_results[:n_plus_one_analysis] || {}
+        return [] unless n_plus_one[:is_likely_n_plus_one]
+
+        suggestions = n_plus_one[:suggested_fixes] || []
+
+        suggestions.map do |fix|
+          {
+            type: "n_plus_one",
+            action: fix[:description],
+            benefit: "Eliminate N+1 queries and reduce database load",
+            priority: "high",
+            code_example: fix[:code_example],
+            confidence: n_plus_one[:confidence_score],
+            category: "performance_critical"
+          }
+        end
+      end
+
+      def generate_query_characteristic_suggestions
+        stats = analysis_results[:query_characteristics] || {}
+        suggestions = []
+
+        if stats[:join_count] && stats[:join_count] > 3
+          suggestions << {
+            type: "optimization",
+            action: "Review if all #{stats[:join_count]} JOINs are necessary",
+            benefit: "Simplified query execution and better performance",
+            priority: "medium",
+            category: "sql_optimization"
+          }
+        end
+
+        if stats[:estimated_complexity] && stats[:estimated_complexity] > 10
+          suggestions << {
+            type: "refactoring",
+            action: "Consider breaking complex query (complexity: #{stats[:estimated_complexity]}) into smaller parts",
+            benefit: "Easier maintenance and potentially better performance",
+            priority: "medium",
+            category: "code_quality"
+          }
+        end
+
+        if stats[:has_subqueries] && stats[:join_count] && stats[:join_count] > 1
+          suggestions << {
+            type: "optimization",
+            action: "Consider converting subqueries to JOINs for better performance",
+            benefit: "More efficient query execution in most databases",
+            priority: "medium",
+            category: "sql_optimization"
+          }
+        end
+
+        suggestions
+      end
+
+      def generate_explain_plan_suggestions
+        explain_issues = analysis_results.dig(:explain_plan, :issues) || []
+
+        explain_issues.map do |issue|
+          case issue[:type]
+          when "sequential_scan"
+            {
+              type: "index",
+              action: "Consider adding database indexes for WHERE clause columns",
+              benefit: "Dramatically faster query execution",
+              priority: "high",
+              category: "database_optimization"
+            }
+          when "temporary_table"
+            {
+              type: "optimization",
+              action: "Optimize query to avoid temporary tables and filesort operations",
+              benefit: "Reduced memory usage and faster execution",
+              priority: "medium",
+              category: "sql_optimization"
+            }
+          when "high_cost_operation"
+            {
+              type: "optimization",
+              action: "Review query execution plan for high-cost operations",
+              benefit: "Identify specific bottlenecks for targeted optimization",
+              priority: "high",
+              category: "performance_critical"
+            }
+          when "where_without_index"
+            {
+              type: "index",
+              action: "Add indexes to support WHERE clause conditions",
+              benefit: "Eliminate row-by-row filtering during query execution",
+              priority: "high",
+              category: "database_optimization"
+            }
+          end
+        end.compact
+      end
+
+      def prioritize_suggestions(suggestions)
+        # Remove duplicates based on action
+        unique_suggestions = suggestions.uniq { |s| s[:action] }
+
+        # Sort by priority and category
+        unique_suggestions.sort_by do |suggestion|
+          priority_score = case suggestion[:priority]
+          when "high" then 3
+          when "medium" then 2
+          when "low" then 1
+          else 0
+          end
+
+          category_score = case suggestion[:category]
+          when "performance_critical" then 4
+          when "database_optimization" then 3
+          when "sql_optimization" then 2
+          when "code_quality" then 1
+          else 0
+          end
+
+          [ -priority_score, -category_score, suggestion[:action] ]
+        end
+      end
+    end
+  end
+end

data/app/services/rails_pulse/query_analysis_service.rb

@@ -0,0 +1,125 @@
+# Orchestrates comprehensive query analysis using modular analyzers.
+# Coordinates multiple specialized analyzers and consolidates results into actionable insights.
+module RailsPulse
+  class QueryAnalysisService
+    def self.analyze_query(query_id)
+      query = RailsPulse::Query.find(query_id)
+      new(query).analyze
+    end
+
+    def initialize(query)
+      @query = query
+      @operations = fetch_recent_operations
+    end
+
+    def analyze
+      # Run all analyzers
+      results = {
+        analyzed_at: Time.current,
+        query_characteristics: analyze_query_characteristics,
+        index_recommendations: analyze_index_recommendations,
+        n_plus_one_analysis: analyze_n_plus_one,
+        explain_plan: analyze_explain_plan,
+        backtrace_analysis: analyze_backtraces
+      }
+
+      # Generate consolidated suggestions
+      results[:suggestions] = generate_suggestions(results)
+
+      # Build compatible format for query model
+      compatible_results = build_compatible_results(results)
+
+      # Save results to query
+      save_results_to_query(compatible_results)
+
+      results
+    end
+
+    private
+
+    def fetch_recent_operations
+      @query.operations
+            .where("occurred_at > ?", 48.hours.ago)
+            .order(occurred_at: :desc)
+            .limit(50)
+    end
+
+    def analyze_query_characteristics
+      Analysis::QueryCharacteristicsAnalyzer.new(@query, @operations).analyze
+    end
+
+    def analyze_index_recommendations
+      Analysis::IndexRecommendationEngine.new(@query, @operations).analyze
+    end
+
+    def analyze_n_plus_one
+      Analysis::NPlusOneDetector.new(@query, @operations).analyze
+    end
+
+    def analyze_explain_plan
+      return { explain_plan: nil, issues: [] } if @operations.empty?
+      Analysis::ExplainPlanAnalyzer.new(@query, @operations).analyze
+    end
+
+    def analyze_backtraces
+      return {} if @operations.empty?
+      Analysis::BacktraceAnalyzer.new(@query, @operations).analyze
+    end
+
+    def generate_suggestions(analysis_results)
+      Analysis::SuggestionGenerator.new(analysis_results).generate
+    end
+
+    # Build compatible format for query model storage
+    def build_compatible_results(results)
+      characteristics = results[:query_characteristics]
+      explain_result = results[:explain_plan]
+
+      {
+        analyzed_at: results[:analyzed_at],
+        explain_plan: explain_result[:explain_plan],
+        issues: extract_all_issues(characteristics, explain_result),
+        metadata: build_metadata(results),
+        query_stats: extract_query_stats(characteristics),
+        backtrace_analysis: results[:backtrace_analysis],
+        index_recommendations: results[:index_recommendations],
+        n_plus_one_analysis: results[:n_plus_one_analysis],
+        suggestions: results[:suggestions]
+      }
+    end
+
+    def extract_all_issues(characteristics, explain_result)
+      issues = []
+      issues.concat(characteristics[:pattern_issues] || [])
+      issues.concat(explain_result[:issues] || [])
+      issues
+    end
+
+    def extract_query_stats(characteristics)
+      characteristics.except(:pattern_issues)
+    end
+
+    def build_metadata(results)
+      {
+        analyzers_used: results.keys.reject { |k| k.in?([ :analyzed_at, :suggestions ]) },
+        analysis_version: "2.0",
+        total_recommendations: results[:index_recommendations]&.count || 0,
+        n_plus_one_detected: results.dig(:n_plus_one_analysis, :is_likely_n_plus_one) || false
+      }
+    end
+
+    def save_results_to_query(results)
+      @query.update!(
+        analyzed_at: results[:analyzed_at],
+        explain_plan: results[:explain_plan],
+        issues: results[:issues],
+        metadata: results[:metadata],
+        query_stats: results[:query_stats],
+        backtrace_analysis: results[:backtrace_analysis],
+        index_recommendations: results[:index_recommendations],
+        n_plus_one_analysis: results[:n_plus_one_analysis],
+        suggestions: results[:suggestions]
+      )
+    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

data/app/views/layouts/rails_pulse/_sidebar_menu.html.erb

@@ -5,7 +5,6 @@
     </div>
     <div class="flex flex-col text-start leading-tight overflow-hidden">
       <span class="overflow-ellipsis font-semibold">Rails Pulse</span>
-      <span class="overflow-ellipsis text-xs">Open Source</span>
     </div>
   </a>
 

data/app/views/layouts/rails_pulse/application.html.erb

@@ -22,18 +22,16 @@
         <div class="hide@md" data-controller="rails-pulse--dialog">
           <button type="button" class="btn btn--icon" data-action="rails-pulse--dialog#showModal">
             <%= rails_pulse_icon 'menu', width: '20' %>
-            <span class="sr-only">Open menu</span>
           </button>
 
         <dialog class="sheet sheet--left" style="--sheet-size: 288px;" data-rails-pulse--dialog-target="menu" data-action="click->rails-pulse--dialog#closeOnClickOutside">
           <div class="sheet__content p-2">
             <div class="sidebar-menu">
-              <a class="btn sidebar-menu__button" href="#">
+              <%= link_to rails_pulse.root_path, class: "btn sidebar-menu__button" do %>
                 <div class="flex flex-col text-start leading-tight overflow-hidden">
                   <span class="overflow-ellipsis font-semibold">Rails Pulse</span>
-                  <span class="overflow-ellipsis text-xs">Open Source</span>
                 </div>
-              </a>
+              <% end %>
               <div class="sidebar-menu__content">
                 <div class="sidebar-menu__group">
                   <nav class="sidebar-menu__items">
@@ -47,9 +45,9 @@
       </div>
 
       <div class="flex items-center gap">
-        <a class="flex items-center gap mie-2" href="#">
+        <%= link_to rails_pulse.root_path, class: "flex items-center gap mie-2" do %>
           <span class="font-bold">Rails Pulse</span>
-        </a>
+        <% end %>
         <nav class="flex items-center gap text-sm text-subtle show@md" style="--column-gap: 1rem">
           <%= render 'layouts/rails_pulse/menu_items' %>
         </nav>

data/app/views/rails_pulse/components/_breadcrumbs.html.erb

@@ -1,4 +1,4 @@
-<nav class="breadcrumb" aria-label="Breadcrumb">
+<nav class="breadcrumb mis-2" aria-label="Breadcrumb">
   <% breadcrumbs.each_with_index do |crumb, index| %>
     <% if crumb[:current] %>
       <span class="text-primary" aria-disabled="true" aria-current="page" role="link"><%= crumb[:title] %></span>

data/app/views/rails_pulse/components/_code_panel.html.erb

@@ -2,11 +2,25 @@
   title ||= nil
 %>
 
-<div>
+<div
+  data-controller="rails-pulse--collapsible"
+  data-rails-pulse--collapsible-collapsed-class="collapsed"
+  class="collapsible-code"
+>
   <% if title %>
-    <h2 class="grow font-semibold leading-none mbe-1 uppercase text-xs"><%= title %></h2>
+    <h2 class="grow font-semibold leading-none mbe-1 uppercase text-xs">
+      <%= title %>
+      <button
+        type="button"
+        class="collapsible-toggle"
+        data-rails-pulse--collapsible-target="toggle"
+        data-action="click->rails-pulse--collapsible#toggle"
+      >
+        show more
+      </button>
+    </h2>
   <% end %>
-  <div class="prose max-i-none">
+  <div class="prose max-i-none" data-rails-pulse--collapsible-target="content">
     <pre class="mbs-0" style="white-space: normal; margin-block-end: 0; margin-block-start: 0;"><code><%= html_escape(value) %></code></pre>
   </div>
 </div>

data/app/views/rails_pulse/components/_empty_state.html.erb

@@ -0,0 +1,11 @@
+<div class="flex items-center justify-center pbs-12 pbe-12 pis-6 pie-6 mb-8">
+  <div class="flex items-center gap">
+    <div class="shrink-0">
+      <img src="<%= asset_path('search.svg') %>" class="w-48 h-48" alt="No data available" />
+    </div>
+    <div class="text-subtle pis-8">
+      <p class="text-lg font-semibold mbe-2"><%= title %></p>
+      <p class="text-sm"><%= description %></p>
+    </div>
+  </div>
+</div>