pg_reports 0.7.0 → 0.8.1

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, "PgReports").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
@@ -13,13 +17,23 @@ module PgReports
       execute(sql, **params)
     end
 
-    # Execute raw SQL and return results as array of hashes
+    # Execute raw SQL and return results as array of hashes.
+    #
+    # Every query is tagged with the "PgReports" AR statement name so the Query
+    # Monitor can skip our own queries by name (see QueryMonitor#should_skip?),
+    # reliably and independent of backtrace depth — the internal live_metrics /
+    # status polling would otherwise leak into the monitor's history.
     def execute(sql, **params)
       processed_sql = interpolate_params(sql, params)
-      result = @connection.exec_query(processed_sql)
+      result = connection.exec_query(processed_sql, "PgReports")
       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 +54,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

@@ -44,13 +44,37 @@ module PgReports
         false
       end
 
-      # Get pg_stat_statements status details
+      # Whether the database connection can execute a basic query.
+      # Used to tell "the connection itself is down" apart from
+      # "connected, but pg_stat_statements isn't set up yet".
+      # @return [Boolean]
+      def connected?
+        executor.execute("SELECT 1")
+        true
+      rescue
+        false
+      end
+
+      # Get pg_stat_statements status details.
+      #
+      # Note: whether pg_stat_statements is in shared_preload_libraries cannot be
+      # read by a plain monitoring role (that requires the pg_read_all_settings
+      # role), so we never look at the setting. Instead we derive the state from
+      # signals every role can observe: can we run a query at all, does the
+      # extension exist in pg_extension, and is its view queryable.
+      #
       # @return [Hash] Status information
       def pg_stat_statements_status
+        unless connected?
+          return {connected: false, extension_installed: false, preloaded: false, ready: false}
+        end
+
+        installed = pg_stat_statements_available?
         {
-          extension_installed: pg_stat_statements_available?,
+          connected: true,
+          extension_installed: installed,
           preloaded: pg_stat_statements_preloaded?,
-          ready: pg_stat_statements_available? && pg_stat_statements_preloaded?
+          ready: installed && pg_stat_statements_preloaded?
         }
       end
 
@@ -58,7 +82,7 @@ module PgReports
       # @param long_query_threshold [Integer] Threshold in seconds for long queries
       # @return [Hash] Metrics data
       # @raise [StandardError] If no data is returned
-      def live_metrics(long_query_threshold: 60)
+      def live_metrics(long_query_threshold: 5)
         data = executor.execute_from_file(:system, :live_metrics,
           long_query_threshold: long_query_threshold)
 
