pg_insights 0.3.1 → 0.4.0

data/app/jobs/pg_insights/query_analysis_job.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module PgInsights
+  class QueryAnalysisJob < ApplicationJob
+    queue_as do
+      PgInsights.queue_name || :default
+    end
+
+    retry_on StandardError, wait: :polynomially_longer, attempts: 3
+    discard_on ActiveRecord::RecordNotFound
+
+    def perform(execution_id, options = {})
+      execution = QueryExecution.find(execution_id)
+
+      # Skip if already completed or failed
+      return execution if execution.completed? || execution.failed?
+
+      Rails.logger.info "Starting query analysis for execution #{execution_id}"
+
+      begin
+        execution.mark_as_running!
+
+        results = case execution.execution_type
+        when "execute"
+                   execute_query(execution.sql_text, options)
+        when "analyze"
+                   analyze_query(execution.sql_text, options)
+        when "both"
+                   execute_and_analyze_query(execution.sql_text, options)
+        else
+                   raise ArgumentError, "Invalid execution_type: #{execution.execution_type}"
+        end
+
+        execution.mark_as_completed!(results)
+        Rails.logger.info "Completed query analysis for execution #{execution_id}"
+
+        execution
+
+      rescue => e
+        Rails.logger.error "Query analysis job failed for execution #{execution_id}: #{e.message}"
+        Rails.logger.error e.backtrace.join("\n") if Rails.env.development?
+
+        execution.mark_as_failed!(e.message, e.backtrace&.first&.truncate(500))
+        raise # Re-raise for job retry mechanism
+      end
+    end
+
+    private
+
+    def execute_query(sql, options)
+      result = execute_with_timeout(sql, PgInsights.query_execution_timeout_ms)
+
+      {
+        result_data: serialize_result_data(result),
+        result_rows_count: result.rows.count,
+        result_columns_count: result.columns.count,
+        total_time_ms: measure_execution_time { result }
+      }
+    end
+
+    def analyze_query(sql, options)
+      explain_sql = build_explain_query(sql, options)
+      result = execute_with_timeout(explain_sql, PgInsights.query_analysis_timeout_ms)
+
+      plan_data = parse_explain_output(result)
+      insights = generate_performance_insights(plan_data)
+
+      {
+        execution_plan: plan_data,
+        plan_summary: generate_plan_summary(plan_data),
+        planning_time_ms: extract_planning_time(plan_data),
+        execution_time_ms: extract_execution_time(plan_data),
+        total_time_ms: calculate_total_time(plan_data),
+        query_cost: extract_query_cost(plan_data),
+        performance_insights: insights,
+        execution_stats: extract_execution_stats(plan_data)
+      }
+    end
+
+    def execute_and_analyze_query(sql, options)
+      # Execute the query first
+      execution_results = execute_query(sql, options)
+
+      # Then analyze it
+      analysis_results = analyze_query(sql, options)
+
+      # Merge both sets of results
+      execution_results.merge(analysis_results)
+    end
+
+    # Delegate to service methods to avoid code duplication
+    def execute_with_timeout(sql, timeout_ms)
+      QueryAnalysisService.send(:execute_with_timeout, sql, timeout_ms)
+    end
+
+    def build_explain_query(sql, options)
+      QueryAnalysisService.send(:build_explain_query, sql, options)
+    end
+
+    def parse_explain_output(result)
+      QueryAnalysisService.send(:parse_explain_output, result)
+    end
+
+    def generate_plan_summary(plan_data)
+      QueryAnalysisService.send(:generate_plan_summary, plan_data)
+    end
+
+    def extract_planning_time(plan_data)
+      QueryAnalysisService.send(:extract_planning_time, plan_data)
+    end
+
+    def extract_execution_time(plan_data)
+      QueryAnalysisService.send(:extract_execution_time, plan_data)
+    end
+
+    def calculate_total_time(plan_data)
+      QueryAnalysisService.send(:calculate_total_time, plan_data)
+    end
+
+    def extract_query_cost(plan_data)
+      QueryAnalysisService.send(:extract_query_cost, plan_data)
+    end
+
+    def extract_execution_stats(plan_data)
+      QueryAnalysisService.send(:extract_execution_stats, plan_data)
+    end
+
+    def generate_performance_insights(plan_data)
+      QueryAnalysisService.send(:generate_performance_insights, plan_data)
+    end
+
+    def serialize_result_data(result)
+      QueryAnalysisService.send(:serialize_result_data, result)
+    end
+
+    def measure_execution_time
+      start_time = Time.current
+      yield
+      ((Time.current - start_time) * 1000).round(3)
+    end
+  end
+end

