ruby-pg-extras 2.1.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a88ff7e79fc4b77781012f9ee52afeee2462dcc46177d6bec8d24885c9822526
-  data.tar.gz: 9befdd7dd6f98195391fe323f5fabf0d74a6bb9bb0d717f7cf74c30219f91462
+  metadata.gz: 1b09fa8f29c8e1b0438acf8834d8d51e4ab76b2b8c4c7475e7ac82902d9bc29d
+  data.tar.gz: 5a18583d3576f515ea05e0a5d74180c11d811a44d5ecca9d5bad001540f28a98
 SHA512:
-  metadata.gz: 0c5df44798b60ae20ad1d8bb395cce56d92e89ddde8912d0a747fcf7e695c74ea3f9a58fa71b7d570a956d908ef3261bfc776c8feb23b21a7f61c595bc3a0855
-  data.tar.gz: d8d2ddcc09c7127ff75b8897bbef5a4ad98f057c80e836bcf8849833c0580914bfd1fd3a435cce34ef4124458dcf0fb12b3dcdb1d78b6932bd629f0ddb90a2f5
+  metadata.gz: 3a24a0a49e083f081d0d023f4f1b05d3fa867ef5b362f99eb6bc3c711616b857c5f434e5c23ffcc2ba42a0890f562f553694cb45434fa5484402569a827fe1fa
+  data.tar.gz: c50dd6d08c4e470a53257af9a7092271a6abeaab308579dc579efcd7df39e9b42031cc01f3d627225fcc73a26bb5c3253a6fe2c94ccc19812fc9671d88936a9b

data/.circleci/config.yml

@@ -31,7 +31,8 @@ jobs:
       - checkout
       - run: gem update --system
       - run: gem install bundler
-      - run: bundle install --path vendor/bundle
+      - run: bundle config set --local path 'vendor/bundle'
+      - run: bundle install
       - run: sudo apt-get update --allow-releaseinfo-change
       - run: sudo apt install postgresql-client-11
       - run: dockerize -wait tcp://postgres11:5432 -timeout 1m

data/README.md

@@ -26,7 +26,7 @@ In your Gemfile
 gem "ruby-pg-extras"
 ```
 
-Some of the queries (e.g., `calls` and `outliers`) require [pg_stat_statements](https://www.postgresql.org/docs/current/pgstatstatements.html) extension enabled.
+`calls` and `outliers` queries require [pg_stat_statements](https://www.postgresql.org/docs/current/pgstatstatements.html) extension.
 
 You can check if it is enabled in your database by running:
 
@@ -39,6 +39,12 @@ You should see the similar line in the output:
 | pg_stat_statements  | 1.7  | 1.7 | track execution statistics of all SQL statements executed |
 ```
 
+`ssl_used` requires `sslinfo` extension, and `buffercache_usage`/`buffercache_usage` queries need `pg_buffercache`. You can enable them all by running:
+
+```ruby
+RubyPGExtras.add_extensions
+```
+
 ## Usage
 
 Gem expects the `ENV['DATABASE_URL']` value in the following format:
@@ -92,6 +98,18 @@ RubyPGExtras.long_running_queries(args: { threshold: "200 milliseconds" })
 
 ```
 
+## Diagnose report
+
+The simplest way to start using pg-extras is to execute a `diagnose` method. It runs a set of checks and prints out a report highlighting areas that may require additional investigation:
+
+```ruby
+RubyPGExtras.diagnose
+```
+
+![Diagnose report](https://github.com/pawurb/ruby-pg-extras/raw/master/ruby-pg-extras-diagnose.png)
+
+Keep reading to learn about methods that `diagnose` uses under the hood.
+
 ## Available methods
 
 ### `cache_hit`
@@ -167,6 +185,20 @@ This method displays values for selected PostgreSQL settings. You can compare th
 
 [More info](https://pawelurbanek.com/postgresql-fix-performance#cache-hit)
 
+### `ssl_used`
+
+```ruby
+
+RubyPGExtras.ssl_used
+
+| ssl_is_used                     |
++---------------------------------+
+| t                               |
+
+```
+
+Returns boolean indicating if an encrypted SSL is currently used. Connecting to the database via an unencrypted connection is a critical security risk.
+
 ### `index_usage`
 
 ```ruby
@@ -222,7 +254,7 @@ This command displays all the current locks, regardless of their type.
 
 RubyPGExtras.outliers(args: { limit: 20 })
 
