pg_reports 0.9.0 → 1.0.0

data/lib/pg_reports/rate_limiter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "active_support/cache"
+
+module PgReports
+  # Counts requests per key in fixed windows.
+  #
+  # The window's number is part of the cache key, so a refused request cannot push
+  # the end of the window back and a client recovers when the window turns over.
+  # The price of a fixed window is that a client can spend two windows' allowance
+  # across the boundary, which is fine for a guard against hammering.
+  #
+  # Counting uses the cache's atomic increment. That is exact on Redis, Memcached
+  # and MemoryStore. FileStore's increment is a read and a write: under load from
+  # several processes it loses updates and this counts low.
+  #
+  # When the cache cannot count, because it is a NullStore or it is failing, each
+  # process counts for itself. A throttle that switches off whenever Redis does
+  # would be gone exactly when the database needs it.
+  class RateLimiter
+    include Singleton
+
+    KEY_PREFIX = "pg_reports:rate_limit"
+
+    # @return [Integer, nil] seconds until the window turns over if this request is
+    #   over the limit, nil if it may proceed
+    def retry_after(key, limit:, window:, now: Time.now.to_i)
+      window = [window.to_i, 1].max
+      slot, elapsed = now.divmod(window)
+
+      return if count("#{KEY_PREFIX}:#{key}:#{slot}", window) <= limit
+
+      window - elapsed
+    end
+
+    private
+
+    def count(key, window)
+      increment(shared_store, key, window) || increment(local_store, key, window)
+    rescue StandardError, NotImplementedError => e
+      Rails.logger&.warn("PgReports: Rate limit cache unavailable: #{e.message}")
+      increment(local_store, key, window)
+    end
+
+    # The write creates the raw counter, which is the form Redis and Memcached can
+    # increment, and does nothing if another request already has.
+    def increment(store, key, window)
+      return unless store
+
+      store.write(key, 0, raw: true, unless_exist: true, expires_in: window)
+      store.increment(key, 1, raw: true, expires_in: window)
+    end
+
+    def shared_store
+      Rails.cache if Rails.respond_to?(:cache)
+    end
+
+    def local_store
+      @local_store ||= ActiveSupport::Cache::MemoryStore.new
+    end
+  end
+end

data/lib/pg_reports/report.rb

@@ -84,7 +84,7 @@ module PgReports
       CSV.generate do |csv|
         csv << columns
         data.each do |row|
-          csv << columns.map { |col| row[col] }
+          csv << columns.map { |col| CsvCell.safe(row[col]) }
         end
       end
     end

data/lib/pg_reports/report_definition.rb

@@ -57,8 +57,18 @@ module PgReports
     def apply_filters(data, params)
       return data unless config["filters"]
 
+      values = parameter_defaults.merge(params.compact)
+
       config["filters"].reduce(data) do |filtered, filter_config|
-        Filter.new(filter_config).apply(filtered, params)
+        Filter.new(filter_config).apply(filtered, values)
+      end
+    end
+
+    # The dashboard's form sends these, but /metrics, downloads, Telegram and direct
+    # calls send nothing and must get the same report.
+    def parameter_defaults
+      (config["parameters"] || {}).each_with_object({}) do |(name, parameter), defaults|
+        defaults[name.to_sym] = parameter["default"]
       end
     end
 

data/lib/pg_reports/sql/connections/connection_stats.sql

@@ -5,7 +5,8 @@ SELECT
   datname AS database,
   state,
   COUNT(*) AS count,
-  COUNT(*) FILTER (WHERE wait_event IS NOT NULL) AS waiting_count
+  COUNT(*) FILTER (WHERE wait_event IS NOT NULL) AS waiting_count,
+  COUNT(*) FILTER (WHERE state LIKE 'idle in transaction%') AS idle_in_transaction
 FROM pg_stat_activity
 WHERE datname IS NOT NULL
   AND pid != pg_backend_pid()