data/app/models/pg_insights/query_execution.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module PgInsights
+  class QueryExecution < ApplicationRecord
+    self.table_name = "pg_insights_query_executions"
+
+    belongs_to :query, class_name: "PgInsights::Query", optional: true
+
+    EXECUTION_TYPES = %w[execute analyze both].freeze
+    STATUSES = %w[pending running completed failed].freeze
+
+    validates :sql_text, presence: true
+    validates :execution_type, inclusion: { in: EXECUTION_TYPES }
+    validates :status, inclusion: { in: STATUSES }
+
+    scope :recent, -> { order(created_at: :desc) }
+    scope :completed, -> { where(status: "completed") }
+    scope :failed, -> { where(status: "failed") }
+    scope :with_analysis, -> { where(execution_type: [ "analyze", "both" ]) }
+    scope :with_results, -> { where(execution_type: [ "execute", "both" ]) }
+    scope :analyzable, -> { completed.with_analysis.where.not(execution_plan: nil) }
+    scope :recent_history, ->(limit = 10) { analyzable.recent.limit(limit) }
+
+    # Status management
+    def pending?
+      status == "pending"
+    end
+
+    def running?
+      status == "running"
+    end
+
+    def completed?
+      status == "completed"
+    end
+
+    def failed?
+      status == "failed"
+    end
+
+    def success?
+      completed? && error_message.blank?
+    end
+
+    # Execution type checks
+    def includes_execution?
+      execution_type.in?([ "execute", "both" ])
+    end
+
+    def includes_analysis?
+      execution_type.in?([ "analyze", "both" ])
+    end
+
+    # Performance metrics
+    def has_timing_data?
+      planning_time_ms.present? || execution_time_ms.present?
+    end
+
+    def formatted_total_time
+      return nil unless total_time_ms
+
+      if total_time_ms < 1000
+        "#{total_time_ms.round(2)}ms"
+      else
+        "#{(total_time_ms / 1000).round(2)}s"
+      end
+    end
+
+    def formatted_query_cost
+      return nil unless query_cost
+
+      if query_cost < 1000
+        query_cost.round(2)
+      else
+        "#{(query_cost / 1000).round(1)}K"
+      end
+    end
+
+    # Plan analysis helpers
+    def has_plan_data?
+      execution_plan.present?
+    end
+
+    def plan_nodes
+      return [] unless execution_plan.present?
+
+      # Extract plan nodes from PostgreSQL EXPLAIN output
+      plan_data = execution_plan.is_a?(Array) ? execution_plan.first : execution_plan
+      extract_plan_nodes(plan_data["Plan"]) if plan_data && plan_data["Plan"]
+    end
+
+    def optimization_suggestions
+      return [] unless performance_insights.present?
+
+      performance_insights["suggestions"] || []
+    end
+
+    def has_performance_issues?
+      return false unless performance_insights.present?
+
+      insights = performance_insights
+      insights["issues_detected"] == true ||
+      insights["slow_operations"].present? ||
+      insights["missing_indexes"].present?
+    end
+
+    # Result data helpers
+    def has_result_data?
+      result_data.present? && result_rows_count.present?
+    end
+
+    def result_summary
+      return nil unless has_result_data?
+
+      "#{result_rows_count} #{'row'.pluralize(result_rows_count)} • #{result_columns_count} #{'column'.pluralize(result_columns_count)}"
+    end
+
+    # Status transitions
+    def mark_as_running!
+      update!(
+        status: "running",
+        started_at: Time.current
+      )
+    end
+
+    def mark_as_completed!(results = {})
+      update!(
+        status: "completed",
+        completed_at: Time.current,
+        duration_ms: calculate_duration,
+        **results
+      )
+    end
+
+    def mark_as_failed!(error_msg, error_detail = nil)
+      update!(
+        status: "failed",
+        completed_at: Time.current,
+        duration_ms: calculate_duration,
+        error_message: error_msg,
+        error_detail: error_detail
+      )
+    end
+
+    # History display helpers (public methods)
+    def display_title
+      return sql_text.truncate(50) if sql_text.present?
+      "Query ##{id}"
+    end
+
+    def display_summary
+      parts = []
+      parts << "#{formatted_total_time}" if total_time_ms.present?
+      parts << "Cost: #{formatted_query_cost}" if query_cost.present?
+      parts << "#{result_rows_count} rows" if result_rows_count.present?
+      parts.join(" • ")
+    end
+
+    def performance_class
+      return "performance-excellent" if total_time_ms && total_time_ms < 50
+      return "performance-good" if total_time_ms && total_time_ms < 200
+      return "performance-fair" if total_time_ms && total_time_ms < 1000
+      return "performance-poor" if total_time_ms && total_time_ms >= 1000
+      "performance-unknown"
+    end
+
+    private
+
+    def calculate_duration
+      return nil unless started_at
+
+      end_time = completed_at || Time.current
+      ((end_time - started_at) * 1000).round(3)
+    end
+
+    def extract_plan_nodes(plan_node, nodes = [], level = 0)
+      return nodes unless plan_node
+
+      nodes << {
+        node_type: plan_node["Node Type"],
+        relation_name: plan_node["Relation Name"],
+        cost: plan_node["Total Cost"],
+        actual_time: plan_node["Actual Total Time"],
+        actual_rows: plan_node["Actual Rows"],
+        level: level
+      }
+
+      # Recursively process child plans
+      if plan_node["Plans"]
+        plan_node["Plans"].each do |child_plan|
+          extract_plan_nodes(child_plan, nodes, level + 1)
+        end
+      end
+
+      nodes
+    end
+  end
+end

