rails_pulse 0.1.2 → 0.1.4

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

@@ -0,0 +1,67 @@
+# Base class providing common utilities for all query analyzers.
+# Handles database adapter detection, SQL parsing, and normalization.
+module RailsPulse
+  module Analysis
+    class BaseAnalyzer
+      attr_reader :query, :operations
+
+      def initialize(query, operations = [])
+        @query = query
+        @operations = Array(operations)
+      end
+
+      # Each analyzer must implement this method
+      def analyze
+        raise NotImplementedError, "#{self.class} must implement #analyze"
+      end
+
+      protected
+
+      def sql
+        @sql ||= query.normalized_sql
+      end
+
+      def recent_operations
+        @recent_operations ||= operations.select { |op| op.occurred_at > 48.hours.ago }
+      end
+
+      # Utility method for database adapter detection
+      def database_adapter
+        @database_adapter ||= RailsPulse::ApplicationRecord.connection.adapter_name.downcase
+      end
+
+      def postgresql?
+        database_adapter == "postgresql"
+      end
+
+      def mysql?
+        database_adapter.in?([ "mysql", "mysql2" ])
+      end
+
+      def sqlite?
+        database_adapter == "sqlite"
+      end
+
+      # Common SQL parsing utilities
+      def extract_main_table(sql_string = sql)
+        match = sql_string.match(/FROM\s+(\w+)/i)
+        match ? match[1] : nil
+      end
+
+      def extract_where_clause(sql_string = sql)
+        match = sql_string.match(/WHERE\s+(.+?)(?:\s+ORDER\s+BY|\s+GROUP\s+BY|\s+LIMIT|\s*$)/i)
+        match ? match[1] : nil
+      end
+
+      def normalize_sql_for_pattern_detection(sql_string)
+        return "" unless sql_string.present?
+
+        sql_string.gsub(/\d+/, "?")              # Replace numbers with placeholders
+                  .gsub(/'[^']*'/, "?")          # Replace strings with placeholders
+                  .gsub(/\s+/, " ")              # Normalize whitespace
+                  .strip
+                  .downcase
+      end
+    end
+  end
+end

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