data/lib/pg_reports/sql/connections/idle_connections.sql

@@ -9,6 +9,7 @@ SELECT
   client_addr,
   state,
   EXTRACT(EPOCH FROM (NOW() - state_change)) AS idle_duration,
+  CASE WHEN state LIKE 'idle in transaction%' THEN EXTRACT(EPOCH FROM (NOW() - state_change)) END AS idle_in_transaction_seconds,
   state_change,
   query_start,
   LEFT(query, 200) AS last_query

data/lib/pg_reports/sql/connections/locks.sql

@@ -11,6 +11,7 @@ SELECT
   l.granted,
   NOT l.granted AS waiting,
   EXTRACT(EPOCH FROM (NOW() - a.query_start)) AS query_duration,
+  CASE WHEN NOT l.granted THEN EXTRACT(EPOCH FROM (NOW() - a.query_start)) END AS waiting_seconds,
   LEFT(a.query, 300) AS query
 FROM pg_locks l
 JOIN pg_stat_activity a ON l.pid = a.pid

data/lib/pg_reports/sql/indexes/bloated_indexes.sql

@@ -1,27 +1,35 @@
 -- Bloated indexes: indexes with estimated bloat
 -- Uses pgstattuple extension if available, otherwise estimates
 
-WITH index_stats AS (
+WITH named_indexes AS (
+  SELECT
+    schemaname,
+    tablename,
+    indexname,
+    format('%I.%I', schemaname, indexname)::regclass AS index_oid
+  FROM pg_indexes
+  WHERE schemaname NOT IN ('pg_catalog', 'information_schema')
+),
+index_stats AS (
   SELECT
     schemaname AS schema,
     tablename AS table_name,
     indexname AS index_name,
-    pg_relation_size(indexname::regclass) AS index_size,
+    pg_relation_size(index_oid) AS index_size,
     -- Estimate bloat using relation page count vs expected
     CASE
-      WHEN pg_relation_size(indexname::regclass) > 0 THEN
+      WHEN pg_relation_size(index_oid) > 0 THEN
         ROUND(
           (
-            (pg_relation_size(indexname::regclass) -
-             (SELECT reltuples * 8 FROM pg_class WHERE relname = indexname))
-            * 100.0 / pg_relation_size(indexname::regclass)
+            (pg_relation_size(index_oid) -
+             (SELECT reltuples * 8 FROM pg_class WHERE oid = index_oid))
+            * 100.0 / pg_relation_size(index_oid)
           )::numeric,
           2
         )
       ELSE 0
     END AS estimated_bloat_percent
-  FROM pg_indexes
-  WHERE schemaname NOT IN ('pg_catalog', 'information_schema')
+  FROM named_indexes
 )
 SELECT
   schema,

data/lib/pg_reports/sql/queries/activity_sample.sql

@@ -0,0 +1,22 @@
+-- Query Monitor sample: the statement each backend finished most recently
+-- A backend that is no longer active keeps its last statement in `query`, with
+-- its start in query_start and its end in state_change.
+--
+-- Without pg_read_all_stats, another role's rows arrive with a NULL state and
+-- NULL backend_type, so those conditions must let them through: the monitor
+-- counts them to tell the viewer what it cannot see.
+
+SELECT
+  pid,
+  application_name,
+  query,
+  query_start,
+  ROUND((EXTRACT(EPOCH FROM (state_change - query_start)) * 1000)::numeric, 2) AS duration_ms
+FROM pg_stat_activity
+WHERE datname = current_database()
+  AND pid <> pg_backend_pid()
+  AND COALESCE(backend_type, 'client backend') = 'client backend'
+  AND application_name IS DISTINCT FROM 'pg_reports'
+  AND query NOT LIKE '%/* pg_reports */%'
+  AND state IS DISTINCT FROM 'active'
+ORDER BY query_start;

data/lib/pg_reports/sql/queries/frequent_queries.sql

@@ -0,0 +1,42 @@
+-- Frequent queries: queries executed at the highest rate (calls per second)
+-- Requires pg_stat_statements 1.9+ (PostgreSQL 14+) for pg_stat_statements_info
+--
+-- pg_stat_statements only keeps cumulative counters, so the rate is an average
+-- over the time each entry has been tracked: since the entry was created
+-- (stats_since, PostgreSQL 17+) or since the last full reset on older versions.
+-- stats_since is read through to_jsonb so that one statement runs on both;
+-- GREATEST ignores the NULL it yields where the column does not exist.
+
+WITH tracked AS (
+  SELECT
+    s.query,
+    s.calls,
+    s.total_exec_time,
+    s.mean_exec_time,
+    GREATEST((to_jsonb(s) ->> 'stats_since')::timestamptz, i.stats_reset) AS tracked_since
+  FROM pg_stat_statements s
+  JOIN pg_database d ON s.dbid = d.oid
+  CROSS JOIN pg_stat_statements_info i
+  WHERE s.calls > 0
+    AND s.query NOT LIKE '%pg_stat_statements%'
+    AND s.query NOT LIKE 'COMMIT%'
+    AND s.query NOT LIKE 'BEGIN%'
+    AND d.datname = current_database()
+),
+rated AS (
+  SELECT
+    *,
+    -- The 60-second floor keeps entries seen moments ago from reporting a huge rate
+    calls / GREATEST(EXTRACT(EPOCH FROM now() - tracked_since), 60) AS rate
+  FROM tracked
+)
+SELECT
+  query,
+  ROUND(rate::numeric, 2) AS calls_per_second,
+  calls,
+  ROUND(mean_exec_time::numeric, 2) AS mean_time_ms,
+  ROUND(total_exec_time::numeric, 2) AS total_time_ms,
+  tracked_since
+FROM rated
+ORDER BY rate DESC
+LIMIT 100;

data/lib/pg_reports/sql_redactor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module PgReports
+  # Hides the string literals in a SQL statement, which is where passwords, tokens
+  # and personal data sit in captured queries.
+  #
+  # Numbers stay: they are what makes a captured query readable, and they rarely
+  # identify more than a row. Quoted identifiers and comments are matched only so
+  # that a quote inside them is not taken for the start of a string.
+  module SqlRedactor
+    PLACEHOLDER = "'?'"
+
+    # Every alternative ends at \z as well as at its closing quote. pg_stat_activity
+    # and the monitor's own limit both cut statements short, so the literal holding
+    # the secret can be the one with no end. The inner repeats are possessive: their
+    # alternatives cannot overlap, and a megabyte of text must not backtrack.
+    TOKEN = /
+      "(?:[^"]|"")*+(?:"|\z)                                  # identifier
+      | --[^\n]*+                                             # line comment
+      | \/\*.*?(?:\*\/|\z)                                    # block comment
+      | (?<literal>
+          (?<![\w$])[eE]'(?:[^'\\]|''|\\.)*+(?:'|\z)          # backslash escapes
+          | '(?:[^']|'')*+(?:'|\z)                            # standard string
+          | \$(?<tag>[A-Za-z_]\w*|)\$.*?(?:\$\k<tag>\$|\z)    # dollar-quoted
+        )
+    /mx
+
+    def self.redact(sql)
+      sql.gsub(TOKEN) { $~[:literal] ? PLACEHOLDER : $~[0] }
+    end
+  end
+end

