pg_reports 0.6.2 → 0.8.0

data/lib/pg_reports/grafana/exporter.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module PgReports
+  module Grafana
+    # Renders selected reports in Prometheus exposition format.
+    # Severity is derived from REPORT_CONFIG thresholds in Dashboard::ReportsRegistry.
+    class Exporter
+      SEVERITY_ORDER = {"ok" => 0, "warning" => 1, "critical" => 2}.freeze
+      MAX_LABEL_VALUE_LENGTH = 200
+      RESERVED_LABEL_NAMES = %w[report severity row error].freeze
+
+      MODULES = {
+        queries: -> { Modules::Queries },
+        indexes: -> { Modules::Indexes },
+        tables: -> { Modules::Tables },
+        connections: -> { Modules::Connections },
+        system: -> { Modules::System },
+        schema_analysis: -> { Modules::SchemaAnalysis }
+      }.freeze
+
+      def self.render
+        new.render
+      end
+
+      def initialize(favorites: PgReports.config.grafana_favorites,
+        cache_ttl: PgReports.config.grafana_cache_ttl,
+        clock: Time)
+        @favorites = normalize(favorites)
+        @cache_ttl = cache_ttl
+        @clock = clock
+      end
+
+      def render
+        results = @favorites.map { |key, opts| collect(key, opts) }
+
+        lines = []
+        emit(lines, "pg_reports_issues", "Number of rows by severity for the report") do |emit|
+          results.each do |r|
+            next unless r[:ok]
+            r[:severities].each { |sev, count| emit.call({report: r[:key], severity: sev}, count) }
+          end
+        end
+
+        emit(lines, "pg_reports_rows", "Total rows returned by the report") do |emit|
+          results.each { |r| emit.call({report: r[:key]}, r[:rows]) if r[:ok] }
+        end
+
+        emit(lines, "pg_reports_run_seconds", "Time spent collecting the report") do |emit|
+          results.each { |r| emit.call({report: r[:key]}, r[:duration].round(4)) if r[:ok] }
+        end
+
+        emit(lines, "pg_reports_last_run_timestamp", "Unix timestamp of last collection") do |emit|
+          results.each { |r| emit.call({report: r[:key]}, r[:timestamp]) if r[:ok] }
+        end
+
+        emit(lines, "pg_reports_up", "Whether collection succeeded (1) or failed (0)") do |emit|
+          results.each do |r|
+            labels = {report: r[:key]}
+            labels[:error] = r[:error] unless r[:ok]
+            emit.call(labels, r[:ok] ? 1 : 0)
+          end
+        end
+
+        emit(lines, "pg_reports_row", "One series per row of the report (drives Grafana table panels). Each row column becomes a label.") do |emit|
+          results.each do |r|
+            next unless r[:ok] && r[:rows_data]
+            r[:rows_data].each_with_index do |row_labels, idx|
+              emit.call(row_labels.merge(report: r[:key], row: idx), 1)
+            end
+          end
+        end
+
+        (lines << "").join("\n")
+      end
+
+      private
+
+      def normalize(favorites)
+        case favorites
+        when Hash
+          favorites.each_with_object({}) { |(k, v), h| h[k.to_sym] = (v || {}).symbolize_keys }
+        when Array
+          favorites.each_with_object({}) { |k, h| h[k.to_sym] = {} }
+        else
+          {}
+        end
+      end
+
+      def collect(key, opts)
+        cached(key, opts) { run(key, opts) }
+      rescue => e
+        {key: key, ok: false, error: e.class.name, message: e.message}
+      end
+
+      def cached(key, opts)
+        ttl = opts[:ttl] || @cache_ttl
+        if ttl && defined?(Rails) && Rails.respond_to?(:cache) && Rails.cache
+          Rails.cache.fetch("pg_reports/grafana/#{key}", expires_in: ttl) { yield }
+        else
+          yield
+        end
+      end
+
+      def run(key, opts)
+        mod = module_for(key) or raise ArgumentError, "Unknown report: #{key}"
+
+        started = @clock.now
+        report = mod.public_send(key, **report_args(opts))
+        finished = @clock.now
+
+        {
+          key: key,
+          ok: true,
+          rows: report.size,
+          severities: severity_counts(key, report),
+          rows_data: opts.fetch(:expose_rows, true) ? row_label_sets(report) : nil,
+          duration: finished - started,
+          timestamp: finished.to_i
+        }
+      end
+
+      def row_label_sets(report)
+        report.map { |row| row_to_labels(row) }
+      end
+
+      def row_to_labels(row)
+        labels = {}
+        row.each do |column, value|
+          next if value.nil?
+
+          name = sanitize_label_name(column.to_s)
+          next if name.empty? || RESERVED_LABEL_NAMES.include?(name)
+
+          formatted = format_label_value(value)
+          next if formatted.length > MAX_LABEL_VALUE_LENGTH
+
+          labels[name] = formatted
+        end
+        labels
+      end
+
+      def sanitize_label_name(name)
+        cleaned = name.gsub(/[^a-zA-Z0-9_]/, "_")
+        cleaned = "_#{cleaned}" if cleaned.match?(/\A[0-9]/)
+        cleaned
+      end
+
+      def format_label_value(value)
+        case value
+        when Float then format("%g", value)
+        when Time, DateTime then value.iso8601
+        else value.to_s
+        end
+      end
+
+      def module_for(key)
+        Dashboard::ReportsRegistry::REPORTS.each do |category, info|
+          next unless info[:reports].key?(key.to_sym)
+          factory = MODULES[category] or return nil
+          return factory.call
+        end
+        nil
+      end
+
+      def report_args(opts)
+        # Only forward kwargs that report methods accept; keep the surface tiny.
+        opts.slice(:limit).compact
+      end
+
+      def severity_counts(key, report)
+        thresholds = Dashboard::ReportsRegistry.thresholds(key)
+        counts = Hash.new(0)
+
+        if thresholds.empty?
+          counts["ok"] = report.size
+          return counts
+        end
+
+        report.each { |row| counts[row_severity(row, thresholds)] += 1 }
+        counts
+      end
+
+      def row_severity(row, thresholds)
+        worst = "ok"
+        thresholds.each do |field, t|
+          value = row[field.to_s] || row[field]
+          next if value.nil?
+
+          worst = max_severity(worst, severity_for(value.to_f, t))
+        end
+        worst
+      end
+
+      def severity_for(value, thresholds)
+        critical = thresholds[:critical]
+        warning = thresholds[:warning]
+
+        if thresholds[:inverted]
+          return "critical" if critical && value <= critical
+          return "warning" if warning && value <= warning
+        else
+          return "critical" if critical && value >= critical
+          return "warning" if warning && value >= warning
+        end
+        "ok"
+      end
+
+      def max_severity(a, b)
+        (SEVERITY_ORDER[a] >= SEVERITY_ORDER[b]) ? a : b
+      end
+
+      def emit(lines, metric, help)
+        buffer = []
+        emitter = ->(labels, value) {
+          buffer << "#{metric}#{format_labels(labels)} #{value}"
+        }
+        yield emitter
+        return if buffer.empty?
+
+        lines << "# HELP #{metric} #{help}"
+        lines << "# TYPE #{metric} gauge"
+        lines.concat(buffer)
+      end
+
+      def format_labels(labels)
+        return "" if labels.nil? || labels.empty?
+
+        pairs = labels.map { |k, v| %(#{k}="#{escape_label(v)}") }
+        "{#{pairs.join(",")}}"
+      end
+
+      def escape_label(value)
+        value.to_s
+          .gsub("\\", "\\\\\\\\")
+          .gsub('"', '\\"')
+          .gsub("\n", '\\n')
+      end
+    end
+  end
+end

data/lib/pg_reports/module_generator.rb

@@ -3,42 +3,43 @@
 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)
+    class << self
+      def 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
-    end
 
-    private
+      private
 
-    def self.get_module(module_name)
-      const_name = module_name.to_s.split("_").map(&:capitalize).join
-      PgReports::Modules.const_get(const_name)
-    rescue NameError
-      # Module doesn't exist, skip it
-      # We don't auto-create modules to avoid conflicts
-      nil
-    end
+      def get_module(module_name)
+        const_name = module_name.to_s.split("_").map(&:capitalize).join
+        PgReports::Modules.const_get(const_name)
+      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"] || {}
+      def 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"] }
+        # 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
+        # Capture definition + defaults so the singleton method closes over them
+        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)
+        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/schema_analysis.rb

