pg_insights 0.1.0 → 0.2.0

data/app/models/pg_insights/health_check_result.rb

@@ -9,6 +9,7 @@ module PgInsights
       slow_queries
       table_bloat
       parameter_settings
+      database_snapshot
     ].freeze
 
     VALID_STATUSES = %w[pending running success error].freeze
@@ -42,5 +43,155 @@ module PgInsights
       threshold ||= PgInsights.health_cache_expiry
       executed_at && executed_at > threshold.ago
     end
+
+    def self.snapshots(limit = 90)
+      by_type("database_snapshot").successful.recent.limit(limit)
+    end
+
+    def self.latest_snapshot
+      by_type("database_snapshot").successful.recent.first
+    end
+
+    def self.snapshots_between(start_date, end_date)
+      by_type("database_snapshot")
+        .successful
+        .where(executed_at: start_date.beginning_of_day..end_date.end_of_day)
+        .order(:executed_at)
+    end
+
+    def self.find_snapshot_by_date(date)
+      by_type("database_snapshot")
+        .successful
+        .where("DATE(executed_at) = ?", date.to_date)
+        .first
+    end
+
+    def self.detect_parameter_changes_since(days_ago = 7)
+      snapshots = by_type("database_snapshot")
+                    .successful
+                    .where("executed_at >= ?", days_ago.days.ago)
+                    .order(:executed_at)
+                    .to_a
+
+      changes = []
+      snapshots.each_cons(2) do |older_snapshot, newer_snapshot|
+        snapshot_changes = compare_snapshots(older_snapshot, newer_snapshot)
+        if snapshot_changes.any?
+          changes << {
+            detected_at: newer_snapshot.executed_at,
+            changes: snapshot_changes
+          }
+        end
+      end
+
+      changes
+    end
+
+    def self.compare_snapshots(snapshot1, snapshot2)
+      return {} unless snapshot1&.result_data && snapshot2&.result_data
+
+      params1 = snapshot1.result_data.dig("parameters") || {}
+      params2 = snapshot2.result_data.dig("parameters") || {}
+
+      changes = {}
+      params2.each do |param_name, new_value|
+        old_value = params1[param_name]
+        if old_value != new_value && !both_nil_or_empty?(old_value, new_value)
+          changes[param_name] = {
+            from: old_value,
+            to: new_value,
+            change_type: determine_change_type(param_name, old_value, new_value),
+            detected_at: snapshot2.executed_at
+          }
+        end
+      end
+
+      changes
+    end
+
+    def self.cleanup_old_snapshots
+      return unless PgInsights.snapshots_available?
+
+      cutoff_date = PgInsights.snapshot_retention_days.days.ago
+      deleted_count = by_type("database_snapshot")
+                        .where("executed_at < ?", cutoff_date)
+                        .delete_all
+
+      Rails.logger.info "PgInsights: Cleaned up #{deleted_count} old snapshots" if deleted_count > 0
+      deleted_count
+    end
+
+    def self.timeline_data(days = 30)
+      snapshots = by_type("database_snapshot")
+                    .successful
+                    .where("executed_at >= ?", days.days.ago)
+                    .order(:executed_at)
+
+      {
+        dates: snapshots.map { |s| s.executed_at.strftime("%Y-%m-%d %H:%M") },
+        cache_hit_rates: snapshots.map { |s| (s.result_data.dig("metrics", "cache_hit_rate") || 0).to_f },
+        avg_query_times: snapshots.map { |s| (s.result_data.dig("metrics", "avg_query_time") || 0).to_f },
+        bloated_tables: snapshots.map { |s| (s.result_data.dig("metrics", "bloated_tables") || 0).to_i },
+        total_connections: snapshots.map { |s| (s.result_data.dig("metrics", "total_connections") || 0).to_i },
+        parameter_changes: detect_parameter_changes_since(days)
+      }
+    end
+
+    private
+
+    def self.both_nil_or_empty?(val1, val2)
+      (val1.nil? || val1 == "") && (val2.nil? || val2 == "")
+    end
+
+    def self.determine_change_type(param_name, old_value, new_value)
+      return "change" unless old_value && new_value
+
+      if numeric_parameter?(param_name)
+        old_numeric = extract_numeric_value(old_value)
+        new_numeric = extract_numeric_value(new_value)
+
+        return "change" unless old_numeric && new_numeric
+
+        if new_numeric > old_numeric
+          "increase"
+        elsif new_numeric < old_numeric
+          "decrease"
+        else
+          "stable"
+        end
+      else
+        old_value == new_value ? "stable" : "change"
+      end
+    end
+
+    def self.numeric_parameter?(param_name)
+      %w[
+        shared_buffers work_mem effective_cache_size max_connections
+        maintenance_work_mem wal_buffers max_wal_size min_wal_size
+        autovacuum_max_workers
+      ].include?(param_name.to_s)
+    end
+
+    def self.extract_numeric_value(value)
+      return value.to_f if value.is_a?(Numeric)
+      return nil unless value.is_a?(String)
+
+      if value.match(/(\d+(?:\.\d+)?)\s*(kB|MB|GB|TB)/i)
+        number = $1.to_f
+        unit = $2.upcase
+
+        case unit
+        when "KB" then number * 1024
+        when "MB" then number * 1024 * 1024
+        when "GB" then number * 1024 * 1024 * 1024
+        when "TB" then number * 1024 * 1024 * 1024 * 1024
+        else number
+        end
+      elsif value.match(/^\d+(?:\.\d+)?$/)
+        value.to_f
+      else
+        nil
+      end
+    end
   end
 end

