rails_pulse 0.1.2 → 0.1.4

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

@@ -0,0 +1,241 @@
+# Detects N+1 query patterns by analyzing query repetition within request cycles.
+# Groups operations by time windows and identifies repetitive single-record lookups that suggest missing eager loading.
+module RailsPulse
+  module Analysis
+    class NPlusOneDetector < BaseAnalyzer
+      REQUEST_GROUPING_WINDOW = 0.1.seconds
+      REPETITION_THRESHOLD = 3
+
+      def analyze
+        return default_result if operations.empty?
+
+        analysis = {
+          is_likely_n_plus_one: false,
+          confidence_score: 0,
+          evidence: [],
+          suggested_fixes: [],
+          execution_patterns: {}
+        }
+
+        # Group operations by request cycles
+        request_groups = group_operations_by_request
+
+        # Analyze patterns within each request
+        request_groups.each do |group|
+          pattern_analysis = analyze_request_pattern(group)
+
+          if pattern_analysis[:repetitive_queries]
+            analysis[:is_likely_n_plus_one] = true
+            analysis[:confidence_score] += pattern_analysis[:confidence]
+            analysis[:evidence].concat(pattern_analysis[:evidence])
+            analysis[:suggested_fixes].concat(pattern_analysis[:fixes])
+          end
+        end
+
+        # Normalize confidence score
+        analysis[:confidence_score] = [ analysis[:confidence_score], 100 ].min
+
+        # Add execution pattern analysis
+        analysis[:execution_patterns] = analyze_execution_patterns
+
+        # Generate ActiveRecord-specific suggestions
+        if analysis[:is_likely_n_plus_one]
+          analysis[:suggested_fixes].concat(generate_activerecord_fixes)
+        end
+
+        analysis
+      end
+
+      private
+
+      def default_result
+        {
+          is_likely_n_plus_one: false,
+          confidence_score: 0,
+          evidence: [],
+          suggested_fixes: [],
+          execution_patterns: {}
+        }
+      end
+
+      def group_operations_by_request
+        groups = []
+        current_group = []
+
+        sorted_operations = operations.sort_by(&:occurred_at)
+
+        sorted_operations.each do |operation|
+          if current_group.empty? || time_within_window?(operation, current_group.last)
+            current_group << operation
+          else
+            groups << current_group if current_group.size > 1
+            current_group = [ operation ]
+          end
+        end
+
+        groups << current_group if current_group.size > 1
+        groups
+      end
+
+      def time_within_window?(operation, last_operation)
+        (operation.occurred_at - last_operation.occurred_at) < REQUEST_GROUPING_WINDOW
+      end
+
+      def analyze_request_pattern(operations_group)
+        analysis = {
+          repetitive_queries: false,
+          confidence: 0,
+          evidence: [],
+          fixes: []
+        }
+
+        # Look for repeated similar queries
+        normalized_queries = operations_group.map { |op| normalize_sql_for_pattern_detection(op.label) }
+        query_counts = normalized_queries.tally
+
+        query_counts.each do |normalized_query, count|
+          next unless count >= REPETITION_THRESHOLD
+
+          analysis[:repetitive_queries] = true
+          analysis[:confidence] += count * 10 # Higher repetition = higher confidence
+
+          analysis[:evidence] << {
+            type: "repetitive_query",
+            description: "Query executed #{count} times in single request",
+            query_pattern: normalized_query,
+            occurrences: count
+          }
+
+          # Detect specific N+1 patterns
+          if single_record_lookup_pattern?(normalized_query)
+            analysis[:evidence] << {
+              type: "single_record_lookup",
+              description: "Single record lookup pattern suggests missing eager loading",
+              query_pattern: normalized_query
+            }
+
+            analysis[:fixes] << {
+              type: "eager_loading",
+              description: "Use includes() or preload() to load associated records",
+              code_example: detect_association_from_query(normalized_query)
+            }
+          end
+        end
+
+        analysis
+      end
+
+      def single_record_lookup_pattern?(normalized_query)
+        normalized_query.match?(/SELECT.*FROM.*WHERE.*=\s*\?/i)
+      end
+
+      def analyze_execution_patterns
+        return {} if operations.empty?
+
+        {
+          total_executions: operations.count,
+          time_span_minutes: time_span_in_minutes,
+          executions_per_minute: calculate_executions_per_minute,
+          peak_execution_periods: find_peak_execution_periods,
+          common_execution_contexts: extract_execution_contexts
+        }
+      end
+
+      def time_span_in_minutes
+        return 0 if operations.count < 2
+        ((operations.last.occurred_at - operations.first.occurred_at) / 1.minute).round(2)
+      end
+
+      def calculate_executions_per_minute
+        return 0 if operations.count < 2
+
+        time_span = operations.last.occurred_at - operations.first.occurred_at
+        return operations.count if time_span <= 0
+
+        (operations.count / (time_span / 1.minute)).round(2)
+      end
+
+      def find_peak_execution_periods
+        # Group by 5-minute windows and find peaks
+        windows = operations.group_by { |op| (op.occurred_at.to_i / 300) * 300 }
+        return [] if windows.empty?
+
+        avg_per_window = windows.values.sum(&:count).to_f / windows.count
+
+        windows.select { |_, ops| ops.count > avg_per_window * 1.5 }.map do |timestamp, ops|
+          {
+            period: Time.at(timestamp).strftime("%Y-%m-%d %H:%M"),
+            executions: ops.count,
+            above_average_by: ((ops.count - avg_per_window) / avg_per_window * 100).round(1)
+          }
+        end
+      end
+
+      def extract_execution_contexts
+        contexts = operations.filter_map(&:codebase_location).compact
+        return {} if contexts.empty?
+
+        # Extract controller/model patterns
+        controller_actions = extract_controller_actions(contexts)
+        model_methods = extract_model_methods(contexts)
+
+        {
+          controller_actions: controller_actions.tally,
+          model_methods: model_methods.tally,
+          unique_locations: contexts.uniq.count,
+          total_contexts: contexts.count
+        }
+      end
+
+      def extract_controller_actions(contexts)
+        contexts.filter_map do |context|
+          match = context.match(%r{app/controllers/(.+?)#(.+)})
+          "#{match[1]}##{match[2]}" if match
+        end
+      end
+
+      def extract_model_methods(contexts)
+        contexts.filter_map do |context|
+          match = context.match(%r{app/models/(.+?)\.rb.*in `(.+?)'})
+          "#{match[1]}.#{match[2]}" if match
+        end
+      end
+
+      def generate_activerecord_fixes
+        [
+          {
+            type: "includes",
+            description: "Use includes() to eager load associations",
+            code_example: "User.includes(:posts).where(active: true)"
+          },
+          {
+            type: "preload",
+            description: "Use preload() when you don't need to query on associations",
+            code_example: "User.preload(:posts).limit(10)"
+          },
+          {
+            type: "joins",
+            description: "Use joins() when you only need to filter, not access associated data",
+            code_example: "User.joins(:posts).where(posts: { published: true })"
+          }
+        ]
+      end
+
+      def detect_association_from_query(normalized_query)
+        # Try to extract table/column info to suggest specific associations
+        match = normalized_query.match(/from\s+(\w+).*where\s+(\w+)\s*=/)
+        return "Model.includes(:association)" unless match
+
+        table = match[1]
+        column = match[2]
+
+        if column.end_with?("_id")
+          association = column.gsub("_id", "")
+          return "#{table.classify}.includes(:#{association})"
+        end
+
+        "Model.includes(:association)"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+# Analyzes SQL query structure and complexity.
+# Detects query type, table joins, WHERE complexity, and common anti-patterns like SELECT * or missing LIMIT.
+module RailsPulse
+  module Analysis
+    class QueryCharacteristicsAnalyzer < BaseAnalyzer
+      def analyze
+        {
+          query_type: detect_query_type,
+          table_count: count_tables,
+          join_count: count_joins,
+          where_clause_complexity: analyze_where_complexity,
+          has_subqueries: has_subqueries?,
+          has_limit: has_limit?,
+          has_order_by: has_order_by?,
+          has_group_by: has_group_by?,
+          has_having: has_having?,
+          has_distinct: has_distinct?,
+          has_aggregations: has_aggregations?,
+          estimated_complexity: calculate_complexity_score,
+          pattern_issues: detect_pattern_issues
+        }
+      end
+
+      private
+
+      def detect_query_type
+        case sql.strip.upcase
+        when /^SELECT/ then "SELECT"
+        when /^INSERT/ then "INSERT"
+        when /^UPDATE/ then "UPDATE"
+        when /^DELETE/ then "DELETE"
+        when /^CREATE/ then "CREATE"
+        when /^DROP/ then "DROP"
+        when /^ALTER/ then "ALTER"
+        else "UNKNOWN"
+        end
+      end
+
+      def count_tables
+        tables = []
+
+        # Match FROM clause with various table name formats
+        # Handles: table_name, schema.table, "quoted_table", `backtick_table`
+        tables.concat(sql.scan(/FROM\s+(?:`([^`]+)`|"([^"]+)"|'([^']+)'|(\w+(?:\.\w+)?))/i).flatten.compact)
+
+        # Match JOIN clauses (INNER JOIN, LEFT JOIN, etc.)
+        tables.concat(sql.scan(/(?:INNER\s+|LEFT\s+|RIGHT\s+|FULL\s+|CROSS\s+)?JOIN\s+(?:`([^`]+)`|"([^"]+)"|'([^']+)'|(\w+(?:\.\w+)?))/i).flatten.compact)
+
+        # Remove schema prefixes for uniqueness check (schema.table -> table)
+        normalized_tables = tables.map { |table| table.split(".").last }
+        normalized_tables.uniq.length
+      end
+
+      def count_joins
+        sql.scan(/\bJOIN\b/i).length
+      end
+
+      def analyze_where_complexity
+        where_clause = extract_where_clause
+        return 0 unless where_clause
+
+        condition_count = where_clause.scan(/\bAND\b|\bOR\b/i).length + 1
+        function_count = where_clause.scan(/\w+\s*\(/).length
+
+        condition_count + (function_count * 2)
+      end
+
+      def has_subqueries?
+        sql.include?("(SELECT")
+      end
+
+      def has_limit?
+        sql.match?(/\bLIMIT\s+\d+/i)
+      end
+
+      def has_order_by?
+        sql.include?("ORDER BY")
+      end
+
+      def has_group_by?
+        sql.include?("GROUP BY")
+      end
+
+      def has_having?
+        sql.include?("HAVING")
+      end
+
+      def has_distinct?
+        sql.include?("DISTINCT")
+      end
+
+      def has_aggregations?
+        sql.match?(/\b(COUNT|SUM|AVG|MIN|MAX|GROUP_CONCAT)\s*\(/i)
+      end
+
+      def calculate_complexity_score
+        score = 0
+        score += count_tables * 2
+        score += count_joins * 3
+        score += analyze_where_complexity
+        score += sql.scan(/\bUNION\b/i).length * 4
+        score += sql.scan(/\(SELECT/i).length * 5
+        score
+      end
+
+      def detect_pattern_issues
+        issues = []
+
+        # Missing WHERE clause on SELECT
+        if sql.match?(/^SELECT.*FROM.*(?!WHERE)/i) && !has_limit?
+          issues << {
+            type: "missing_where_clause",
+            severity: "warning",
+            description: "SELECT query without WHERE clause may return excessive data",
+            impact: "Performance degradation from full table scans"
+          }
+        end
+
+        # SELECT * usage
+        if sql.include?("SELECT *")
+          issues << {
+            type: "select_star",
+            severity: "info",
+            description: "Using SELECT * may retrieve unnecessary columns",
+            impact: "Increased memory usage and network transfer"
+          }
+        end
+
+        # Missing LIMIT on potentially large results
+        if sql.match?(/^SELECT.*FROM.*WHERE/i) && !has_limit? && !sql.include?("COUNT")
+          issues << {
+            type: "missing_limit",
+            severity: "warning",
+            description: "Query may return large result sets without LIMIT",
+            impact: "Memory exhaustion and slow response times"
+          }
+        end
+
+        # Complex WHERE clauses
+        where_clause = extract_where_clause
+        if where_clause && where_clause.scan(/\bAND\b|\bOR\b/i).length > 5
+          issues << {
+            type: "complex_where_clause",
+            severity: "warning",
+            description: "Complex WHERE clause with many conditions",
+            impact: "Difficult to optimize and maintain"
+          }
+        end
+
+        issues
+      end
+    end
+  end
+end

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