pg_insights 0.1.0

data/app/controllers/pg_insights/health_controller.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module PgInsights
+  class HealthController < ApplicationController
+    layout "pg_insights/application"
+
+    def index
+      @health_results = HealthCheckResult.latest_results
+
+      @unused_indexes = extract_or_fetch("unused_indexes") { HealthCheckService.check_unused_indexes }
+      @missing_indexes = extract_or_fetch("missing_indexes") { HealthCheckService.check_missing_indexes }
+      @sequential_scans = extract_or_fetch("sequential_scans") { HealthCheckService.check_sequential_scans }
+      @slow_queries = extract_or_fetch("slow_queries") { HealthCheckService.check_slow_queries }
+      @table_bloat = extract_or_fetch("table_bloat") { HealthCheckService.check_table_bloat }
+      @parameter_settings = extract_or_fetch("parameter_settings") { HealthCheckService.check_parameter_settings }
+
+      refresh_stale_data_async
+    end
+
+    def unused_indexes
+      result = HealthCheckResult.latest_for_type("unused_indexes")
+      render json: {
+        data: result&.result_data || [],
+        status: result&.status || "pending",
+        executed_at: result&.executed_at,
+        fresh: result&.fresh? || false
+      }
+    end
+
+    def missing_indexes
+      result = HealthCheckResult.latest_for_type("missing_indexes")
+      render json: {
+        data: result&.result_data || [],
+        status: result&.status || "pending",
+        executed_at: result&.executed_at,
+        fresh: result&.fresh? || false
+      }
+    end
+
+    def sequential_scans
+      result = HealthCheckResult.latest_for_type("sequential_scans")
+      render json: {
+        data: result&.result_data || [],
+        status: result&.status || "pending",
+        executed_at: result&.executed_at,
+        fresh: result&.fresh? || false
+      }
+    end
+
+    def slow_queries
+      result = HealthCheckResult.latest_for_type("slow_queries")
+      render json: {
+        data: result&.result_data || [],
+        status: result&.status || "pending",
+        executed_at: result&.executed_at,
+        fresh: result&.fresh? || false
+      }
+    end
+
+    def table_bloat
+      result = HealthCheckResult.latest_for_type("table_bloat")
+      render json: {
+        data: result&.result_data || [],
+        status: result&.status || "pending",
+        executed_at: result&.executed_at,
+        fresh: result&.fresh? || false
+      }
+    end
+
+    def parameter_settings
+      result = HealthCheckResult.latest_for_type("parameter_settings")
+      render json: {
+        data: result&.result_data || [],
+        status: result&.status || "pending",
+        executed_at: result&.executed_at,
+        fresh: result&.fresh? || false
+      }
+    end
+
+    def refresh
+      HealthCheckService.refresh_all!
+      render json: { message: "Health checks queued for refresh" }
+    end
+
+    private
+
+    def extract_or_fetch(check_type)
+      cached_result = @health_results[check_type]
+
+      if cached_result&.fresh?
+        return cached_result.result_data
+      end
+
+      begin
+        yield
+      rescue => e
+        Rails.logger.error "Health check failed for #{check_type}: #{e.message}"
+        { error: e.message }
+      end
+    end
+
+    def refresh_stale_data_async
+      stale_checks = @health_results.select { |_, result| result.nil? || !result.fresh? }
+
+      if stale_checks.any?
+        HealthCheckService.refresh_all!
+      end
+    end
+  end
+end