data/app/services/pg_insights/health_check_service.rb

@@ -28,6 +28,12 @@ module PgInsights
       get_cached_result("parameter_settings") || execute_parameter_settings_query
     end
 
+    def self.collect_database_snapshot
+      return unless PgInsights.snapshots_available?
+
+      get_cached_result("database_snapshot") || execute_database_snapshot_query
+    end
+
     def self.refresh_all!(force_synchronous: false)
       if force_synchronous || !PgInsights.background_jobs_available?
         execute_all_checks_synchronously
@@ -124,6 +130,10 @@ module PgInsights
       execute_health_check_query("parameter_settings")
     end
 
+    def self.execute_database_snapshot_query
+      execute_health_check_query("database_snapshot")
+    end
+
     def self.execute_health_check_query(check_type, limit = 10)
       case check_type
       when "unused_indexes"
@@ -138,6 +148,8 @@ module PgInsights
         execute_table_bloat_sql(limit)
       when "parameter_settings"
         execute_parameter_settings_sql
+      when "database_snapshot"
+        execute_database_snapshot_sql
       else
         raise ArgumentError, "Unknown check type: #{check_type}"
       end
@@ -220,7 +232,7 @@ module PgInsights
           n_live_tup,
           CASE#{' '}
             WHEN (n_live_tup + n_dead_tup) > 0#{' '}
-            THEN round((n_dead_tup::float / (n_live_tup + n_dead_tup) * 100)::numeric, 2)
+            THEN round((n_dead_tup::numeric / (n_live_tup + n_dead_tup) * 100), 2)
             ELSE 0#{' '}
           END as dead_tuple_pct,
           pg_size_pretty(pg_total_relation_size(relid) / (1024*1024)) || ' MB' as table_mb_text,
@@ -233,7 +245,7 @@ module PgInsights
         WHERE schemaname = 'public'
           AND (n_live_tup + n_dead_tup) > 0
           AND (
-            (n_dead_tup::float / (n_live_tup + n_dead_tup)) > 0.1
+            (n_dead_tup::numeric / (n_live_tup + n_dead_tup)) > 0.1
             OR n_dead_tup > 1000
           )
           AND pg_total_relation_size(relid) > 1024*1024
@@ -258,7 +270,6 @@ module PgInsights
       result = execute_query(sql)
       return result if result.is_a?(Hash) && result[:error]
 
