rails_pulse 0.1.1 → 0.1.3

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

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