data/lib/pg_reports/standalone.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "ipaddr"
 require "securerandom"
 
 module PgReports
@@ -20,13 +21,15 @@ module PgReports
     DEFAULT_PORT = 4000
     DEFAULT_HOST = "127.0.0.1"
     DEFAULT_MOUNT = "/"
+    LOOPBACK_HOSTS = %w[127.0.0.1 localhost ::1].freeze
 
     # Rack handlers tried, in order, when none is named explicitly.
     CANDIDATE_SERVERS = %w[puma webrick].freeze
 
-    # Config files auto-loaded (first that exists), relative to the working
-    # directory, when no explicit --config path is given.
-    DEFAULT_CONFIG_FILES = %w[pg_reports.rb config/pg_reports.rb].freeze
+    # Where a config file tends to live, relative to the working directory. Named
+    # only to say that one was skipped: a config file is Ruby, and starting this
+    # tool inside a cloned repository must not run what that repository ships.
+    CONVENTIONAL_CONFIG_FILES = %w[pg_reports.rb config/pg_reports.rb].freeze
 
     class ServerUnavailable < PgReports::Error; end
 
@@ -39,7 +42,7 @@ module PgReports
     #   from DATABASE_URL or libpq-style PG* env vars
     # @param server [String, nil] Rack handler name to force (e.g. "puma")
     # @param config_file [String, nil] path to a Ruby config file that calls
