pg_reports 0.3.1 → 0.4.0

data/lib/pg_reports/definitions/system/cache_stats.yml

@@ -0,0 +1,18 @@
+# Cache hit ratio for the entire database
+# Simple report showing cache statistics
+
+report:
+  name: cache_stats
+  module: system
+  description: "Database-wide cache hit statistics"
+
+  sql:
+    category: system
+    file: cache_stats
+
+  title: "Database Cache Statistics"
+
+  columns:
+    - database
+    - heap_hit_ratio
+    - index_hit_ratio

data/lib/pg_reports/definitions/system/database_sizes.yml

@@ -0,0 +1,18 @@
+# Database sizes
+# Simple report showing all database sizes
+
+report:
+  name: database_sizes
+  module: system
+  description: "Sizes of all databases"
+
+  sql:
+    category: system
+    file: database_sizes
+
+  title: "Database Sizes"
+
+  columns:
+    - database
+    - size_mb
+    - size_pretty

data/lib/pg_reports/definitions/system/extensions.yml

@@ -0,0 +1,19 @@
+# Extension information
+# Simple report showing installed PostgreSQL extensions
+
+report:
+  name: extensions
+  module: system
+  description: "Installed PostgreSQL extensions"
+
+  sql:
+    category: system
+    file: extensions
+
+  title: "Installed Extensions"
+
+  columns:
+    - name
+    - version
+    - schema
+    - description

data/lib/pg_reports/definitions/system/settings.yml

@@ -0,0 +1,20 @@
+# PostgreSQL settings
+# Simple report showing important configuration settings
+
+report:
+  name: settings
+  module: system
+  description: "Important PostgreSQL configuration settings"
+
+  sql:
+    category: system
+    file: settings
+
+  title: "PostgreSQL Settings"
+
+  columns:
+    - name
+    - setting
+    - unit
+    - category
+    - description

data/lib/pg_reports/definitions/tables/bloated_tables.yml

@@ -0,0 +1,43 @@
+# Bloated tables - tables with high dead tuple ratio
+# Report with threshold filtering and title interpolation
+
+report:
+  name: bloated_tables
+  module: tables
+  description: "Tables with high dead tuple ratio"
+
+  sql:
+    category: tables
+    file: bloated_tables
+
+  title: "Bloated Tables (bloat >= ${threshold}%)"
+  title_vars:
+    threshold:
+      source: config
+      key: bloat_threshold_percent
+
+  columns:
+    - schema
+    - table_name
+    - live_rows
+    - dead_rows
+    - bloat_percent
+    - table_size_mb
+
+  parameters:
+    limit:
+      type: integer
+      default: 20
+      description: "Maximum number of results"
+
+  filters:
+    - field: bloat_percent
+      operator: gte
+      value:
+        source: config
+        key: bloat_threshold_percent
+      cast: float
+
+  problem_explanations:
+    dead_tuple_ratio: many_dead_tuples
+    n_dead_tup: many_dead_tuples

data/lib/pg_reports/definitions/tables/cache_hit_ratios.yml

@@ -0,0 +1,26 @@
+# Table cache hit ratios
+# Simple report with limit parameter
+
+report:
+  name: cache_hit_ratios
+  module: tables
+  description: "Table cache hit ratios showing buffer hits vs reads"
+
+  sql:
+    category: tables
+    file: cache_hit_ratios
+
+  title: "Table Cache Hit Ratios"
+
+  columns:
+    - schema
+    - table_name
+    - heap_blks_read
+    - heap_blks_hit
+    - cache_hit_ratio
+
+  parameters:
+    limit:
+      type: integer
+      default: 50
+      description: "Maximum number of results"

data/lib/pg_reports/definitions/tables/recently_modified.yml

@@ -0,0 +1,27 @@
+# Recently modified tables
+# Simple report with limit parameter
+
+report:
+  name: recently_modified
+  module: tables
+  description: "Tables with recent modifications (inserts, updates, deletes)"
+
+  sql:
+    category: tables
+    file: recently_modified
+
+  title: "Recently Modified Tables"
+
+  columns:
+    - schema
+    - table_name
+    - n_tup_ins
+    - n_tup_upd
+    - n_tup_del
+    - last_analyze
+
+  parameters:
+    limit:
+      type: integer
+      default: 20
+      description: "Maximum number of results"