-                   qry                   |    exec_time     | prop_exec_time |   ncalls    | sync_io_time
+                   query                 |    exec_time     | prop_exec_time |   ncalls    | sync_io_time
 -----------------------------------------+------------------+----------------+-------------+--------------
  SELECT * FROM archivable_usage_events.. | 154:39:26.431466 | 72.2%          | 34,211,877  | 00:00:00
  COPY public.archivable_usage_events (.. | 50:38:33.198418  | 23.6%          | 13          | 13:34:21.00108
@@ -373,7 +405,7 @@ This command displays the total size of each table and materialized view in the
 
 ```ruby
 
-RubyPGExtras.unused_indexes(args: { min_scans: 20 })
+RubyPGExtras.unused_indexes(args: { max_scans: 20 })
 
           table      |                       index                | index_size | index_scans
 ---------------------+--------------------------------------------+------------+-------------
@@ -527,6 +559,14 @@ RubyPGExtras.kill_all
 
 This commands kills all the currently active connections to the database. It can be useful as a last resort when your database is stuck in a deadlock.
 
+### `pg_stat_statements_reset`
+
+```ruby
+RubyPGExtras.pg_stat_statements_reset
+```
+
+This command discards all statistics gathered so far by pg_stat_statements.
+
 ### `buffercache_stats`
 
 ```ruby

data/lib/ruby-pg-extras/diagnose_data.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require 'filesize'
+
+module RubyPGExtras
+  class DiagnoseData
+    PG_EXTRAS_TABLE_CACHE_HIT_MIN_EXPECTED = "0.985"
+    PG_EXTRAS_INDEX_CACHE_HIT_MIN_EXPECTED = "0.985"
+    PG_EXTRAS_UNUSED_INDEXES_MAX_SCANS = 20
+    PG_EXTRAS_UNUSED_INDEXES_MIN_SIZE_BYTES = Filesize.from("1 MB").to_i # 1000000 bytes
+    PG_EXTRAS_NULL_INDEXES_MIN_SIZE_MB = 1 # 1 MB
+    PG_EXTRAS_NULL_MIN_NULL_FRAC_PERCENT = 50 # 50%
+    PG_EXTRAS_BLOAT_MIN_VALUE = 10
+    PG_EXTRAS_OUTLIERS_MIN_EXEC_RATIO = 33 # 33%
+
+    def self.call
+      new.call
+    end
+
+    def call
+      [
+        :table_cache_hit,
+        :index_cache_hit,
+        :unused_indexes,
+        :null_indexes,
+        :bloat,
+        :duplicate_indexes
+      ].yield_self do |checks|
+        extensions_data = query_module.extensions(in_format: :hash)
+        pg_stats_enabled = extensions_data.find do |el|
+          el.fetch("name") == "pg_stat_statements"
+        end.fetch("installed_version", false)
+
+        ssl_info_enabled = extensions_data.find do |el|
+          el.fetch("name") == "sslinfo"
+        end.fetch("installed_version", false)
+
+        if pg_stats_enabled
+          checks = checks.concat([:outliers])
+        end
+
+        if ssl_info_enabled
+          checks = checks.concat([:ssl_used])
+        end
+
+        checks
+      end.map do |check|
+        send(check).merge(check_name: check)
+      end
+    end
+
+    private
+
+    def query_module
+      RubyPGExtras
+    end
+
+    def table_cache_hit
+      min_expected = ENV.fetch(
+        "PG_EXTRAS_TABLE_CACHE_HIT_MIN_EXPECTED",
+        PG_EXTRAS_TABLE_CACHE_HIT_MIN_EXPECTED
+      ).to_f
+
+      table_cache_hit_ratio = query_module.cache_hit(in_format: :hash)[1].fetch("ratio").to_f.round(6)
+
+      if table_cache_hit_ratio > min_expected
+        {
+          ok: true,
+          message: "Table cache hit ratio is correct: #{table_cache_hit_ratio}."
+        }
+      else
+        {
+          ok: false,
+          message: "Table hit ratio is too low: #{table_cache_hit_ratio}."
+        }
+      end
+    end
+
+    def index_cache_hit
+      min_expected = ENV.fetch(
+        "PG_EXTRAS_INDEX_CACHE_HIT_MIN_EXPECTED",
+        PG_EXTRAS_INDEX_CACHE_HIT_MIN_EXPECTED
+      ).to_f
+
+      index_cache_hit_ratio = query_module.cache_hit(in_format: :hash)[0].fetch("ratio").to_f.round(6)
+
+      if index_cache_hit_ratio > min_expected
+        {
+          ok: true,
+          message: "Index hit ratio is correct: #{index_cache_hit_ratio}."
+        }
+      else
+        {
+          ok: false,
+          message: "Index hit ratio is too low: #{index_cache_hit_ratio}."
+        }
+      end
+    end
+
+    def ssl_used
+      ssl_connection = query_module.ssl_used(in_format: :hash)[0].fetch("ssl_is_used")
+
+      if ssl_connection
+        {
+          ok: true,
+          message: "Database client is using a secure SSL connection."
+        }
+      else
+        {
+          ok: false,
+          message: "Database client is using an unencrypted connection."
+        }
+      end
+    end
+
+    def unused_indexes
+      indexes = query_module.unused_indexes(
+        in_format: :hash,
+        args: { min_scans: PG_EXTRAS_UNUSED_INDEXES_MAX_SCANS }
+      ).select do |i|
+        Filesize.from(i.fetch("index_size")).to_i >= PG_EXTRAS_UNUSED_INDEXES_MIN_SIZE_BYTES
+      end
+
+      if indexes.count == 0
+        {
+          ok: true,
+          message: "No unused indexes detected."
+        }
+      else
+        print_indexes = indexes.map do |i|
+          "'#{i.fetch('index')}' on '#{i.fetch('table')}' size #{i.fetch('index_size')}"
+        end.join(",\n")
+        {
+          ok: false,
+          message: "Unused indexes detected:\n#{print_indexes}"
+        }
+      end
+    end
+
+    def null_indexes
+      indexes = query_module.null_indexes(
+        in_format: :hash,
+        args: { min_relation_size_mb: PG_EXTRAS_NULL_INDEXES_MIN_SIZE_MB }
+      ).select do |i|
+        i.fetch("null_frac").gsub("%", "").to_f >= PG_EXTRAS_NULL_MIN_NULL_FRAC_PERCENT
+      end
+
+      if indexes.count == 0
+        {
+          ok: true,
+          message: "No null indexes detected."
+        }
+      else
+        print_indexes = indexes.map do |i|
+          "'#{i.fetch('index')}' size #{i.fetch('index_size')} null values fraction #{i.fetch('null_frac')}"
+        end.join(",\n")
+        {
+          ok: false,
+          message: "Null indexes detected:\n#{print_indexes}"
+        }
+      end
+    end
+
+    def bloat
+      bloat_data = query_module.bloat(in_format: :hash).select do |b|
+        b.fetch("bloat").to_f >= PG_EXTRAS_BLOAT_MIN_VALUE
+      end
+
+      if bloat_data.count == 0
+        {
+          ok: true,
+          message: "No bloat detected."
+        }
+      else
+        print_bloat = bloat_data.map do |b|
+          "'#{b.fetch('object_name')}' bloat #{b.fetch('bloat')} waste #{b.fetch('waste')}"
+        end.join(",\n")
+
+        {
+          ok: false,
+          message: "Bloat detected:\n#{print_bloat}"
+        }
+      end
+    end
+
+    def duplicate_indexes
+      indexes = query_module.duplicate_indexes(in_format: :hash)
+
+      if indexes.count == 0
+        {
+          ok: true,
+          message: "No duplicate indexes detected."
+        }
+      else
+        print_indexes = indexes.map do |i|
+          "'#{i.fetch('idx1')}' of size #{i.fetch('size')} is identical to '#{i.fetch('idx2')}'"
+        end.join(",\n")
+
+        {
+          ok: false,
+          message: "Duplicate indexes detected:\n#{print_indexes}"
+        }
+      end
+    end
+
+    def outliers
+      queries = query_module.outliers(in_format: :hash).select do |q|
+        q.fetch("prop_exec_time").gsub("%", "").to_f >= PG_EXTRAS_OUTLIERS_MIN_EXEC_RATIO
+      end
+
+      if queries.count == 0
+        {
+          ok: true,
+          message: "No queries using significant execution ratio detected."
+        }
+      else
+        print_queries = queries.map do |q|
+          "'#{q.fetch('query').slice(0, 30)}...' called #{q.fetch('ncalls')} times, using #{q.fetch('prop_exec_time')} of total exec time."
+        end.join(",\n")
+
+        {
+          ok: false,
+          message: "Queries using significant execution ratio detected:\n#{print_queries}"
+        }
+      end
+    end
+  end
+end

data/lib/ruby-pg-extras/diagnose_print.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'terminal-table'
+
+module RubyPGExtras
+  class DiagnosePrint
+    def self.call(data)
+      new.call(data)
+    end
+
+    def call(data)
+      rows = data.sort do |el|
+        p el
+        el.fetch(:ok) ? 1 : -1
+      end.map do |el|
+        symbol = el.fetch(:ok) ? "√" : "x"
+        color = el.fetch(:ok) ? :green : :red
+
+        [
+          colorize("[#{symbol}] - #{el.fetch(:check_name)}", color),
+          colorize(el.fetch(:message), color)
+        ]
+      end
+
+      puts Terminal::Table.new(
+        title: title,
+        rows: rows
+      )
+    end
+
+    private
+
+    def title
+      "ruby-pg-extras - diagnose report"
+    end
+
+    def colorize(string, color)
+      if color == :red
+        "\e[0;31;49m#{string}\e[0m"
+      elsif color == :green
+        "\e[0;32;49m#{string}\e[0m"
+      else
+        raise "Unsupported color: #{color}"
+      end
+    end
+  end
+end

data/lib/ruby-pg-extras/queries/add_extensions.sql

@@ -0,0 +1,5 @@
+/* Configure extensions necessary for other queries to work */
+
+CREATE EXTENSION IF NOT EXISTS sslinfo;
+CREATE EXTENSION IF NOT EXISTS pg_buffercache;
+CREATE EXTENSION IF NOT EXISTS pg_stat_statements;

data/lib/ruby-pg-extras/queries/duplicate_indexes.sql

@@ -1,4 +1,4 @@
-/* Multiple indexes that have the same set of columns, same opclass, expression and predicate -- which make them equivalent. */
+/* Multiple indexes that have the same set of columns, same opclass, expression and predicate. */
 
 SELECT pg_size_pretty(sum(pg_relation_size(idx))::bigint) as size,
        (array_agg(idx))[1] as idx1, (array_agg(idx))[2] as idx2,

data/lib/ruby-pg-extras/queries/pg_stat_statements_reset.sql

@@ -0,0 +1,3 @@
+/* pg_stat_statements_reset discards statistics gathered so far by pg_stat_statements */
+
+SELECT pg_stat_statements_reset();

data/lib/ruby-pg-extras/queries/ssl_used.sql

@@ -0,0 +1,3 @@
+/* Check if SSL connection is used */
+
+SELECT ssl_is_used();

data/lib/ruby-pg-extras/queries/unused_indexes.sql

@@ -11,6 +11,6 @@ SELECT
   idx_scan as index_scans
 FROM pg_stat_user_indexes ui
 JOIN pg_index i ON ui.indexrelid = i.indexrelid
-WHERE NOT indisunique AND idx_scan < %{min_scans} AND pg_relation_size(relid) > 5 * 8192
+WHERE NOT indisunique AND idx_scan < %{max_scans} AND pg_relation_size(relid) > 5 * 8192
 ORDER BY pg_relation_size(i.indexrelid) / nullif(idx_scan, 0) DESC NULLS FIRST,
 pg_relation_size(i.indexrelid) DESC;

data/lib/ruby-pg-extras/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyPGExtras
-  VERSION = "2.1.0"
+  VERSION = "3.1.0"
 end

data/lib/ruby-pg-extras.rb

@@ -3,20 +3,23 @@
 require 'terminal-table'
 require 'uri'
 require 'pg'
+require 'ruby-pg-extras/diagnose_data'
+require 'ruby-pg-extras/diagnose_print'
 
 module RubyPGExtras
   @@database_url = nil
   NEW_PG_STAT_STATEMENTS = "1.8"
 
   QUERIES = %i(
-    bloat blocking cache_hit db_settings
+    add_extensions bloat blocking cache_hit db_settings
     calls extensions table_cache_hit index_cache_hit
     index_size index_usage null_indexes locks all_locks
     long_running_queries mandelbrot outliers
     records_rank seq_scans table_indexes_size
     table_size total_index_size total_table_size
     unused_indexes duplicate_indexes vacuum_stats kill_all
-    buffercache_stats buffercache_usage
+    pg_stat_statements_reset buffercache_stats
+    buffercache_usage ssl_used
   )
 
   DEFAULT_ARGS = Hash.new({}).merge({
@@ -27,7 +30,7 @@ module RubyPGExtras
     outliers_legacy: { limit: 10 },
     buffercache_stats: { limit: 10 },
     buffercache_usage: { limit: 20 },
-    unused_indexes: { min_scans: 50 },
+    unused_indexes: { max_scans: 50 },
     null_indexes: { min_relation_size_mb: 10 }
   })
 
@@ -66,6 +69,20 @@ module RubyPGExtras
     )
   end
 
