pg_reports 0.7.0 → 0.8.0

data/lib/pg_reports/connection/target.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module PgReports
+  module Connection
+    # Represents a single named PostgreSQL target (host+credentials).
+    # Holds a memoized AR-subclass-backed connection per database it has been
+    # asked for, so switching between databases on the same target reuses pools.
+    #
+    # The :primary target wraps ActiveRecord::Base directly when accessed at its
+    # default database — we don't open a parallel pool to the host app's DB.
+    # For non-default databases we create an isolated AR subclass that has its
+    # own pool, so the host application's pool is never affected.
+    class Target
+      class ConnectionFailed < PgReports::Error; end
+
+      attr_reader :name
+
+      def initialize(name, spec)
+        @name = name.to_sym
+        @spec = normalize_spec(spec)
+        @pools = {} # database (string) => AR class
+      end
+
+      # Configuration hash used as a template for derived databases.
+      def spec
+        @spec.dup
+      end
+
+      def default_database
+        @spec[:database]&.to_s
+      end
+
+      # Resolve the AR class backing the connection for `database` (nil = default).
+      # Returns a class responding to `.connection` (ActiveRecord::Base or subclass).
+      def ar_class_for(database = nil)
+        db = (database || default_database).to_s
+        raise ArgumentError, "Cannot resolve connection: target #{name.inspect} has no default database and none was given" if db.empty?
+
+        @pools[db] ||= build_pool_class(db)
+      end
+
+      # Returns the active PG connection for `database`, opening it if needed.
+      def connection_for(database = nil)
+        ar_class_for(database).connection
+      rescue ActiveRecord::NoDatabaseError, PG::ConnectionBad => e
+        raise ConnectionFailed, "Cannot connect to #{name}/#{database || default_database}: #{e.message}"
+      end
+
+      # List all databases visible on this target's cluster (using pg_database).
+      # Result rows: { "name" => String, "size" => String, "current" => Boolean }
+      def list_databases(current: nil)
+        rows = connection_for.exec_query(<<~SQL).to_a
+          SELECT datname AS name,
+                 pg_size_pretty(pg_database_size(datname)) AS size
+          FROM pg_database
+          WHERE datistemplate = false AND datallowconn = true
+          ORDER BY datname
+        SQL
+        current_db = (current || default_database).to_s
+        rows.each { |r| r["current"] = (r["name"].to_s == current_db) }
+        rows
+      end
+
+      # Close all derived pools we own. The :primary AR::Base pool is never touched.
+      def disconnect!
+        @pools.each_value do |klass|
+          next if klass.equal?(ActiveRecord::Base)
+          klass.connection_pool.disconnect! if klass.connection_pool.connected?
+        rescue
+          # Best-effort cleanup
+        end
+        @pools.clear
+      end
+
+      private
+
+      def normalize_spec(spec)
+        hash = case spec
+        when Hash
+          spec.transform_keys(&:to_sym)
+        when ActiveRecord::DatabaseConfigurations::HashConfig
+          spec.configuration_hash.transform_keys(&:to_sym)
+        else
+          raise ArgumentError, "Unsupported spec type: #{spec.class}"
+        end
+
+        # Ensure adapter defaults to postgresql; we only support PG.
+        hash[:adapter] ||= "postgresql"
+        hash
+      end
+
+      def build_pool_class(database)
+        # When asked for the primary target's default database, reuse AR::Base
+        # so we don't open a parallel pool to the same DB the host app uses.
+        if name == :primary && database == default_database
+          return ActiveRecord::Base
+        end
+
+        klass = Class.new(ActiveRecord::Base) { self.abstract_class = true }
+        const_name = "Pool_#{name}_#{database}".gsub(/\W/, "_")
+        if PgReports::Connection.const_defined?(const_name, false)
+          PgReports::Connection.send(:remove_const, const_name)
+        end
+        PgReports::Connection.const_set(const_name, klass)
+
+        klass.establish_connection(@spec.merge(database: database))
+        klass
+      end
+    end
+  end
+end

data/lib/pg_reports/dashboard/reports_registry.rb

@@ -277,8 +277,8 @@ module PgReports
             seq_scans: {name: "Sequential Scans", description: "Tables with high sequential scans"},
             tables_without_pk: {name: "No Primary Key", description: "Tables missing primary keys"},
             recently_modified: {name: "Recently Modified", description: "Tables with recent activity"},