@@ -173,7 +197,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/standalone.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module PgReports
+  # Runs the dashboard as a self-contained application, without a host Rails app.
+  #
+  # It boots a minimal Rails::Application that mounts PgReports::Engine and points
+  # ActiveRecord::Base at a PostgreSQL database, then serves it over HTTP. This is
+  # what powers the `pg_reports server` executable and the `pg_reports:server`
+  # rake task, so the project can be launched straight from the gem's root folder.
+  #
+  # Dependency note: this relies only on gems already pulled in transitively by
+  # the gem's runtime deps (rack via actionpack, rackup via railties). The actual
+  # web server (puma / webrick) is resolved at run time and is NOT a hard
+  # dependency — installed-gem users bring their own.
+  module Standalone
+    extend self
+
+    DEFAULT_PORT = 4000
+    DEFAULT_HOST = "127.0.0.1"
+    DEFAULT_MOUNT = "/"
+
+    # Rack handlers tried, in order, when none is named explicitly.
+    CANDIDATE_SERVERS = %w[puma webrick].freeze
+
+    class ServerUnavailable < PgReports::Error; end
+
+    # Boot the app and start a (blocking) web server.
+    #
+    # @param port [Integer]
+    # @param host [String]
+    # @param mount_path [String] where the engine is mounted (default "/")
+    # @param database_url [String, nil] explicit connection URL; otherwise resolved
+    #   from DATABASE_URL or libpq-style PG* env vars
+    # @param server [String, nil] Rack handler name to force (e.g. "puma")
+    def run(port: DEFAULT_PORT, host: DEFAULT_HOST, mount_path: DEFAULT_MOUNT,
+      database_url: nil, server: nil)
+      # Rails' ActiveRecord railtie reads the connection from DATABASE_URL when no
+      # config/database.yml exists — so we route our resolved connection through
+      # it. The connection registry then auto-registers it as the :primary target,
+      # and database switching / multi-cluster all work unchanged.
+      ENV["DATABASE_URL"] = connection_url(database_url)
+
+      app = build_application(mount_path)
+      app.initialize!
+      verify_connection!
+
+      handler_name, handler = resolve_server(server)
+      banner(host: host, port: port, server: handler_name)
+      handler.run(app, Host: host, Port: port)
+    end
+
+    # Resolve the connection URL. Priority: explicit url > DATABASE_URL >
+    # libpq-style PG* env vars (PGHOST/PGPORT/PGUSER/PGPASSWORD/PGDATABASE).
+    def connection_url(explicit = nil)
+      return explicit if explicit && !explicit.empty?
+      return ENV["DATABASE_URL"] if ENV["DATABASE_URL"] && !ENV["DATABASE_URL"].empty?
+
+      require "erb"
+      user = ENV["PGUSER"] || ENV["USER"]
+      password = ENV["PGPASSWORD"]
+      host = ENV["PGHOST"] || "localhost"
+      port = ENV["PGPORT"] || 5432
+      database = ENV["PGDATABASE"] || "postgres"
+
+      userinfo = +""
+      if user && !user.empty?
+        userinfo << ERB::Util.url_encode(user)
+        userinfo << ":#{ERB::Util.url_encode(password)}" if password && !password.empty?
+        userinfo << "@"
+      end
+
+      "postgresql://#{userinfo}#{host}:#{port}/#{ERB::Util.url_encode(database)}"
+    end
+
+    private
+
+    # Build (and register as Rails.application) a minimal Rails app that mounts
+    # the engine. Kept intentionally small: no asset pipeline (views are inline),
+    # cookie sessions for the dashboard's database selector + CSRF.
+    def build_application(mount_path)
+      require "rails"
+      require "action_controller/railtie"
+      require "active_record/railtie"
+      require "tmpdir"
+      # pg_reports.rb only requires the engine when Rails::Engine is already
+      # defined; when loaded outside a Rails app that guard was false, so load it
+      # now that the railties are present. This also registers its initializers.
+      require "pg_reports/engine"
+
+      target_mount = mount_path
+      # A throwaway, empty app root. We must NOT use the gem root here — Rails
+      # would then load the gem's engine config/routes.rb (and config/locales) as
+      # the *application's* own, which double-loads and breaks. The engine loads
+      # those itself relative to its own root; the app only needs the mount below.
+      app_root = Dir.mktmpdir("pg_reports-standalone")
+      at_exit { FileUtils.remove_entry(app_root, true) }
+
+      Class.new(Rails::Application) do
+        config.root = app_root
+        config.eager_load = false
+        config.consider_all_requests_local = true
+        config.secret_key_base = ENV["SECRET_KEY_BASE"] || SecureRandom.hex(64)
+        config.session_store :cookie_store, key: "_pg_reports_session"
+        config.hosts.clear # local tool: don't block by Host header
+        config.logger = ::Logger.new($stdout)
+        config.log_level = (ENV["LOG_LEVEL"] || "info").to_sym
+        config.active_support.report_deprecations = false
+
+        routes.append do
+          mount PgReports::Engine, at: target_mount, as: "pg_reports"
+        end
+      end
+    end
+
+    # Force an actual connection so the user gets a clear error at startup rather
+    # than a 500 on the first request when the database is unreachable.
+    def verify_connection!
+      ActiveRecord::Base.connection
+    rescue => e
+      raise PgReports::Error, "Cannot connect to the database (#{ENV["DATABASE_URL"]}): #{e.message}"
+    end
+
+    # Find a usable Rack handler. Honors an explicit name, otherwise tries the
+    # candidates in order and uses the first that is installed.
+    def resolve_server(name)
+      require "rackup"
+
+      candidates = name ? [name] : CANDIDATE_SERVERS
+      candidates.each do |candidate|
+        handler = begin
+          Rackup::Handler.get(candidate)
+        rescue LoadError, NameError
+          nil
+        end
+        return [candidate, handler] if handler
+      end
+
+      raise ServerUnavailable, <<~MSG.strip
+        No web server found (tried: #{candidates.join(", ")}).
+        Add one to run the standalone dashboard, e.g. `gem install puma`
+        (or add `gem "puma"` to your Gemfile).
+      MSG
+    end
+
+    def banner(host:, port:, server:)
+      url_host = (host == "0.0.0.0") ? "localhost" : host
+      warn "pg_reports: serving dashboard via #{server} on http://#{url_host}:#{port} (Ctrl-C to stop)"
+    end
+  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.1"
 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"
@@ -40,6 +43,10 @@ require_relative "pg_reports/grafana/dashboard_builder"
 # Rails Engine
 require_relative "pg_reports/engine" if defined?(Rails::Engine)
 
+# Standalone runner (no host app). Only defines methods; the heavy Rails/web
+# requires happen lazily inside PgReports::Standalone.run.
+require_relative "pg_reports/standalone"
+
 module PgReports
   class << self
     # Query analysis methods
@@ -138,6 +145,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.1
 platform: ruby
 authors:
 - Eldar Avatov
@@ -140,7 +140,8 @@ description: A comprehensive PostgreSQL monitoring and analysis library that pro
   a beautiful web dashboard and Telegram notifications.
 email:
 - eldar.avatov@gmail.com
-executables: []
+executables:
+- pg_reports
 extensions: []
 extra_rdoc_files: []
 files:
@@ -150,12 +151,15 @@ 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
+- bin/pg_reports
 - config/locales/en.yml
 - config/locales/ru.yml
 - config/locales/uk.yml
@@ -164,6 +168,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
@@ -279,6 +286,7 @@ files:
 - lib/pg_reports/sql/tables/update_hotspots.sql
 - lib/pg_reports/sql/tables/vacuum_needed.sql
 - lib/pg_reports/sql_loader.rb
+- lib/pg_reports/standalone.rb
 - lib/pg_reports/telegram_sender.rb
 - lib/pg_reports/version.rb
 - lib/tasks/pg_reports.rake
@@ -289,16 +297,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
@@ -313,7 +311,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.4
+rubygems_version: 3.6.9
 specification_version: 4
 summary: PostgreSQL analysis and reporting tool with Telegram integration
 test_files: []