data/app/controllers/pg_insights/insights_controller.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module PgInsights
+  class InsightsController < PgInsights::ApplicationController
+    layout "pg_insights/application"
+    protect_from_forgery with: :exception
+
+    MAX_ROWS = 1_000
+    TIMEOUT = 5_000
+
+    # GET /pg_insights
+    # POST /pg_insights
+    def index
+      # Combine built-in and user-saved queries for the UI
+      built_in_queries = PgInsights::InsightQueryService.all
+
+      saved_queries = PgInsights::Query.order(updated_at: :desc).map do |q|
+        {
+          id: q.id,
+          name: q.name,
+          sql: q.sql,
+          description: q.description,
+          category: q.category || "saved"
+        }
+      end
+
+      @insight_queries = built_in_queries + saved_queries
+
+      return unless request.post?
+      sql = params.require(:sql)
+
+      unless read_only?(sql)
+        flash.now[:alert] = "Only single SELECT statements are allowed"
+        return render :index, status: :unprocessable_entity
+      end
+
+      sql = append_limit(sql, MAX_ROWS) unless sql.match?(/limit\s+\d+/i)
+
+      begin
+        ActiveRecord::Base.connection.transaction do
+          ActiveRecord::Base.connection.execute("SET LOCAL statement_timeout = #{TIMEOUT}")
+          @result = ActiveRecord::Base.connection.exec_query(sql)
+        end
+      rescue ActiveRecord::StatementInvalid, PG::Error => e
+        flash.now[:alert] = "Query Error: #{e.message}"
+        return render :index, status: :unprocessable_entity
+      end
+
+      render :index
+    end
+
+    # GET /pg_insights/table_names
+    def table_names
+      tables = ActiveRecord::Base.connection.exec_query(
+        "SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename"
+      )
+      render json: { tables: tables.rows.map(&:first) }
+    rescue ActiveRecord::StatementInvalid, PG::Error => e
+      Rails.logger.error "Failed to fetch table names: #{e.message}"
+      render json: { tables: [] }
+    end
+
+    private
+
+    def read_only?(sql)
+      sql.strip!
+      # Check for a single SELECT statement
+      sql.downcase.start_with?("select") &&
+        !sql.include?(";") &&
+        !sql.match?(/\b(insert|update|delete|alter|drop|create|grant|revoke)\b/i)
+    end
+
+    def append_limit(sql, n)
+      "#{sql.strip} LIMIT #{n}"
+    end
+  end
+end

data/app/controllers/pg_insights/queries_controller.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PgInsights
+  class QueriesController < PgInsights::ApplicationController
+    protect_from_forgery with: :null_session
+
+    before_action :set_query, only: [ :update, :destroy ]
+
+    # POST /pg_insights/queries
+    def create
+      @query = PgInsights::Query.new(query_params)
+      if @query.save
+        render json: { success: true, query: @query.as_json(only: [ :id, :name, :sql, :description, :category ]) }, status: :created
+      else
+        render json: { success: false, errors: @query.errors.full_messages }, status: :unprocessable_entity
+      end
+    end
+
+    # PATCH/PUT /pg_insights/queries/:id
+    def update
+      if @query.update(query_params)
+        render json: { success: true, query: @query.as_json(only: [ :id, :name, :sql, :description, :category ]) }
+      else
+        render json: { success: false, errors: @query.errors.full_messages }, status: :unprocessable_entity
+      end
+    end
+
+    # DELETE /pg_insights/queries/:id
+    def destroy
+      @query.destroy
+      head :no_content
+    end
+
+    private
+
+    def set_query
+      @query = PgInsights::Query.find(params[:id])
+    end
+
+    def query_params
+      params.require(:query).permit(:name, :sql, :description, :category)
+    end
+  end
+end

data/app/helpers/pg_insights/application_helper.rb

@@ -0,0 +1,4 @@
+module PgInsights
+  module ApplicationHelper
+  end
+end

data/app/helpers/pg_insights/insights_helper.rb