-            update_hotspots: {name: "Update Hotspots", description: "Same rows or indexed columns updated repeatedly", new: true},
-            unused_tables: {name: "Unused Tables", description: "Tables never queried since the last stats reset", new: true}
+            update_hotspots: {name: "Update Hotspots", description: "Same rows or indexed columns updated repeatedly"},
+            unused_tables: {name: "Unused Tables", description: "Tables never queried since the last stats reset"}
           }
         },
         connections: {
@@ -316,14 +316,19 @@ module PgReports
           name: "Schema Analysis",
           icon: "🔍",
           color: "#06b6d4",
+          # These reports introspect the host application's ActiveRecord models,
+          # which are bound to the default database. Running them against a
+          # different database in the cluster returns rows that may not map to
+          # any model. The dashboard greys the category out in that case.
+          target_constraint: :primary_default_database_only,
           reports: {
             missing_validations: {name: "Missing Validations", description: "Unique indexes without model validations"},
-            unused_columns: {name: "Unused Columns", description: "Columns that have only ever held a single value", new: true},
-            always_null_columns: {name: "Always-NULL Columns", description: "Nullable columns that contain only NULL", new: true},
-            polymorphic_without_index: {name: "Polymorphic Without Index", description: "Polymorphic associations missing composite index", new: true},
-            counter_cache_issues: {name: "Counter Cache Issues", description: "counter_cache declarations whose target column is missing", new: true},
-            soft_delete_without_scope: {name: "Soft Delete Without Scope", description: "Soft-delete columns with no model scope filtering them", new: true},
-            orphan_tables: {name: "Orphan Tables", description: "DB tables without a corresponding Rails model", new: true}
+            unused_columns: {name: "Unused Columns", description: "Columns that have only ever held a single value"},
+            always_null_columns: {name: "Always-NULL Columns", description: "Nullable columns that contain only NULL"},
+            polymorphic_without_index: {name: "Polymorphic Without Index", description: "Polymorphic associations missing composite index"},
+            counter_cache_issues: {name: "Counter Cache Issues", description: "counter_cache declarations whose target column is missing"},
+            soft_delete_without_scope: {name: "Soft Delete Without Scope", description: "Soft-delete columns with no model scope filtering them"},
+            orphan_tables: {name: "Orphan Tables", description: "DB tables without a corresponding Rails model"}
           }
         }
       }.freeze
@@ -398,6 +403,15 @@ module PgReports
       def self.problem_fields(report)
         REPORT_CONFIG.dig(report.to_sym, :problem_fields) || []
       end
+
+      # Returns the target constraint declared on a category, or nil.
+      # Currently the only constraint is :primary_default_database_only, which
+      # means "only meaningful when the dashboard is pointing at the host app's
+      # primary target on its default database" — used by Schema Analysis,
+      # which depends on ActiveRecord::Base.descendants of the host app.
+      def self.target_constraint(category)
+        REPORTS.dig(category.to_sym, :target_constraint)
+      end
     end
   end
 end

data/lib/pg_reports/executor.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
 module PgReports
-  # Executes SQL queries and returns results
+  # Executes SQL queries and returns results.
+  #
+  # The connection is resolved lazily on every #execute call so that thread-local
+  # context set by PgReports.with_target / with_database is honored even when an
+  # Executor instance has been memoized at the module level.
   class Executor
     def initialize(connection: nil)
-      @connection = connection || PgReports.config.connection
+      @connection_override = connection
     end
 
     # Execute SQL from a file and return results as array of hashes
@@ -16,10 +20,15 @@ module PgReports
     # Execute raw SQL and return results as array of hashes
     def execute(sql, **params)
       processed_sql = interpolate_params(sql, params)
-      result = @connection.exec_query(processed_sql)
+      result = connection.exec_query(processed_sql)
       result.to_a
     end
 
+    # Resolved on every call: explicit override > thread-local > registry default.
+    def connection
+      @connection_override || PgReports.config.connection
+    end
+
     private
 
     # Simple parameter interpolation for SQL
@@ -40,11 +49,11 @@ module PgReports
       when Integer, Float
         value.to_s
       when String
-        @connection.quote(value)
+        connection.quote(value)
       when Array
         "(#{value.map { |v| quote_value(v) }.join(", ")})"
       else
-        @connection.quote(value.to_s)
+        connection.quote(value.to_s)
       end
     end
   end

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.7.0"
+  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"
@@ -138,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
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_reports
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Eldar Avatov
@@ -150,10 +150,12 @@ files:
 - 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
@@ -164,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
@@ -289,16 +294,6 @@ metadata:
   homepage_uri: https://github.com/deadalice/pg_reports
   source_code_uri: https://github.com/deadalice/pg_reports
   changelog_uri: https://github.com/deadalice/pg_reports/blob/main/CHANGELOG.md
-post_install_message: |
-  Thanks for installing pg_reports v0.7.0!
-
-  New in 0.7.0 — experimental Grafana / Prometheus support
-  ────────────────────────────────────────────────────────
-  Expose selected reports at <mount_point>/metrics in Prometheus exposition
-  format and import a ready-to-use Grafana dashboard:
-
-  Setup guide:
-    https://github.com/deadalice/pg_reports/blob/main/docs/grafana.md
 rdoc_options: []
 require_paths:
 - lib