+  def self.diagnose(in_format: :display_table)
+    data = RubyPGExtras::DiagnoseData.call
+
+    if in_format == :display_table
+      RubyPGExtras::DiagnosePrint.call(data)
+    elsif in_format == :hash
+      data
+    elsif in_format == :array
+      data.map(&:values)
+    else
+      raise "Invalid 'in_format' argument!"
+    end
+  end
+
   def self.display_result(result, title:, in_format:)
     case in_format
     when :array

data/ruby-pg-extras.gemspec

@@ -16,6 +16,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.license       = "MIT"
   gem.add_dependency "pg"
+  gem.add_dependency "filesize"
   gem.add_dependency "terminal-table"
   gem.add_development_dependency "rake"
   gem.add_development_dependency "rspec"

data/spec/diagnose_data_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyPGExtras::DiagnoseData do
+  subject(:result) do
+    RubyPGExtras::DiagnoseData.call
+  end
+
+  describe "call" do
+    context "stubbed cases" do
+      before do
+        expect(RubyPGExtras).to receive(:unused_indexes) {
+          [
+            { "table" => "public.plans", "index" => "index_plans_on_payer_id", "index_size" => "16 MB", "index_scans" => 0 },
+            { "table" => "public.feedbacks", "index" => "index_feedbacks_on_target_id", "index_size" => "80 kB", "index_scans" => 1 },
+            { "table" => "public.channels", "index" => "index_channels_on_slack_id", "index_size" => "56 MB", "index_scans" => 7}
+          ]
+        }
+
+        expect(RubyPGExtras).to receive(:null_indexes) {
+          [
+            { "oid" => 123, "index" => "index_plans_on_payer_id", "index_size" => "16 MB", "unique" => "t", "null_frac" => "00.00%", "expected_saving" => "0 kb" },
+            { "oid" => 321, "index" => "index_feedbacks_on_target_id", "index_size" => "80 kB", "unique" => "f", "null_frac" => "97.00%", "expected_saving" => "77 kb" },
+            { "oid" => 231, "index" => "index_channels_on_slack_id", "index_size" => "56 MB", "unique" => "t", "null_frac" => "49.99%", "expected_saving" => "28 MB" }
+          ]
+        }
+
+        expect(RubyPGExtras).to receive(:bloat) {
+          [
+            { "type" => "table", "schemaname" => "public", "object_name" => "bloated_table_1", "bloat" => 8, "waste" => "0 kb" },
+            { "type" => "table", "schemaname" => "public", "object_name" => "bloated_table_2", "bloat" => 8, "waste" => "77 kb" },
+            { "type" => "schemaname", "public" => "index_channels_on_slack_id", "object_name" => "bloated_index", "bloat" => 11, "waste" => "28 MB" }
+          ]
+        }
+
+        expect(RubyPGExtras).to receive(:duplicate_indexes) {
+          [
+            { "size" => "128 kb", "idx1" => "users_pkey", "idx2" => "index_users_id" }
+          ]
+        }
+
+        expect(RubyPGExtras).to receive(:outliers) {
+          [
+            { "query" => "SELECT * FROM users WHERE users.age > 20 AND users.height > 160", "exec_time" => "154:39:26.431466", "prop_exec_time" => "72.2%", "ncalls" => "34,211,877", "sync_io_time" => "00:34:19.784318" }
+          ]
+        }
+      end
+
+      it "works" do
+        expect {
+          RubyPGExtras::DiagnosePrint.call(result)
+        }.not_to raise_error
+      end
+    end
+
+    context "real database data" do
+      before do
+        expect(RubyPGExtras).to receive(:unused_indexes) {
+          [
+            { "table" => "public.plans", "index" => "index_plans_on_payer_id", "index_size" => "2 MB", "index_scans" => 0 },
+            { "table" => "public.feedbacks", "index" => "index_feedbacks_on_target_id", "index_size" => "80 kB", "index_scans" => 1 },
+            { "table" => "public.channels", "index" => "index_channels_on_slack_id", "index_size" => "1.1 MB", "index_scans" => 7}
+          ]
+        }
+
+      end
+
+      it "works" do
+        expect {
+          RubyPGExtras::DiagnosePrint.call(result)
+        }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/diagnose_print_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RubyPGExtras::DiagnosePrint do
+  subject(:print_result) do
+    RubyPGExtras::DiagnosePrint.call(data)
+  end
+
+  let(:data) do
+    [
+      {
+        :check_name => :table_cache_hit,
+        :ok => false,
+        :message => "Table hit ratio too low: 0.906977."
+      },
+      {
+        :check_name => :index_cache_hit,
+        :ok => false,
+        :message => "Index hit ratio is too low: 0.818182."
+      },
+      {
+        :check_name => :ssl_used,
+        :ok => true,
+        :message => "Database client is using a secure SSL connection."
+      }
+    ]
+  end
+
+  describe "call" do
+    it "works" do
+      expect {
+        print_result
+      }.not_to raise_error
+    end
+  end
+end