@@ -0,0 +1,190 @@
+module PgInsights
+  module InsightsHelper
+    def should_show_chart?(result)
+      return false unless result&.rows&.any?
+      return false if result.columns.size < 2 || result.columns.size > 4
+
+      # Check if we have at least one numeric column
+      has_numeric = result.rows.any? do |row|
+        row.any? { |cell| cell.is_a?(Numeric) || (cell.is_a?(String) && cell.match?(/^\d+(\.\d+)?$/)) }
+      end
+
+      has_numeric && result.rows.size <= 50 # Limit for better chart readability
+    end
+
+    def render_chart(result)
+      chart_data = prepare_chart_data(result)
+      return "" unless chart_data[:chartData].present?
+
+      # Use bar chart as default with ChartKick
+      begin
+        bar_chart(
+          chart_data[:chartData],
+          height: "350px",
+          colors: [ "#00979D", "#00838a", "#00767a" ],
+          responsive: true
+        )
+      rescue => e
+        content_tag(:div,
+                    "Chart data format error: #{e.message}",
+                    style: "text-align: center; padding: 40px; color: #64748b;"
+        )
+      end
+    end
+
+    def render_stats(result)
+      stats = calculate_stats(result)
+
+      content_tag(:div) do
+        content_tag(:div, class: "stats-section") do
+          content_tag(:h4, "Summary Statistics") +
+            content_tag(:div, class: "stats-grid") do
+              stats.map do |stat|
+                content_tag(:div, class: "stat-card") do
+                  content_tag(:div, stat[:value], class: "stat-value") +
+                    content_tag(:div, stat[:label], class: "stat-label")
+                end
+              end.join.html_safe
+            end
+        end
+      end
+    end
+
+    def query_category_badge_class(category)
+      "query-category-badge #{category.to_s.downcase}"
+    end
+
+    def sql_placeholder_text
+      <<~SQL.strip
+        -- Enter your SQL query here
+
+        -- Example: Database table sizes (great for charts!)
+        SELECT tablename,
+               pg_total_relation_size(schemaname||'.'||tablename) as size_bytes
+        FROM pg_tables
+        WHERE schemaname = 'public'
+        ORDER BY pg_total_relation_size(schemaname||'.'||tablename) DESC
+        LIMIT 10;
+      SQL
+    end
+
+    def query_example_button_data(query)
+      {
+        query_id: query["id"],
+        category: query["category"],
+        title: query["description"]
+      }
+    end
+
+    def filter_buttons_data
+      [
+        { category: "all", label: "All", active: true },
+        { category: "database", label: "Database", active: false },
+        { category: "business", label: "Business", active: false },
+        { category: "saved", label: "Saved", active: false }
+      ]
+    end
+
+    def cell_value_class(cell)
+      if cell.nil?
+        "null-value"
+      elsif cell.to_s.strip.empty?
+        "empty-value"
+      elsif cell.is_a?(Numeric) || (cell.is_a?(String) && cell.match?(/^\d+(\.\d+)?$/))
+        "numeric-value"
+      elsif cell.to_s.length > 50
+        "long-text"
+      else
+        "text-value"
+      end
+    end
+
+    def format_cell_value(cell)
+      if cell.nil?
+        "NULL"
+      elsif cell.to_s.strip.empty?
+        "empty"
+      elsif cell.to_s.length > 100
+        truncate(cell.to_s, length: 100)
+      else
+        cell.to_s
+      end
+    end
+
+    private
+
+    def prepare_chart_data(result)
+      return { labels: [], chartData: [] } unless result&.rows&.any?
+
+      # For ChartKick, we need simple key-value pairs
+      chart_data = result.rows.map do |row|
+        label = row[0].to_s.truncate(30) # Truncate long labels
+        value = parse_numeric_value(row[1])
+        value ? [ label, value ] : nil
+      end.compact
+
+      {
+        labels: chart_data.map(&:first),
+        chartData: chart_data
+      }
+    rescue => e
+      Rails.logger.error "Chart data preparation error: #{e.message}"
+      { labels: [], chartData: [] }
+    end
+
+    def calculate_stats(result)
+      return [] unless result&.rows&.any?
+
+      stats = []
+
+      # Basic stats
+      stats << { label: "Total Records", value: number_with_delimiter(result.rows.size) }
+      stats << { label: "Columns", value: result.columns.size }
+
+      # Numeric column stats
+      result.columns.each_with_index do |col, idx|
+        next if idx == 0 # Skip first column (typically labels)
+
+        numeric_values = result.rows.map { |row| parse_numeric_value(row[idx]) }.compact
+
+        if numeric_values.any?
+          stats << {
+            label: "#{col} (Sum)",
+            value: number_with_delimiter(numeric_values.sum.round(2))
+          }
+          stats << {
+            label: "#{col} (Avg)",
+            value: number_with_delimiter((numeric_values.sum / numeric_values.size).round(2))
+          }
+          stats << {
+            label: "#{col} (Max)",
+            value: number_with_delimiter(numeric_values.max)
+          }
+          stats << {
+            label: "#{col} (Min)",
+            value: number_with_delimiter(numeric_values.min)
+          }
+        end
+      end
+
+      stats
+    end
+
+    def parse_numeric_value(value)
+      return nil if value.nil?
+      return value if value.is_a?(Numeric)
+
+      # Handle string numbers
+      if value.is_a?(String)
+        cleaned = value.to_s.gsub(/[,$\s%]/, "")
+        if cleaned.match?(/^\d+$/)
+          return cleaned.to_i
+        elsif cleaned.match?(/^\d+\.\d+$/)
+          return cleaned.to_f
+        end
+      end
+
+      nil
+    end
+  end
+end