-    #   `PgReports.configure`; auto-detected from DEFAULT_CONFIG_FILES otherwise
+    #   `PgReports.configure`
     # @param overrides [Hash] per-setting overrides applied last (from CLI flags);
     #   nil values are ignored. Keys are Configuration attribute names.
     def run(port: DEFAULT_PORT, host: DEFAULT_HOST, mount_path: DEFAULT_MOUNT,
@@ -50,11 +53,22 @@ module PgReports
       # and database switching / multi-cluster all work unchanged.
       ENV["DATABASE_URL"] = connection_url(database_url)
 
+      # libpq reads this for every connection, including the per-database pools
+      # opened later, which is what lets the Query Monitor leave them out.
+      ENV["PGAPPNAME"] = QueryMonitor::APPLICATION_NAME
+
       # Mark this process as standalone so the dashboard can hide reports that
       # only make sense with a host app (e.g. Schema Analysis, which introspects
       # the host application's ActiveRecord models — there are none here).
       PgReports.config.standalone = true
 
+      # The production default protects a host application's queries, and there
+      # is no host application here. A config file can still turn it off below.
+      PgReports.config.query_monitor_enabled = true
+
+      # It samples every client of the database, not one developer's own application
+      PgReports.config.query_monitor_redact_literals = true
+
       # Layer settings on top of the ENV-derived defaults: config file first, then
       # explicit CLI overrides win.
       apply_configuration(config_file: config_file, overrides: overrides)
@@ -88,7 +102,38 @@ module PgReports
         userinfo << "@"
       end
 
-      "postgresql://#{userinfo}#{host}:#{port}/#{ERB::Util.url_encode(database)}"
+      path = "/#{ERB::Util.url_encode(database)}"
+
+      # A directory is how libpq spells a Unix socket. It cannot be the URL's
+      # authority, where the first slash would start the path, and URI refuses
+      # credentials without a host, so everything moves to the query.
+      if host.start_with?("/")
+        query = {user: user, password: password, host: host, port: port}
+          .reject { |_key, value| value.to_s.empty? }
+          .map { |key, value| "#{key}=#{ERB::Util.url_encode(value)}" }
+        return "postgresql://#{path}?#{query.join("&")}"
+      end
+
+      authority = host.include?(":") ? "[#{host}]" : host
+      "postgresql://#{userinfo}#{authority}:#{port}#{path}"
+    end
+
+    # For anything shown to a person: the URL can carry the password, in either of
+    # the two places #connection_url puts it.
+    def redact_url(url)
+      url.to_s.sub(%r{(//[^:/@]*:).*@}, '\1***@').sub(/([?&]password=)[^&]*/, '\1***')
+    end
+
+    # What Host headers to answer to. Without credentials the only thing keeping
+    # the dashboard private is that a request comes from this machine, and a web
+    # page can arrange that: it points its own domain at 127.0.0.1 (DNS rebinding),
+    # and the browser then sends that page's requests here as same-origin. Such a
+    # request still names the attacker's domain in Host, so it is refused here.
+    # Credentials make the check pointless, and the real name unknowable.
+    def allowed_hosts
+      return [] if PgReports.config.dashboard_auth.present?
+
+      ["localhost", ".localhost", IPAddr.new("127.0.0.0/8"), IPAddr.new("::1")]
     end
 
     private
@@ -102,8 +147,11 @@ module PgReports
     # flag — thresholds, Telegram, Grafana favorites, even the dashboard_auth
     # proc. CLI flags cover only the handful of common security toggles.
     def apply_configuration(config_file:, overrides:)
-      path = config_file || detect_config_file
-      load_config_file(path) if path
+      if config_file
+        load_config_file(config_file)
+      else
+        note_skipped_config_file
+      end
 
       overrides.each do |key, value|
         next if value.nil? # unset flag — leave the file/ENV value in place
@@ -111,12 +159,9 @@ module PgReports
       end
     end
 
-    # First existing DEFAULT_CONFIG_FILES entry (relative to the working dir), or
-    # nil when the user keeps no config file.
-    def detect_config_file
-      DEFAULT_CONFIG_FILES
-        .map { |f| File.expand_path(f, Dir.pwd) }
-        .find { |f| File.file?(f) }
+    def note_skipped_config_file
+      found = CONVENTIONAL_CONFIG_FILES.find { |file| File.file?(File.expand_path(file, Dir.pwd)) }
+      warn "pg_reports: not loading #{found}, pass --config #{found} to use it" if found
     end
 
     # Evaluate a Ruby config file. A missing explicit path is an error (the user
@@ -148,6 +193,8 @@ module PgReports
       require "pg_reports/engine"
 
       target_mount = mount_path
+      hosts = allowed_hosts
+      token_protected_metrics = PgReports.config.grafana_metrics_token.present?
       # 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
@@ -158,10 +205,15 @@ module PgReports
       Class.new(Rails::Application) do
         config.root = app_root
         config.eager_load = false
-        config.consider_all_requests_local = true
+        config.consider_all_requests_local = false
         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.hosts = hosts
+        # A scraper asks for the server by whatever name it has, and the bearer
+        # token is what protects this endpoint
+        config.host_authorization = {exclude: ->(request) { request.path.end_with?("/metrics") }} if token_protected_metrics
+        # Parameters reach the log at the default level, and SQL carries data
+        config.filter_parameters += %i[query params]
         config.logger = ::Logger.new($stdout)
         config.log_level = (ENV["LOG_LEVEL"] || "info").to_sym
         config.active_support.report_deprecations = false
@@ -175,20 +227,19 @@ module PgReports
     # 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
+      # Rails 7.2+ connects lazily, so only a query proves anything
+      ActiveRecord::Base.connection.execute("SELECT 1")
     rescue => e
-      raise PgReports::Error, "Cannot connect to the database (#{ENV["DATABASE_URL"]}): #{e.message}"
+      raise PgReports::Error, "Cannot connect to the database (#{redact_url(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)
+          rack_handlers.get(candidate)
         rescue LoadError, NameError
           nil
         end
@@ -202,9 +253,21 @@ module PgReports
       MSG
     end
 
+    # Rackup split from Rack with Rack 3, so Rails before 7.1 does not bring it
+    def rack_handlers
+      require "rackup"
+      Rackup::Handler
+    rescue LoadError
+      require "rack"
+      Rack::Handler
+    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)"
+      return if PgReports.config.dashboard_auth.present? || LOOPBACK_HOSTS.include?(host)
+
+      warn "pg_reports: no dashboard_auth is set, so requests from other machines get a 403 (see docs/standalone.md)"
     end
   end
 end

data/lib/pg_reports/version.rb

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

data/lib/pg_reports.rb

@@ -11,17 +11,22 @@ 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/access_policy"
+require_relative "pg_reports/rate_limiter"
 require_relative "pg_reports/sql_loader"
 require_relative "pg_reports/executor"
+require_relative "pg_reports/connection/target"
+require_relative "pg_reports/csv_cell"
 require_relative "pg_reports/report"
 require_relative "pg_reports/telegram_sender"
 require_relative "pg_reports/annotation_parser"
+require_relative "pg_reports/sql_redactor"
 require_relative "pg_reports/explain_analyzer"
+require_relative "pg_reports/drop_index_migration"
 require_relative "pg_reports/query_monitor"
 
 # YAML-based report system
@@ -55,7 +60,7 @@ require_relative "pg_reports/standalone"
 module PgReports
   class << self
     # Query analysis methods
-    delegate :slow_queries, :heavy_queries, :expensive_queries,
+    delegate :slow_queries, :heavy_queries, :frequent_queries, :expensive_queries,
       :missing_index_queries, :low_cache_hit_queries, :all_queries,
       :reset_statistics!, to: Modules::Queries
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_reports
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Eldar Avatov
@@ -15,56 +15,56 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -153,6 +153,7 @@ files:
 - 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/_settings_modal.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
@@ -166,12 +167,14 @@ files:
 - config/locales/uk.yml
 - config/routes.rb
 - lib/pg_reports.rb
+- lib/pg_reports/access_policy.rb
 - 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/csv_cell.rb
 - lib/pg_reports/dashboard/reports_registry.rb
 - lib/pg_reports/definitions/connections/active_connections.yml
 - lib/pg_reports/definitions/connections/blocking_queries.yml
@@ -195,6 +198,7 @@ files:
 - lib/pg_reports/definitions/indexes/unused_indexes.yml
 - lib/pg_reports/definitions/queries/all_queries.yml
 - lib/pg_reports/definitions/queries/expensive_queries.yml
+- lib/pg_reports/definitions/queries/frequent_queries.yml
 - lib/pg_reports/definitions/queries/heavy_queries.yml
 - lib/pg_reports/definitions/queries/low_cache_hit_queries.yml
 - lib/pg_reports/definitions/queries/missing_index_queries.yml
@@ -218,6 +222,7 @@ files:
 - lib/pg_reports/definitions/tables/unused_tables.yml
 - lib/pg_reports/definitions/tables/update_hotspots.yml
 - lib/pg_reports/definitions/tables/vacuum_needed.yml
+- lib/pg_reports/drop_index_migration.rb
 - lib/pg_reports/engine.rb
 - lib/pg_reports/error.rb
 - lib/pg_reports/executor.rb
@@ -233,6 +238,7 @@ files:
 - lib/pg_reports/modules/system.rb
 - lib/pg_reports/modules/tables.rb
 - lib/pg_reports/query_monitor.rb
+- lib/pg_reports/rate_limiter.rb
 - lib/pg_reports/report.rb
 - lib/pg_reports/report_definition.rb
 - lib/pg_reports/report_loader.rb
@@ -256,8 +262,10 @@ files:
 - lib/pg_reports/sql/indexes/invalid_indexes.sql
 - lib/pg_reports/sql/indexes/missing_indexes.sql
 - lib/pg_reports/sql/indexes/unused_indexes.sql
+- lib/pg_reports/sql/queries/activity_sample.sql
 - lib/pg_reports/sql/queries/all_queries.sql
 - lib/pg_reports/sql/queries/expensive_queries.sql
+- lib/pg_reports/sql/queries/frequent_queries.sql
 - lib/pg_reports/sql/queries/heavy_queries.sql
 - lib/pg_reports/sql/queries/low_cache_hit_queries.sql
 - lib/pg_reports/sql/queries/missing_index_queries.sql
@@ -287,6 +295,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/sql_redactor.rb
 - lib/pg_reports/standalone.rb
 - lib/pg_reports/telegram_sender.rb
 - lib/pg_reports/version.rb