data/lib/pg_reports/definitions/tables/row_counts.yml

@@ -0,0 +1,29 @@
+# Table row counts
+# Report with title interpolation using limit parameter
+
+report:
+  name: row_counts
+  module: tables
+  description: "Table row counts sorted by count"
+
+  sql:
+    category: tables
+    file: row_counts
+
+  title: "Table Row Counts (top ${limit})"
+  title_vars:
+    limit:
+      source: param
+      key: limit
+
+  columns:
+    - schema
+    - table_name
+    - row_count
+    - table_size_mb
+
+  parameters:
+    limit:
+      type: integer
+      default: 50
+      description: "Maximum number of results"

data/lib/pg_reports/definitions/tables/seq_scans.yml

@@ -0,0 +1,31 @@
+# Sequential scan statistics
+# Report with title interpolation using limit parameter
+
+report:
+  name: seq_scans
+  module: tables
+  description: "Sequential scan statistics for tables"
+
+  sql:
+    category: tables
+    file: seq_scans
+
+  title: "Sequential Scans (top ${limit})"
+  title_vars:
+    limit:
+      source: param
+      key: limit
+
+  columns:
+    - schema
+    - table_name
+    - seq_scan
+    - seq_tup_read
+    - idx_scan
+    - rows_per_seq_scan
+
+  parameters:
+    limit:
+      type: integer
+      default: 20
+      description: "Maximum number of results"

data/lib/pg_reports/definitions/tables/table_sizes.yml

@@ -0,0 +1,31 @@
+# Table sizes including indexes
+# Report with title interpolation using limit parameter
+
+report:
+  name: table_sizes
+  module: tables
+  description: "Table sizes including indexes"
+
+  sql:
+    category: tables
+    file: table_sizes
+
+  title: "Table Sizes (top ${limit})"
+  title_vars:
+    limit:
+      source: param
+      key: limit
+
+  columns:
+    - schema
+    - table_name
+    - table_size_mb
+    - index_size_mb
+    - total_size_mb
+    - row_count
+
+  parameters:
+    limit:
+      type: integer
+      default: 50
+      description: "Maximum number of results"

data/lib/pg_reports/definitions/tables/vacuum_needed.yml

@@ -0,0 +1,39 @@
+# Tables needing vacuum - high dead rows count
+# Report with threshold filtering and title interpolation
+
+report:
+  name: vacuum_needed
+  module: tables
+  description: "Tables with high dead rows count needing vacuum"
+
+  sql:
+    category: tables
+    file: vacuum_needed
+
+  title: "Tables Needing Vacuum (dead rows >= ${threshold})"
+  title_vars:
+    threshold:
+      source: config
+      key: dead_rows_threshold
+
+  columns:
+    - schema
+    - table_name
+    - n_live_tup
+    - n_dead_tup
+    - last_vacuum
+    - last_autovacuum
+
+  parameters:
+    limit:
+      type: integer
+      default: 20
+      description: "Maximum number of results"
+
+  filters:
+    - field: n_dead_tup
+      operator: gte
+      value:
+        source: config
+        key: dead_rows_threshold
+      cast: integer

data/lib/pg_reports/filter.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module PgReports
+  # Applies filtering logic to report data based on YAML configuration
+  class Filter
+    OPERATORS = {
+      "eq" => ->(a, b) { a == b },
+      "ne" => ->(a, b) { a != b },
+      "lt" => ->(a, b) { a < b },
+      "lte" => ->(a, b) { a <= b },
+      "gt" => ->(a, b) { a > b },
+      "gte" => ->(a, b) { a >= b }
+    }.freeze
+
+    def initialize(config)
+      @field = config["field"]
+      @operator = config["operator"]
+      @value_config = config["value"]
+      @cast = config["cast"] || "string"
+    end
+
+    def apply(data, params)
+      threshold = resolve_value(params)
+      operator_fn = OPERATORS[@operator]
+
+      raise ArgumentError, "Unknown operator: #{@operator}" unless operator_fn
+
+      data.select do |row|
+        field_value = cast_value(row[@field], @cast)
+        operator_fn.call(field_value, threshold)
+      end
+    end
+
+    private
+
+    def resolve_value(params)
+      value = case @value_config["source"]
+      when "config"
+        PgReports.config.public_send(@value_config["key"])
+      when "param"
+        params[@value_config["key"].to_sym]
+      else
+        raise ArgumentError, "Unknown value source: #{@value_config["source"]}"
+      end
+
+      cast_value(value, @cast)
+    end
+
+    def cast_value(value, type)
+      case type
+      when "integer" then value.to_i
+      when "float" then value.to_f
+      when "string" then value.to_s
+      else value
+      end
+    end
+  end
+end