-      # todo basic recommendations (can be improved with system info)
       recommendations = {
         "shared_buffers" => "Recommended: 25% of total system RAM.",
         "work_mem" => "Recommended: Based on RAM, connections, and query complexity. Default is often too low.",
@@ -273,6 +284,151 @@ module PgInsights
       end
     end
 
+    def self.execute_database_snapshot_sql
+      {
+        parameters: collect_enhanced_parameters,
+        metrics: collect_performance_metrics,
+        metadata: collect_database_metadata,
+        collected_at: Time.current.iso8601
+      }
+    end
+
+    def self.collect_enhanced_parameters
+      settings_to_check = [
+        "shared_buffers", "work_mem", "effective_cache_size",
+        "max_connections", "maintenance_work_mem", "checkpoint_completion_target",
+        "wal_buffers", "random_page_cost", "seq_page_cost", "cpu_tuple_cost",
+        "autovacuum", "autovacuum_max_workers", "max_wal_size", "min_wal_size"
+      ]
+
+      sql = <<-SQL
+        SELECT name, setting, unit, context, vartype
+        FROM pg_settings
+        WHERE name IN (#{settings_to_check.map { |s| "'#{s}'" }.join(',')})
+        ORDER BY name;
+      SQL
+
+      result = execute_query(sql)
+      return {} if result.is_a?(Hash) && result[:error]
+
+      result.each_with_object({}) do |row, hash|
+        key = row["name"]
+        value = row["setting"]
+        value += row["unit"] if row["unit"].present?
+        hash[key] = value
+      end
+    end
+
+    def self.collect_performance_metrics
+      metrics = {}
+
+      cache_sql = <<-SQL
+        SELECT#{' '}
+          CASE#{' '}
+            WHEN sum(heap_blks_hit) + sum(heap_blks_read) = 0 THEN 0
+            ELSE round((sum(heap_blks_hit)::numeric / (sum(heap_blks_hit) + sum(heap_blks_read))) * 100, 2)
+          END as cache_hit_rate
+        FROM pg_statio_user_tables;
+      SQL
+
+      cache_result = execute_query(cache_sql)
+      metrics["cache_hit_rate"] = cache_result.first&.dig("cache_hit_rate") || 0
+
+      if extension_available?("pg_stat_statements")
+        query_sql = <<-SQL
+          SELECT#{' '}
+            round(avg(mean_exec_time)::numeric, 2) as avg_query_time,
+            round(percentile_cont(0.95) WITHIN GROUP (ORDER BY mean_exec_time)::numeric, 2) as p95_query_time,
+            count(*) as total_queries,
+            sum(calls) as total_calls
+          FROM pg_stat_statements#{' '}
+          WHERE mean_exec_time > 0;
+        SQL
+
+        query_result = execute_query(query_sql)
+        if query_result.first
+          metrics["avg_query_time"] = query_result.first["avg_query_time"]
+          metrics["p95_query_time"] = query_result.first["p95_query_time"]
+          metrics["total_queries"] = query_result.first["total_queries"]
+          metrics["total_calls"] = query_result.first["total_calls"]
+        end
+      end
+
+      bloat_sql = <<-SQL
+        SELECT#{' '}
+          count(*) as bloated_tables,
+          round(avg(CASE#{' '}
+            WHEN (n_live_tup + n_dead_tup) > 0#{' '}
+            THEN (n_dead_tup::numeric / (n_live_tup + n_dead_tup) * 100)
+            ELSE 0#{' '}
+          END), 2) as avg_bloat_pct
+        FROM pg_stat_user_tables
+        WHERE schemaname = 'public'
+          AND (n_live_tup + n_dead_tup) > 0
+          AND (n_dead_tup::numeric / (n_live_tup + n_dead_tup)) > 0.1;
+      SQL
+
+      bloat_result = execute_query(bloat_sql)
+      if bloat_result.first
+        metrics["bloated_tables"] = bloat_result.first["bloated_tables"] || 0
+        metrics["avg_bloat_pct"] = bloat_result.first["avg_bloat_pct"] || 0
+      end
+
+      conn_sql = <<-SQL
+        SELECT#{' '}
+          count(*) as total_connections,
+          count(*) FILTER (WHERE state = 'active') as active_connections,
+          count(*) FILTER (WHERE state = 'idle') as idle_connections
+        FROM pg_stat_activity;
+      SQL
+
+      conn_result = execute_query(conn_sql)
+      if conn_result.first
+        metrics["total_connections"] = conn_result.first["total_connections"]
+        metrics["active_connections"] = conn_result.first["active_connections"]
+        metrics["idle_connections"] = conn_result.first["idle_connections"]
+      end
+
+      seq_scan_sql = <<-SQL
+        SELECT count(*) as high_seq_scan_tables
+        FROM pg_stat_user_tables
+        WHERE schemaname = 'public' AND seq_scan > 100;
+      SQL
+
+      seq_result = execute_query(seq_scan_sql)
+      metrics["high_seq_scan_tables"] = seq_result.first&.dig("high_seq_scan_tables") || 0
+
+      metrics
+    end
+
+    def self.collect_database_metadata
+      {
+        postgres_version: execute_query("SELECT version();").first&.dig("version"),
+        database_size: execute_query("SELECT pg_size_pretty(pg_database_size(current_database()));").first&.values&.first,
+        extensions: collect_extensions,
+        collected_at: Time.current.iso8601
+      }
+    end
+
+    def self.collect_extensions
+      ext_sql = "SELECT extname FROM pg_extension ORDER BY extname;"
+      result = execute_query(ext_sql)
+      return [] if result.is_a?(Hash) && result[:error]
+
+      result.map { |row| row["extname"] }
+    end
+
+    def self.extension_available?(extension_name)
+      escaped_name = ActiveRecord::Base.connection.quote(extension_name)
+      result = execute_query("SELECT 1 FROM pg_extension WHERE extname = #{escaped_name}")
+
+      return false if result.is_a?(Hash) && result[:error]
+      result.any?
+    rescue => e
+      Rails.logger.error "PgInsights: Extension availability check failed: #{e.message}"
+      false
+    end
+
     def self.get_cached_result(check_type)
       return nil unless defined?(HealthCheckResult)
 

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

@@ -25,6 +25,7 @@
         <div class="header-right">
           <nav class="header-nav">
             <%= link_to "Health Dashboard", pg_insights.health_path, class: "nav-link #{'active' if current_page?(pg_insights.health_path)}" %>
+            <%= link_to "Timeline", pg_insights.timeline_path, class: "nav-link #{'active' if current_page?(pg_insights.timeline_path)}" %>
             <%= link_to "Query Runner", pg_insights.root_path, class: "nav-link #{'active' if current_page?(pg_insights.root_path)}" %>
           </nav>
         </div>