data/app/services/pg_insights/query_analysis_service.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module PgInsights
+  class QueryAnalysisService
+    class << self
+      def execute_query(sql, execution_type: "execute", options: {})
+        execution = create_execution_record(sql, execution_type)
+
+        begin
+          execution.mark_as_running!
+
+          results = case execution_type.to_s
+          when "execute"
+                     execute_only(sql, options)
+          when "analyze"
+                     analyze_only(sql, options)
+          when "both"
+                     execute_and_analyze(sql, options)
+          else
+                     raise ArgumentError, "Invalid execution_type: #{execution_type}"
+          end
+
+          execution.mark_as_completed!(results)
+          execution
+
+        rescue => e
+          Rails.logger.error "Query analysis failed: #{e.message}"
+          Rails.logger.error e.backtrace.join("\n") if Rails.env.development?
+
+          execution.mark_as_failed!(e.message, e.backtrace&.first&.truncate(500))
+          execution
+        end
+      end
+
+      def analyze_query_async(sql, execution_type: "analyze", options: {})
+        if background_jobs_available?
+          execution = create_execution_record(sql, execution_type)
+          QueryAnalysisJob.perform_later(execution.id, options)
+          execution
+        else
+          # Fallback to synchronous execution
+          execute_query(sql, execution_type: execution_type, options: options)
+        end
+      end
+
+      private
+
+      def create_execution_record(sql, execution_type)
+        QueryExecution.create!(
+          sql_text: normalize_sql(sql),
+          execution_type: execution_type,
+          status: "pending"
+        )
+      end
+
+      def execute_only(sql, options)
+        result = execute_with_timeout(sql, PgInsights.query_execution_timeout_ms)
+
+        {
+          result_data: serialize_result_data(result),
+          result_rows_count: result.rows.count,
+          result_columns_count: result.columns.count,
+          total_time_ms: measure_execution_time { result }
+        }
+      end
+
+      def analyze_only(sql, options)
+        explain_sql = build_explain_query(sql, options)
+        result = execute_with_timeout(explain_sql, PgInsights.query_analysis_timeout_ms)
+
+        plan_data = parse_explain_output(result)
+        insights = generate_performance_insights(plan_data)
+
+        {
+          execution_plan: plan_data,
+          plan_summary: generate_plan_summary(plan_data),
+          planning_time_ms: extract_planning_time(plan_data),
+          execution_time_ms: extract_execution_time(plan_data),
+          total_time_ms: calculate_total_time(plan_data),
+          query_cost: extract_query_cost(plan_data),
+          performance_insights: insights,
+          execution_stats: extract_execution_stats(plan_data)
+        }
+      end
+
+      def execute_and_analyze(sql, options)
+        # Execute the query first
+        execution_results = execute_only(sql, options)
+
+        # Then analyze it
+        analysis_results = analyze_only(sql, options)
+
+        # Merge both sets of results
+        execution_results.merge(analysis_results)
+      end
+
+      def execute_with_timeout(sql, timeout_ms)
+        ActiveRecord::Base.connection.transaction do
+          ActiveRecord::Base.connection.execute("SET LOCAL statement_timeout = #{timeout_ms}")
+          ActiveRecord::Base.connection.exec_query(sql)
+        end
+      end
+
+      def build_explain_query(sql, options)
+        explain_options = []
+        explain_options << "ANALYZE"
+        explain_options << "VERBOSE" if options[:verbose]
+        explain_options << "COSTS" if options.fetch(:costs, true)
+        explain_options << "SETTINGS" if options[:settings]
+        explain_options << "BUFFERS" if options[:buffers]
+        explain_options << "TIMING" if options.fetch(:timing, true)
+        explain_options << "SUMMARY" if options.fetch(:summary, true)
+        explain_options << "FORMAT JSON" # Always use JSON for parsing
+
+        "EXPLAIN (#{explain_options.join(', ')}) #{sql}"
+      end
+
+      def parse_explain_output(result)
+        return {} if result.rows.empty?
+
+        json_string = result.rows.first.first
+        JSON.parse(json_string)
+      rescue JSON::ParserError => e
+        Rails.logger.error "Failed to parse EXPLAIN output: #{e.message}"
+        { error: "Failed to parse execution plan", raw_output: result.rows }
+      end
+
+      def generate_plan_summary(plan_data)
+        return nil unless plan_data.present? && plan_data.first
+
+        plan = plan_data.first["Plan"]
+        return nil unless plan
+
+        summary_parts = []
+        summary_parts << "#{plan['Node Type']}"
+        summary_parts << "on #{plan['Relation Name']}" if plan["Relation Name"]
+        summary_parts << "(cost=#{plan['Total Cost']&.round(2)})" if plan["Total Cost"]
+        summary_parts << "rows=#{plan['Actual Rows']}" if plan["Actual Rows"]
+        summary_parts << "time=#{plan['Actual Total Time']&.round(2)}ms" if plan["Actual Total Time"]
+
+        summary_parts.join(" ")
+      end
+
+      def extract_planning_time(plan_data)
+        return nil unless plan_data.present? && plan_data.first
+
+        plan_data.first["Planning Time"]
+      end
+
+      def extract_execution_time(plan_data)
+        return nil unless plan_data.present? && plan_data.first
+
+        plan_data.first["Execution Time"]
+      end
+
+      def calculate_total_time(plan_data)
+        planning = extract_planning_time(plan_data) || 0
+        execution = extract_execution_time(plan_data) || 0
+        planning + execution
+      end
+
+      def extract_query_cost(plan_data)
+        return nil unless plan_data.present? && plan_data.first && plan_data.first["Plan"]
+
+        plan_data.first["Plan"]["Total Cost"]
+      end
+
+      def extract_execution_stats(plan_data)
+        return {} unless plan_data.present? && plan_data.first
+
+        stats = {}
+        plan = plan_data.first["Plan"]
+
+        if plan
+          stats[:shared_hit_blocks] = plan["Shared Hit Blocks"] if plan["Shared Hit Blocks"]
+          stats[:shared_read_blocks] = plan["Shared Read Blocks"] if plan["Shared Read Blocks"]
+          stats[:shared_dirtied_blocks] = plan["Shared Dirtied Blocks"] if plan["Shared Dirtied_blocks"]
+          stats[:local_hit_blocks] = plan["Local Hit Blocks"] if plan["Local Hit Blocks"]
+          stats[:local_read_blocks] = plan["Local Read Blocks"] if plan["Local Read Blocks"]
+          stats[:temp_read_blocks] = plan["Temp Read Blocks"] if plan["Temp Read Blocks"]
+          stats[:temp_written_blocks] = plan["Temp Written Blocks"] if plan["Temp Written Blocks"]
+        end
+
+        stats
+      end
+
+      def generate_performance_insights(plan_data)
+        return { suggestions: [], issues_detected: false } unless plan_data.present?
+
+        insights = { suggestions: [], issues_detected: false, slow_operations: [], missing_indexes: [] }
+
+        plan = plan_data.first&.dig("Plan")
+        return insights unless plan
+
+        # Analyze plan for performance issues
+        analyze_node_performance(plan, insights)
+
+        insights[:issues_detected] = insights[:suggestions].any? ||
+                                   insights[:slow_operations].any? ||
+                                   insights[:missing_indexes].any?
+
+        insights
+      end
+
+      def analyze_node_performance(node, insights, level = 0)
+        return unless node
+
+        node_type = node["Node Type"]
+        actual_time = node["Actual Total Time"]
+        actual_rows = node["Actual Rows"]
+        relation_name = node["Relation Name"]
+
+        # Check for expensive sequential scans
+        if node_type == "Seq Scan" && actual_rows && actual_rows > 1000
+          insights[:slow_operations] << "Sequential scan on #{relation_name} (#{actual_rows} rows)"
+          insights[:suggestions] << "Consider adding an index on #{relation_name} to avoid full table scan"
+          insights[:missing_indexes] << relation_name if relation_name
+        end
+
+        # Check for expensive sorts
+        if node_type == "Sort" && actual_time && actual_time > 100
+          insights[:slow_operations] << "Expensive sort operation (#{actual_time.round(2)}ms)"
+          insights[:suggestions] << "Consider adding an index to avoid sorting, or increase work_mem"
+        end
+
+        # Check for nested loop joins with high cost
+        if node_type == "Nested Loop" && actual_time && actual_time > 50
+          insights[:slow_operations] << "Potentially expensive nested loop join"
+          insights[:suggestions] << "Consider adding indexes on join columns or using different join strategy"
+        end
+
+        # Check for hash joins that spill to disk
+        if node_type == "Hash Join" && node["Temp Written Blocks"] && node["Temp Written Blocks"] > 0
+          insights[:slow_operations] << "Hash join spilling to disk"
+          insights[:suggestions] << "Consider increasing work_mem to avoid disk spilling"
+        end
+
+        # Recursively analyze child nodes
+        if node["Plans"]
+          node["Plans"].each do |child_plan|
+            analyze_node_performance(child_plan, insights, level + 1)
+          end
+        end
+      end
+
+      def serialize_result_data(result)
+        {
+          columns: result.columns,
+          rows: result.rows,
+          column_types: result.column_types
+        }
+      end
+
+      def measure_execution_time
+        start_time = Time.current
+        yield
+        ((Time.current - start_time) * 1000).round(3)
+      end
+
+      def normalize_sql(sql)
+        sql.strip.gsub(/\s+/, " ")
+      end
+
+      def background_jobs_available?
+        defined?(ActiveJob) && ActiveJob::Base.queue_adapter.present?
+      end
+    end
+  end
+end

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

@@ -8,10 +8,17 @@
   <%#= favicon_link_tag "favicon.png" %>
   <%= stylesheet_link_tag "pg_insights/application", media: "all" %>
   <%= stylesheet_link_tag "pg_insights/results", media: "all" %>
+  <%= stylesheet_link_tag "pg_insights/analysis", media: "all" %>
   <%= stylesheet_link_tag "pg_insights/health", media: "all" %>
-  <%= javascript_include_tag "pg_insights/application", nonce: true %>
+  <%= javascript_include_tag "chartkick", nonce: true %>
+  <%= javascript_include_tag "Chart.bundle", nonce: true %>
+  <%= javascript_include_tag "pg_insights/results/view_toggles", nonce: true %>
+  <%= javascript_include_tag "pg_insights/results/chart_renderer", nonce: true %>
+  <%= javascript_include_tag "pg_insights/results/table_manager", nonce: true %>
   <%= javascript_include_tag "pg_insights/results", nonce: true %>
+  <%= javascript_include_tag "pg_insights/query_comparison", nonce: true %>
   <%= javascript_include_tag "pg_insights/health", nonce: true %>
+  <%= javascript_include_tag "pg_insights/application", nonce: true %>
 
 </head>
 <body>