data/lib/pg_reports/module_generator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PgReports
+  # Generates module methods dynamically from YAML report definitions
+  class ModuleGenerator
+    def self.generate!
+      ReportLoader.load_all.each do |module_name, reports|
+        module_class = get_module(module_name)
+        next unless module_class
+
+        reports.each do |report_name, definition|
+          define_report_method(module_class, report_name, definition)
+        end
+      end
+    end
+
+    private
+
+    def self.get_module(module_name)
+      PgReports::Modules.const_get(module_name.capitalize)
+    rescue NameError
+      # Module doesn't exist, skip it
+      # We don't auto-create modules to avoid conflicts
+      nil
+    end
+
+    def self.define_report_method(module_class, report_name, definition)
+      params_config = definition.config["parameters"] || {}
+
+      # Extract default parameter values
+      defaults = params_config.transform_values { |v| v["default"] }
+
+      # Define the method on the module
+      # We capture the definition in a local variable to avoid closure issues
+      captured_definition = definition
+      captured_defaults = defaults
+
+      module_class.define_singleton_method(report_name) do |**params|
+        merged_params = captured_defaults.merge(params)
+        captured_definition.generate_report(**merged_params)
+      end
+    end
+  end
+end

data/lib/pg_reports/modules/connections.rb

@@ -3,82 +3,17 @@
 module PgReports
   module Modules
     # Connection and lock analysis module
+    # Most report methods are generated from YAML definitions in lib/pg_reports/definitions/connections/
     module Connections
       extend self
 
-      # Active connections
-      # @return [Report] Report with active connections
-      def active_connections
-        data = executor.execute_from_file(:connections, :active_connections)
-
-        Report.new(
-          title: "Active Connections",
-          data: data,
-          columns: %w[pid database username application state query_start state_change query]
-        )
-      end
-
-      # Connection statistics by state
-      # @return [Report] Report with connection counts by state
-      def connection_stats
-        data = executor.execute_from_file(:connections, :connection_stats)
-
-        Report.new(
-          title: "Connection Statistics",
-          data: data,
-          columns: %w[database state count]
-        )
-      end
-
-      # Long running queries
-      # @return [Report] Report with long running queries
-      def long_running_queries(min_duration_seconds: 60)
-        data = executor.execute_from_file(:connections, :long_running_queries)
-
-        filtered = data.select { |row| row["duration_seconds"].to_f >= min_duration_seconds }
-
-        Report.new(
-          title: "Long Running Queries (>= #{min_duration_seconds}s)",
-          data: filtered,
-          columns: %w[pid database username duration_seconds state query]
-        )
-      end
-
-      # Blocking queries - queries that are blocking others
-      # @return [Report] Report with blocking queries
-      def blocking_queries
-        data = executor.execute_from_file(:connections, :blocking_queries)
-
-        Report.new(
-          title: "Blocking Queries",
-          data: data,
-          columns: %w[blocked_pid blocking_pid blocked_query blocking_query blocked_duration]
-        )
-      end
-
-      # Lock statistics
-      # @return [Report] Report with lock statistics
-      def locks
-        data = executor.execute_from_file(:connections, :locks)
-
-        Report.new(
-          title: "Current Locks",
-          data: data,
-          columns: %w[pid database relation locktype mode granted waiting]
-        )
-      end
-
-      # Idle connections
-      # @return [Report] Report with idle connections
-      def idle_connections
-        data = executor.execute_from_file(:connections, :idle_connections)
-
-        Report.new(
-          title: "Idle Connections",
-          data: data,
-          columns: %w[pid database username application idle_duration state_change]
-        )
-      end
+      # The following methods are auto-generated from YAML:
+      # - active_connections
+      # - connection_stats
+      # - long_running_queries(min_duration_seconds: 60)
+      # - blocking_queries
+      # - locks
+      # - idle_connections
 
       # Kill a specific backend process
       # @param pid [Integer] Process ID to terminate

