rails_pulse 0.1.2 → 0.1.3

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

@@ -0,0 +1,326 @@
+# Recommends database indexes to improve query performance.
+# Analyzes WHERE clauses, JOINs, ORDER BY, and identifies opportunities for single-column, composite, and covering indexes.
+module RailsPulse
+  module Analysis
+    class IndexRecommendationEngine < BaseAnalyzer
+      def analyze
+        return [] unless sql.present?
+
+        recommendations = []
+
+        # Analyze WHERE clause for single column indexes
+        recommendations.concat(analyze_where_clause_indexes)
+
+        # Analyze JOIN conditions for indexes
+        recommendations.concat(analyze_join_indexes)
+
+        # Analyze ORDER BY clauses for indexes
+        recommendations.concat(analyze_order_by_indexes)
+
+        # Analyze composite index opportunities
+        recommendations.concat(analyze_composite_index_opportunities)
+
+        # Check for covering index opportunities
+        recommendations.concat(analyze_covering_index_opportunities)
+
+        # Prioritize recommendations based on query frequency and complexity
+        prioritize_recommendations(recommendations)
+      end
+
+      private
+
+      def analyze_where_clause_indexes
+        recommendations = []
+        table_name = extract_main_table
+        return recommendations unless table_name
+
+        where_clause = extract_where_clause
+        return recommendations unless where_clause
+
+        # Find equality conditions (best for indexes)
+        equality_conditions = where_clause.scan(/(\w+)\s*=\s*[?'"\d]/)
+        equality_conditions.each do |column_match|
+          column = column_match[0]
+          next if reserved_word?(column)
+
+          recommendations << build_index_recommendation(
+            table_name, [ column ], "single_column", "high",
+            "Equality condition in WHERE clause",
+            "Fast lookups for #{column} = value queries"
+          )
+        end
+
+        # Find range conditions
+        range_conditions = where_clause.scan(/(\w+)\s*(?:>|<|>=|<=|BETWEEN)/i)
+        range_conditions.each do |column_match|
+          column = column_match[0]
+          next if reserved_word?(column)
+
+          recommendations << build_index_recommendation(
+            table_name, [ column ], "single_column", "medium",
+            "Range condition in WHERE clause",
+            "Efficient range scans for #{column}"
+          )
+        end
+
+        # Find LIKE patterns that could benefit from indexes
+        analyze_like_conditions(table_name, where_clause, recommendations)
+
+        recommendations
+      end
+
+      def analyze_like_conditions(table_name, where_clause, recommendations)
+        like_conditions = where_clause.scan(/(\w+)\s*LIKE\s*'([^']+)'/i)
+        like_conditions.each do |column, pattern|
+          next if reserved_word?(column)
+
+          if pattern.start_with?("%")
+            # Leading wildcard - suggest full-text search instead
+            recommendations << build_fulltext_recommendation(table_name, column)
+          else
+            # Prefix match can use regular index
+            recommendations << build_index_recommendation(
+              table_name, [ column ], "single_column", "medium",
+              "LIKE with prefix pattern",
+              "Prefix matching for #{column}"
+            )
+          end
+        end
+      end
+
+      def analyze_join_indexes
+        recommendations = []
+
+        # Extract JOIN conditions
+        join_matches = sql.scan(/JOIN\s+(\w+)\s+.*?ON\s+(\w+)\.(\w+)\s*=\s*(\w+)\.(\w+)/i)
+
+        join_matches.each do |join_table, table1, col1, table2, col2|
+          # Recommend indexes on join columns
+          recommendations << build_index_recommendation(
+            join_table, [ col2 ], "single_column", "high",
+            "JOIN condition", "Fast JOIN execution"
+          )
+
+          # Also check the other side of the join if it's not the main table
+          main_table = extract_main_table
+          if table1 != main_table
+            recommendations << build_index_recommendation(
+              table1, [ col1 ], "single_column", "high",
+              "JOIN condition", "Fast JOIN execution"
+            )
+          end
+        end
+
+        recommendations
+      end
+
+      def analyze_order_by_indexes
+        recommendations = []
+        table_name = extract_main_table
+        return recommendations unless table_name
+
+        order_columns = extract_order_columns
+        return recommendations if order_columns.empty?
+
+        if order_columns.length == 1
+          column = order_columns.first
+          recommendations << build_index_recommendation(
+            table_name, [ column ], "single_column", "medium",
+            "ORDER BY clause", "Avoid sorting for ORDER BY #{column}"
+          )
+        elsif order_columns.length > 1
+          recommendations << build_index_recommendation(
+            table_name, order_columns, "composite", "medium",
+            "Multi-column ORDER BY", "Avoid sorting for complex ORDER BY"
+          )
+        end
+
+        recommendations
+      end
+
+      def analyze_composite_index_opportunities
+        recommendations = []
+        table_name = extract_main_table
+        return recommendations unless table_name
+
+        where_columns = extract_where_columns
+        order_columns = extract_order_columns
+
+        # Look for WHERE + ORDER BY combinations
+        if where_columns.any? && order_columns.any?
+          composite_columns = where_columns + order_columns
+
+          recommendations << build_index_recommendation(
+            table_name, composite_columns, "composite", "high",
+            "WHERE + ORDER BY optimization",
+            "Single index for filtering and sorting"
+          )
+        end
+
+        # Look for multiple WHERE conditions
+        if where_columns.length > 1
+          recommendations << build_index_recommendation(
+            table_name, where_columns, "composite", "high",
+            "Multiple WHERE conditions",
+            "Efficient multi-column filtering"
+          )
+        end
+
+        recommendations
+      end
+
+      def analyze_covering_index_opportunities
+        recommendations = []
+        table_name = extract_main_table
+        return recommendations unless table_name
+
+        # Extract selected columns
+        select_match = sql.match(/SELECT\s+(.+?)\s+FROM/i)
+        return recommendations if !select_match || select_match[1].include?("*")
+
+        selected_columns = select_match[1].split(",").map(&:strip)
+        where_columns = extract_where_columns
+
+        if where_columns.any? && selected_columns.length <= 5
+          covering_columns = (where_columns + selected_columns).uniq
+
+          recommendations << {
+            type: "covering",
+            table: table_name,
+            columns: covering_columns,
+            reason: "Covering index opportunity",
+            priority: "medium",
+            migration_code: generate_covering_migration_code(table_name, where_columns, selected_columns),
+            estimated_benefit: "Index-only scan without table access",
+            priority_score: 60,
+            execution_context: execution_context
+          }
+        end
+
+        recommendations
+      end
+
+      def extract_where_columns
+        where_clause = extract_where_clause
+        return [] unless where_clause
+
+        columns = []
+
+        # Extract columns from equality conditions
+        columns.concat(where_clause.scan(/(\w+)\s*=/).flatten)
+        # Extract columns from range conditions
+        columns.concat(where_clause.scan(/(\w+)\s*(?:>|<|>=|<=|BETWEEN)/).flatten)
+        # Extract columns from LIKE conditions
+        columns.concat(where_clause.scan(/(\w+)\s*LIKE/).flatten)
+
+        columns.reject { |col| reserved_word?(col) }.uniq
+      end
+
+      def extract_order_columns
+        order_match = sql.match(/ORDER\s+BY\s+(.+?)(?:\s+LIMIT|\s*$)/i)
+        return [] unless order_match
+
+        order_clause = order_match[1]
+        order_clause.split(",").map do |col|
+          col.strip.gsub(/\s+(ASC|DESC)\s*$/i, "").strip
+        end
+      end
+
+      def build_index_recommendation(table, columns, type, priority, reason, benefit)
+        {
+          type: type,
+          table: table,
+          columns: Array(columns),
+          reason: reason,
+          priority: priority,
+          migration_code: generate_migration_code(table, columns),
+          estimated_benefit: benefit,
+          priority_score: calculate_priority_score(priority),
+          execution_context: execution_context
+        }
+      end
+
+      def build_fulltext_recommendation(table, column)
+        {
+          type: "full_text",
+          table: table,
+          columns: [ column ],
+          reason: "LIKE with leading wildcard",
+          priority: "low",
+          migration_code: generate_fulltext_migration_code(table, [ column ]),
+          estimated_benefit: "Full-text search instead of slow LIKE queries",
+          priority_score: 30,
+          execution_context: execution_context
+        }
+      end
+
+      def prioritize_recommendations(recommendations)
+        execution_frequency = operations.count
+
+        recommendations.each do |rec|
+          # Boost score based on execution frequency
+          frequency_boost = [ execution_frequency * 2, 50 ].min
+          rec[:priority_score] += frequency_boost
+        end
+
+        # Remove duplicates and sort by priority
+        unique_recommendations = recommendations.uniq { |r| [ r[:table], r[:columns].sort ] }
+        unique_recommendations.sort_by { |r| -r[:priority_score] }
+      end
+
+      def calculate_priority_score(priority)
+        case priority
+        when "high" then 100
+        when "medium" then 60
+        when "low" then 30
+        else 50
+        end
+      end
+
+      def execution_context
+        @execution_context ||= {
+          frequency: operations.count,
+          frequency_description: describe_frequency(operations.count)
+        }
+      end
+
+      def generate_migration_code(table_name, columns)
+        columns = Array(columns)
+        if columns.length == 1
+          "add_index :#{table_name}, :#{columns.first}"
+        else
+          "add_index :#{table_name}, #{columns.inspect}"
+        end
+      end
+
+      def generate_covering_migration_code(table_name, where_columns, select_columns)
+        all_columns = (where_columns + select_columns).uniq
+        "add_index :#{table_name}, #{all_columns.inspect}, name: 'covering_idx_#{table_name}_#{where_columns.join('_')}'"
+      end
+
+      def generate_fulltext_migration_code(table_name, columns)
+        case database_adapter
+        when "postgresql"
+          "add_index :#{table_name}, :#{columns.first}, using: 'gin', opclass: 'gin_trgm_ops'"
+        when "mysql", "mysql2"
+          "add_index :#{table_name}, :#{columns.first}, type: 'fulltext'"
+        else
+          "# Full-text search not supported for #{database_adapter}"
+        end
+      end
+
+      def describe_frequency(count)
+        case count
+        when 0..10 then "Low frequency"
+        when 11..50 then "Medium frequency"
+        when 51..100 then "High frequency"
+        else "Very high frequency"
+        end
+      end
+
+      def reserved_word?(word)
+        word.upcase.in?([ "AND", "OR", "NOT", "NULL", "TRUE", "FALSE" ])
+      end
+    end
+  end
+end

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,146 @@
+# 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 = []
+        tables.concat(sql.scan(/FROM\s+(\w+)/i).flatten)
+        tables.concat(sql.scan(/JOIN\s+(\w+)/i).flatten)
+        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