data/app/jobs/pg_insights/application_job.rb

@@ -0,0 +1,4 @@
+module PgInsights
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/pg_insights/health_check_job.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module PgInsights
+  class HealthCheckJob < ApplicationJob
+    queue_as -> { PgInsights.background_job_queue }
+
+    rescue_from(StandardError) do |exception|
+      Rails.logger.error "PgInsights::HealthCheckJob failed: #{exception.message}"
+    end
+
+    def perform(check_type, options = {})
+      unless PgInsights.background_jobs_available?
+        Rails.logger.warn "PgInsights: Background jobs not available, skipping #{check_type} check"
+        return
+      end
+
+      limit = options.fetch("limit", 10)
+
+      Rails.logger.debug "PgInsights: Starting background health check for #{check_type}"
+
+      begin
+        HealthCheckService.execute_and_cache_check(check_type, limit)
+        Rails.logger.debug "PgInsights: Completed background health check for #{check_type}"
+      rescue => e
+        Rails.logger.error "PgInsights: Background health check failed for #{check_type}: #{e.message}"
+      end
+    end
+
+    def self.queue_name
+      PgInsights.background_job_queue
+    end
+
+    def self.perform_check(check_type, options = {})
+      return false unless PgInsights.background_jobs_available?
+
+      begin
+        perform_later(check_type, options)
+        true
+      rescue => e
+        Rails.logger.warn "PgInsights: Failed to enqueue health check job for #{check_type}: #{e.message}"
+        false
+      end
+    end
+  end
+end

data/app/jobs/pg_insights/health_check_scheduler_job.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module PgInsights
+  class HealthCheckSchedulerJob < ApplicationJob
+    queue_as -> { PgInsights.background_job_queue }
+
+    rescue_from(StandardError) do |exception|
+      Rails.logger.error "PgInsights::HealthCheckSchedulerJob failed: #{exception.message}"
+    end
+
+    def perform
+      unless PgInsights.background_jobs_available?
+        Rails.logger.warn "PgInsights: Background jobs not available, skipping scheduler"
+        return
+      end
+
+      Rails.logger.debug "PgInsights: Starting health check scheduler"
+
+      scheduled_count = 0
+
+      HealthCheckResult::VALID_CHECK_TYPES.each do |check_type|
+        latest = HealthCheckResult.latest_for_type(check_type)
+
+        if latest.nil? || !latest.fresh?
+          if HealthCheckJob.perform_check(check_type)
+            scheduled_count += 1
+            Rails.logger.debug "PgInsights: Scheduled health check for #{check_type}"
+          else
+            Rails.logger.warn "PgInsights: Failed to schedule health check for #{check_type}"
+          end
+        else
+          Rails.logger.debug "PgInsights: Skipping #{check_type} - data is fresh"
+        end
+      end
+
+      Rails.logger.info "PgInsights: Health check scheduler completed. Scheduled #{scheduled_count} checks."
+    end
+
+    def self.schedule_health_checks
+      return false unless PgInsights.background_jobs_available?
+
+      begin
+        perform_later
+        Rails.logger.info "PgInsights: Health check scheduler enqueued successfully"
+        true
+      rescue => e
+        Rails.logger.warn "PgInsights: Failed to enqueue health check scheduler: #{e.message}"
+        false
+      end
+    end
+  end
+end