data/spec/smoke_spec.rb

@@ -3,11 +3,6 @@
 require 'spec_helper'
 
 describe RubyPGExtras do
-  before(:all) do
-    RubyPGExtras.connection.exec("CREATE EXTENSION IF NOT EXISTS pg_buffercache;")
-    RubyPGExtras.connection.exec("CREATE EXTENSION IF NOT EXISTS pg_stat_statements;")
-  end
-
   RubyPGExtras::QUERIES.each do |query_name|
     it "#{query_name} description can be read" do
       expect do

data/spec/spec_helper.rb

@@ -17,3 +17,11 @@ else
 end
 
 ENV["DATABASE_URL"] ||= "postgresql://postgres:secret@localhost:#{port}/ruby-pg-extras-test"
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    RubyPGExtras.connection.exec("CREATE EXTENSION IF NOT EXISTS pg_stat_statements;")
+    RubyPGExtras.connection.exec("CREATE EXTENSION IF NOT EXISTS pg_buffercache;")
+    RubyPGExtras.connection.exec("CREATE EXTENSION IF NOT EXISTS sslinfo;")
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-pg-extras
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.1.0
 platform: ruby
 authors:
 - pawurb
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-15 00:00:00.000000000 Z
+date: 2021-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: filesize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: terminal-table
   requirement: !ruby/object:Gem::Requirement