data/lib/pg_reports/modules/indexes.rb

@@ -3,103 +3,18 @@
 module PgReports
   module Modules
     # Index analysis module
+    # All report methods are generated from YAML definitions in lib/pg_reports/definitions/indexes/
     module Indexes
       extend self
 
-      # Unused indexes - indexes that are rarely or never scanned
-      # @return [Report] Report with unused indexes
-      def unused_indexes(limit: 50)
-        data = executor.execute_from_file(:indexes, :unused_indexes)
-        threshold = PgReports.config.unused_index_threshold_scans
-
-        filtered = data.select { |row| row["idx_scan"].to_i <= threshold }
-          .first(limit)
-
-        Report.new(
-          title: "Unused Indexes (scans <= #{threshold})",
-          data: filtered,
-          columns: %w[schema table_name index_name idx_scan index_size_mb]
-        )
-      end
-
-      # Duplicate indexes - indexes that may be redundant
-      # @return [Report] Report with duplicate indexes
-      def duplicate_indexes
-        data = executor.execute_from_file(:indexes, :duplicate_indexes)
-
-        Report.new(
-          title: "Duplicate Indexes",
-          data: data,
-          columns: %w[table_name index_name duplicate_of index_size_mb]
-        )
-      end
-
-      # Invalid indexes - indexes that are not valid (e.g., failed to build)
-      # @return [Report] Report with invalid indexes
-      def invalid_indexes
-        data = executor.execute_from_file(:indexes, :invalid_indexes)
-
-        Report.new(
-          title: "Invalid Indexes",
-          data: data,
-          columns: %w[schema table_name index_name index_definition]
-        )
-      end
-
-      # Missing indexes - tables with high sequential scans
-      # @return [Report] Report suggesting missing indexes
-      def missing_indexes(limit: 20)
-        data = executor.execute_from_file(:indexes, :missing_indexes)
-          .first(limit)
-
-        Report.new(
-          title: "Tables Potentially Missing Indexes",
-          data: data,
-          columns: %w[schema table_name seq_scan seq_tup_read idx_scan table_size_mb]
-        )
-      end
-
-      # Index usage statistics
-      # @return [Report] Report with index usage statistics
-      def index_usage(limit: 50)
-        data = executor.execute_from_file(:indexes, :index_usage)
-          .first(limit)
-
-        Report.new(
-          title: "Index Usage Statistics",
-          data: data,
-          columns: %w[schema table_name index_name idx_scan idx_tup_read index_size_mb]
-        )
-      end
-
-      # Bloated indexes - indexes with high bloat
-      # @return [Report] Report with bloated indexes
-      def bloated_indexes(limit: 20)
-        data = executor.execute_from_file(:indexes, :bloated_indexes)
-        threshold = PgReports.config.bloat_threshold_percent
-
-        filtered = data.select { |row| row["bloat_percent"].to_f >= threshold }
-          .first(limit)
-
-        Report.new(
-          title: "Bloated Indexes (bloat >= #{threshold}%)",
-          data: filtered,
-          columns: %w[schema table_name index_name index_size_mb bloat_size_mb bloat_percent]
-        )
-      end
-
-      # Index sizes
-      # @return [Report] Report with index sizes
-      def index_sizes(limit: 50)
-        data = executor.execute_from_file(:indexes, :index_sizes)
-          .first(limit)
-
-        Report.new(
-          title: "Index Sizes (top #{limit})",
-          data: data,
-          columns: %w[schema table_name index_name index_size_mb]
-        )
-      end
+      # The following methods are auto-generated from YAML:
+      # - unused_indexes(limit: 50)
+      # - duplicate_indexes
+      # - invalid_indexes
+      # - missing_indexes(limit: 20)
+      # - index_usage(limit: 50)
+      # - bloated_indexes(limit: 20)
+      # - index_sizes(limit: 50)
 
       private