data/app/jobs/pg_insights/recurring_health_checks_job.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module PgInsights
+  class RecurringHealthChecksJob < ApplicationJob
+    queue_as -> { PgInsights.background_job_queue }
+
+    rescue_from(StandardError) do |exception|
+      Rails.logger.error "PgInsights::RecurringHealthChecksJob failed: #{exception.message}"
+    end
+
+    def perform
+      unless PgInsights.background_jobs_available?
+        Rails.logger.warn "PgInsights: Background jobs not available, skipping recurring health checks"
+        return
+      end
+
+      Rails.logger.debug "PgInsights: Starting recurring health check cycle"
+
+      if HealthCheckSchedulerJob.schedule_health_checks
+        Rails.logger.info "PgInsights: Recurring health check cycle initiated successfully"
+      else
+        Rails.logger.warn "PgInsights: Recurring health check cycle failed to start"
+      end
+    end
+
+    def self.should_be_scheduled?
+      PgInsights.background_jobs_available? &&
+      PgInsights.enable_background_jobs &&
+      defined?(HealthCheckSchedulerJob) &&
+      defined?(HealthCheckJob)
+    end
+
+    def self.validate_setup
+      issues = []
+
+      issues << "Background jobs are disabled" unless PgInsights.enable_background_jobs
+      issues << "ActiveJob not available" unless defined?(ActiveJob::Base)
+      issues << "Queue adapter is inline (no async processing)" if ActiveJob::Base.queue_adapter.is_a?(ActiveJob::QueueAdapters::InlineAdapter)
+      issues << "HealthCheckJob not available" unless defined?(HealthCheckJob)
+      issues << "HealthCheckSchedulerJob not available" unless defined?(HealthCheckSchedulerJob)
+
+      if issues.empty?
+        { valid: true, message: "PgInsights recurring health checks are properly configured" }
+      else
+        { valid: false, issues: issues }
+      end
+    end
+  end
+end

data/app/models/pg_insights/application_record.rb

@@ -0,0 +1,5 @@
+module PgInsights
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/pg_insights/health_check_result.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module PgInsights
+  class HealthCheckResult < ApplicationRecord
+    VALID_CHECK_TYPES = %w[
+      unused_indexes
+      missing_indexes
+      sequential_scans
+      slow_queries
+      table_bloat
+      parameter_settings
+    ].freeze
+
+    VALID_STATUSES = %w[pending running success error].freeze
+
+    validates :check_type, presence: true, inclusion: { in: VALID_CHECK_TYPES }
+    validates :status, presence: true, inclusion: { in: VALID_STATUSES }
+
+    scope :recent, -> { order(executed_at: :desc) }
+    scope :successful, -> { where(status: "success") }
+    scope :by_type, ->(type) { where(check_type: type) }
+
+    def self.latest_for_type(check_type)
+      by_type(check_type).successful.recent.first
+    end
+
+    def self.latest_results
+      VALID_CHECK_TYPES.map do |check_type|
+        [ check_type, latest_for_type(check_type) ]
+      end.to_h
+    end
+
+    def success?
+      status == "success"
+    end
+
+    def error?
+      status == "error"
+    end
+
+    def fresh?(threshold = nil)
+      threshold ||= PgInsights.health_cache_expiry
+      executed_at && executed_at > threshold.ago
+    end
+  end
+end

data/app/models/pg_insights/query.rb

@@ -0,0 +1,10 @@
+module PgInsights
+  class Query < ApplicationRecord
+    self.table_name = "pg_insights_queries"
+
+    validates :name, presence: true, uniqueness: { case_sensitive: false }
+    validates :sql, presence: true
+    validates :description, length: { maximum: 500 }
+    validates :category, presence: true
+  end
+end