@@ -83,6 +97,9 @@ files:
 - Rakefile
 - docker-compose.yml.sample
 - lib/ruby-pg-extras.rb
+- lib/ruby-pg-extras/diagnose_data.rb
+- lib/ruby-pg-extras/diagnose_print.rb
+- lib/ruby-pg-extras/queries/add_extensions.sql
 - lib/ruby-pg-extras/queries/all_locks.sql
 - lib/ruby-pg-extras/queries/bloat.sql
 - lib/ruby-pg-extras/queries/blocking.sql
@@ -104,8 +121,10 @@ files:
 - lib/ruby-pg-extras/queries/null_indexes.sql
 - lib/ruby-pg-extras/queries/outliers.sql
 - lib/ruby-pg-extras/queries/outliers_legacy.sql
+- lib/ruby-pg-extras/queries/pg_stat_statements_reset.sql
 - lib/ruby-pg-extras/queries/records_rank.sql
 - lib/ruby-pg-extras/queries/seq_scans.sql
+- lib/ruby-pg-extras/queries/ssl_used.sql
 - lib/ruby-pg-extras/queries/table_cache_hit.sql
 - lib/ruby-pg-extras/queries/table_indexes_size.sql
 - lib/ruby-pg-extras/queries/table_size.sql
@@ -114,7 +133,10 @@ files:
 - lib/ruby-pg-extras/queries/unused_indexes.sql
 - lib/ruby-pg-extras/queries/vacuum_stats.sql
 - lib/ruby-pg-extras/version.rb
+- ruby-pg-extras-diagnose.png
 - ruby-pg-extras.gemspec
+- spec/diagnose_data_spec.rb
+- spec/diagnose_print_spec.rb
 - spec/smoke_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/pawurb/ruby-pg-extras
@@ -141,5 +163,7 @@ signing_key:
 specification_version: 4
 summary: Ruby PostgreSQL performance database insights
 test_files:
+- spec/diagnose_data_spec.rb
+- spec/diagnose_print_spec.rb
 - spec/smoke_spec.rb
 - spec/spec_helper.rb