@@ -112,7 +112,7 @@ module PgReports
           counter_belongs_to(model).each do |assoc|
             counter_col = counter_cache_column_name(model, assoc)
             parent = parent_class_for(assoc)
-            next unless parent && parent.table_exists?
+            next unless parent&.table_exists?
 
             unless parent.column_names.include?(counter_col)
               results << {

data/lib/pg_reports/modules/system.rb

@@ -173,7 +173,10 @@ module PgReports
       private
 
       def pg_version
-        @pg_version ||= begin
+        # Cache per-connection so switching targets/databases re-resolves the version.
+        cache = (Thread.current[:pg_reports_pg_version_cache] ||= {})
+        key = executor.connection.object_id
+        cache[key] ||= begin
           result = executor.execute("SELECT current_setting('server_version_num')::int AS v")
           result.first&.fetch("v", 0).to_i
         end

data/lib/pg_reports/query_monitor.rb

@@ -290,13 +290,16 @@ module PgReports
         # when gem is installed from RubyGems
         next if path.include?("/query_monitor.rb")
 
-        # Filter queries from pg_reports internal modules only:
-        # - Installed gem: /gems/pg_reports-X.Y.Z/lib/
-        # - Local gem: /pg_reports/lib/pg_reports/modules/
-        # Note: We intentionally DO NOT filter dashboard_controller.rb
-        # to allow monitoring of user application queries made during dashboard page loads
-        path.match?(%r{/gems/pg_reports[-\d.]+/lib/}) ||
-          path.match?(%r{/pg_reports/lib/pg_reports/modules/})
+        # Filter queries from pg_reports internal code:
+        # - Installed gem: /gems/pg_reports-X.Y.Z/lib/ or /gems/pg_reports-X.Y.Z/app/
+        # - Local gem: /pg_reports/lib/pg_reports/ or /pg_reports/app/(controllers|views)/pg_reports/
+        # This includes the dashboard controller's own SQL execution endpoints
+        # (execute_query, explain_analyze) which call AR directly without going
+        # through Executor — without this match nothing in the caller stack
+        # would identify the query as ours.
+        path.match?(%r{/gems/pg_reports[-\d.]+/(lib|app)/}) ||
+          path.match?(%r{/pg_reports/lib/pg_reports/}) ||
+          path.match?(%r{/pg_reports/app/(controllers|views)/pg_reports/})
       end
     end
 

data/lib/pg_reports/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgReports
-  VERSION = "0.6.2"
+  VERSION = "0.8.0"
 end

data/lib/pg_reports.rb

@@ -6,6 +6,9 @@ require "active_record"
 
 require_relative "pg_reports/version"
 require_relative "pg_reports/error"
+require_relative "pg_reports/connection/target"
+require_relative "pg_reports/connection/registry"
+require_relative "pg_reports/connection/error_translator"
 require_relative "pg_reports/compatibility"
 require_relative "pg_reports/configuration"
 require_relative "pg_reports/sql_loader"
@@ -33,6 +36,10 @@ require_relative "pg_reports/modules/schema_analysis"
 # Dashboard
 require_relative "pg_reports/dashboard/reports_registry"
 
+# Grafana / Prometheus exporter
+require_relative "pg_reports/grafana/exporter"
+require_relative "pg_reports/grafana/dashboard_builder"
+
 # Rails Engine
 require_relative "pg_reports/engine" if defined?(Rails::Engine)
 
@@ -134,6 +141,56 @@ module PgReports
       ReportLoader.reload!
       ModuleGenerator.generate!
     end
+
+    # Connection registry — multi-target / multi-database support.
+    # The :primary target is auto-discovered from ActiveRecord on first access.
+    def connection_registry
+      @connection_registry ||= Connection::Registry.new
+    end
+
+    # Run a block against a specific target (and optionally a specific database
+    # on that target). Honored by Executor and any code routing through
+    # PgReports.config.connection.
+    #
+    #   PgReports.with_target(:analytics) { PgReports.slow_queries }
+    #   PgReports.with_target(:primary, database: "logs") { PgReports.table_sizes }
+    def with_target(name, database: nil, &block)
+      connection_registry.with_context(target: name, database: database, &block)
+    end
+
+    # Switch only the database on whatever target is currently active
+    # (defaults to the registry's default target).
+    #
+    #   PgReports.with_database("reporting") { PgReports.database_sizes }
+    def with_database(database, &block)
+      target = connection_registry.current_name || connection_registry.default_name
+      connection_registry.with_context(target: target, database: database, &block)
+    end
+
+    # Name of the currently effective target (taking with_target into account).
+    def current_target_name
+      connection_registry.current_name || connection_registry.default_name
+    end
+
+    # Name of the currently effective database (taking with_database into account).
+    def current_database_name
+      connection_registry.current_database_name
+    end
+
+    # List databases on the currently active target's cluster.
+    # Each row: { "name" => String, "size" => String, "current" => Boolean }
+    def list_databases
+      target = connection_registry.fetch
+      target.list_databases(current: current_database_name)
+    end
+
+    # List of registered targets, each as { name:, default_database:, current: }.
+    def list_targets
+      current = current_target_name
+      connection_registry.targets.map do |t|
+        {name: t.name, default_database: t.default_database, current: t.name == current}
+      end
+    end
   end
 end
 

data/lib/tasks/pg_reports.rake

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "json"
+
+namespace :pg_reports do
+  namespace :grafana do
+    desc "Write importable Grafana dashboard JSON for the configured grafana_favorites. " \
+         "Defaults to pg_reports.json in pwd. Override with OUTPUT=, FAVORITES=, TITLE=, UID=, REFRESH=, TIME_FROM=."
+    task dashboard: :environment do
+      favorites = if ENV["FAVORITES"]
+        ENV["FAVORITES"].split(",").map { |k| k.strip.to_sym }
+      else
+        PgReports.config.grafana_favorites
+      end
+
+      builder = PgReports::Grafana::DashboardBuilder.new(
+        favorites: favorites,
+        title: ENV.fetch("TITLE", PgReports::Grafana::DashboardBuilder::DEFAULT_TITLE),
+        uid: ENV.fetch("UID", PgReports::Grafana::DashboardBuilder::DEFAULT_UID),
+        refresh: ENV.fetch("REFRESH", "1m"),
+        time_from: ENV.fetch("TIME_FROM", "now-6h")
+      )
+
+      output_path = ENV.fetch("OUTPUT", "pg_reports.json")
+      File.write(output_path, JSON.pretty_generate(builder.build))
+      warn "Wrote #{output_path}"
+    end
+
+    desc "Write the current /metrics payload to a file. Defaults to pg_reports.metrics in pwd. Override with OUTPUT=."
+    task metrics: :environment do
+      output_path = ENV.fetch("OUTPUT", "pg_reports.metrics")
+      File.write(output_path, PgReports::Grafana::Exporter.render)
+      warn "Wrote #{output_path}"
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_reports
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.8.0
 platform: ruby
 authors:
 - Eldar Avatov
@@ -148,11 +148,14 @@ files:
 - LICENSE.txt
 - README.md
 - app/controllers/pg_reports/dashboard_controller.rb
+- app/controllers/pg_reports/metrics_controller.rb
 - app/views/layouts/pg_reports/application.html.erb
+- app/views/pg_reports/dashboard/_database_selector.html.erb
 - app/views/pg_reports/dashboard/_fake_source_data.html.erb
 - app/views/pg_reports/dashboard/_show_modals.html.erb
 - app/views/pg_reports/dashboard/_show_scripts.html.erb
 - app/views/pg_reports/dashboard/_show_styles.html.erb
+- app/views/pg_reports/dashboard/_target_selector.html.erb
 - app/views/pg_reports/dashboard/index.html.erb
 - app/views/pg_reports/dashboard/show.html.erb
 - config/locales/en.yml
@@ -163,6 +166,9 @@ files:
 - lib/pg_reports/annotation_parser.rb
 - lib/pg_reports/compatibility.rb
 - lib/pg_reports/configuration.rb
+- lib/pg_reports/connection/error_translator.rb
+- lib/pg_reports/connection/registry.rb
+- lib/pg_reports/connection/target.rb
 - lib/pg_reports/dashboard/reports_registry.rb
 - lib/pg_reports/definitions/connections/active_connections.yml
 - lib/pg_reports/definitions/connections/blocking_queries.yml
@@ -214,6 +220,8 @@ files:
 - lib/pg_reports/executor.rb
 - lib/pg_reports/explain_analyzer.rb
 - lib/pg_reports/filter.rb
+- lib/pg_reports/grafana/dashboard_builder.rb
+- lib/pg_reports/grafana/exporter.rb
 - lib/pg_reports/module_generator.rb
 - lib/pg_reports/modules/connections.rb
 - lib/pg_reports/modules/indexes.rb
@@ -278,6 +286,7 @@ files:
 - lib/pg_reports/sql_loader.rb
 - lib/pg_reports/telegram_sender.rb
 - lib/pg_reports/version.rb
+- lib/tasks/pg_reports.rake
 homepage: https://github.com/deadalice/pg_reports
 licenses:
 - MIT