@@ -0,0 +1,206 @@
+# Executes database EXPLAIN commands and analyzes query execution plans.
+# Detects sequential scans, temporary tables, high-cost operations, and database-specific performance issues.
+module RailsPulse
+  module Analysis
+    class ExplainPlanAnalyzer < BaseAnalyzer
+      EXPLAIN_TIMEOUT = 5.seconds
+
+      def analyze
+        return { explain_plan: nil, issues: [] } if recent_operations.empty?
+
+        actual_sql = recent_operations.first.label
+        explain_plan = generate_explain_plan(actual_sql)
+
+        {
+          explain_plan: explain_plan,
+          issues: detect_explain_issues(explain_plan)
+        }
+      end
+
+      private
+
+      def generate_explain_plan(sql)
+        return nil unless sql.present?
+
+        # Skip EXPLAIN queries in test environment to avoid transaction issues
+        return nil if Rails.env.test?
+
+        begin
+          sanitized_sql = sanitize_sql_for_explain(sql)
+
+          Timeout.timeout(EXPLAIN_TIMEOUT) do
+            case database_adapter
+            when "postgresql"
+              execute_postgres_explain(sanitized_sql)
+            when "mysql", "mysql2"
+              execute_mysql_explain(sanitized_sql)
+            when "sqlite"
+              execute_sqlite_explain(sanitized_sql)
+            else
+              nil
+            end
+          end
+        rescue => e
+          Rails.logger.warn("[ExplainPlanAnalyzer] EXPLAIN failed for query #{query.id}: #{e.message}")
+          nil
+        end
+      end
+
+      def detect_explain_issues(explain_plan)
+        return [] unless explain_plan.present?
+
+        issues = []
+
+        # Look for common issues in EXPLAIN output
+        if sequential_scan?(explain_plan)
+          issues << {
+            type: "sequential_scan",
+            severity: "warning",
+            description: "Query performs sequential/table scan",
+            impact: "Poor performance on large tables"
+          }
+        end
+
+        if temporary_operations?(explain_plan)
+          issues << {
+            type: "temporary_table",
+            severity: "warning",
+            description: "Query uses temporary tables or filesort",
+            impact: "Increased memory usage and processing time"
+          }
+        end
+
+        # Database-specific analysis
+        case database_adapter
+        when "postgresql"
+          issues.concat(analyze_postgres_specific_issues(explain_plan))
+        when "mysql", "mysql2"
+          issues.concat(analyze_mysql_specific_issues(explain_plan))
+        when "sqlite"
+          issues.concat(analyze_sqlite_specific_issues(explain_plan))
+        end
+
+        issues
+      end
+
+      def sequential_scan?(explain_plan)
+        explain_plan.downcase.include?("seq scan") ||
+        explain_plan.downcase.include?("table scan") ||
+        explain_plan.downcase.include?("full table scan")
+      end
+
+      def temporary_operations?(explain_plan)
+        explain_plan.downcase.include?("temporary") ||
+        explain_plan.downcase.include?("filesort") ||
+        explain_plan.downcase.include?("using temporary")
+      end
+
+      def analyze_postgres_specific_issues(explain_plan)
+        issues = []
+
+        # High cost operations
+        if explain_plan.match(/cost=(\d+\.\d+)\.\.(\d+\.\d+)/)
+          total_cost = $2.to_f
+          if total_cost > 1000
+            issues << {
+              type: "high_cost_operation",
+              severity: "warning",
+              description: "Query has high execution cost (#{total_cost.round(2)})",
+              impact: "May indicate need for optimization or indexing"
+            }
+          end
+        end
+
+        # Hash joins on large datasets
+        if explain_plan.include?("Hash Join") && explain_plan.match(/rows=(\d+)/)
+          rows = $1.to_i
+          if rows > 10000
+            issues << {
+              type: "large_hash_join",
+              severity: "info",
+              description: "Hash join on large dataset (#{rows} rows)",
+              impact: "High memory usage during query execution"
+            }
+          end
+        end
+
+        issues
+      end
+
+      def analyze_mysql_specific_issues(explain_plan)
+        issues = []
+
+        # Using where with no index
+        if explain_plan.include?("Using where") && !explain_plan.include?("Using index")
+          issues << {
+            type: "where_without_index",
+            severity: "warning",
+            description: "WHERE clause not using index efficiently",
+            impact: "Slower query execution due to row-by-row filtering"
+          }
+        end
+
+        # Full table scan with large row count
+        if explain_plan.match(/type: ALL.*rows: (\d+)/)
+          rows = $1.to_i
+          if rows > 1000
+            issues << {
+              type: "full_scan_large_table",
+              severity: "warning",
+              description: "Full table scan on table with #{rows} rows",
+              impact: "Very slow query execution on large dataset"
+            }
+          end
+        end
+
+        issues
+      end
+
+      def analyze_sqlite_specific_issues(explain_plan)
+        issues = []
+
+        # SCAN TABLE operations
+        if explain_plan.include?("SCAN TABLE")
+          issues << {
+            type: "table_scan",
+            severity: "warning",
+            description: "SQLite performing table scan",
+            impact: "Linear search through all table rows"
+          }
+        end
+
+        # Missing index usage
+        if explain_plan.include?("USING INDEX") == false && explain_plan.include?("WHERE")
+          issues << {
+            type: "no_index_usage",
+            severity: "info",
+            description: "Query not utilizing available indexes",
+            impact: "Potential for optimization with proper indexing"
+          }
+        end
+
+        issues
+      end
+
+      def sanitize_sql_for_explain(sql)
+        # Basic sanitization for EXPLAIN
+        sql.strip.gsub(/;+\s*$/, "")
+      end
+
+      def execute_postgres_explain(sql)
+        result = RailsPulse::ApplicationRecord.connection.execute("EXPLAIN (ANALYZE, BUFFERS) #{sql}")
+        result.values.flatten.join("\n")
+      end
+
+      def execute_mysql_explain(sql)
+        result = RailsPulse::ApplicationRecord.connection.execute("EXPLAIN #{sql}")
+        result.to_a.map { |row| row.values.join(" | ") }.join("\n")
+      end
+
+      def execute_sqlite_explain(sql)
+        result = RailsPulse::ApplicationRecord.connection.execute("EXPLAIN QUERY PLAN #{sql}")
+        result.map { |row| row.values.join(" | ") }.join("\n")
+      end
+    end
+  end
+end

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