ruby-pg-extras 1.3.1 → 1.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d0df9d65eb4c50bca362f8d093b72eb62cd59b5137dd1cd8032837e8bcfbee8
-  data.tar.gz: 2030a04032fd67df813e9699be68a26eb81d92de743e680e0a63145a9e48fa68
+  metadata.gz: 3de471f9f4d008d006000667b4b52d4e0d8aec0c5dc9ef55ce6045e5e8f96994
+  data.tar.gz: bb78196a09f0af1d7f4be623f1794223b3db074d19eb439e59670b8e960d06e1
 SHA512:
-  metadata.gz: d66a0ba6f8d7baa5a509cb944e9e03a8d9da748b487e92165416f25e71561165f2259dab70f5d4e54bf603016dfb002610505175b67f9edf05ea4051a2f74260
-  data.tar.gz: 7599de124bd7d1ab3bde751095fe1e4db1971acd9ac806b88f2ac53108617276571c8ffeffbbb3551cab67f1909e9311ad0bace7ec1519eda68da070379c81f1
+  metadata.gz: 7ed2d3f75a540b6e8b22db825a1479a53649ee3ddde59ca7783301f5e42d89f8a8c1d40e11b42a5f1340f3b72d866531a6878c57ccfb211f43ca00d21d82c177
+  data.tar.gz: 5f6618ededb729f9d085cfdc5c5c722065ccd8beee6cb191bdfc3e6e58700fa2468d0f5aa3f7829fc9d520d7fb66fe248d897d989fe7fec9c21896cb2234bdad

data/README.md

@@ -85,6 +85,13 @@ RubyPGExtras.cache_hit(in_format: :raw) =>
  #<PG::Result:0x00007f75777f7328 status=PGRES_TUPLES_OK ntuples=2 nfields=2 cmd_tuples=2>
 ```
 
+Some methods accept an optional `args` param allowing you to customize queries:
+
+```ruby
+RubyPGExtras.long_running_queries(args: { threshold: "200 milliseconds" })
+
+```
+
 ## Available methods
 
 ### `cache_hit`
@@ -102,6 +109,8 @@ RubyPGExtras.cache_hit
 
 This command provides information on the efficiency of the buffer cache, for both index reads (`index hit rate`) as well as table reads (`table hit rate`). A low buffer cache hit ratio can be a sign that the Postgres instance is too small for the workload.
 
+[More info](https://pawelurbanek.com/postgresql-fix-performance#cache-hit)
+
 ### `index_cache_hit`
 
 ```ruby
@@ -118,6 +127,8 @@ RubyPGExtras.index_cache_hit
 
 The same as `cache_hit` with each table's indexes cache hit info displayed separately.
 
+[More info](https://pawelurbanek.com/postgresql-fix-performance#cache-hit)
+
 ### `table_cache_hit`
 
 ```ruby
@@ -134,6 +145,26 @@ RubyPGExtras.table_cache_hit
 
 The same as `cache_hit` with each table's cache hit info displayed seperately.
 
+[More info](https://pawelurbanek.com/postgresql-fix-performance#cache-hit)
+
+### `db_settings`
+
+```ruby
+
+RubyPGExtras.db_settings
+
+             name             | setting | unit |
+------------------------------+---------+------+
+ checkpoint_completion_target | 0.7     |      |
+ default_statistics_target    | 100     |      |
+ effective_cache_size         | 1350000 | 8kB  |
+ effective_io_concurrency     | 1       |      |
+(truncated results for brevity)
+
+```
+
+This method displays values for selected PostgreSQL settings. You can compare them with settings recommended by [PGTune](https://pgtune.leopard.in.ua/#/) and tweak values to improve performance.
+
 ### `index_usage`
 
 ```ruby
@@ -171,6 +202,8 @@ RubyPGExtras.locks
 
 This command displays queries that have taken out an exclusive lock on a relation. Exclusive locks typically prevent other operations on that relation from taking place, and can be a cause of "hung" queries that are waiting for a lock to be granted.
 
+[More info](https://pawelurbanek.com/postgresql-fix-performance#deadlocks)
+
 ### `all_locks`
 
 ```ruby
@@ -185,7 +218,7 @@ This command displays all the current locks, regardless of their type.
 
 ```ruby
 
-RubyPGExtras.outliers
+RubyPGExtras.outliers(args: { limit: 20 })
 
                    qry                   |    exec_time     | prop_exec_time |   ncalls    | sync_io_time
 -----------------------------------------+------------------+----------------+-------------+--------------
@@ -203,11 +236,13 @@ This command displays statements, obtained from `pg_stat_statements`, ordered by
 
 Typically, an efficient query will have an appropriate ratio of calls to total execution time, with as little time spent on I/O as possible. Queries that have a high total execution time but low call count should be investigated to improve their performance. Queries that have a high proportion of execution time being spent on synchronous I/O should also be investigated.
 
+[More info](https://pawelurbanek.com/postgresql-fix-performance#missing-indexes)
+
 ### `calls`
 
 ```ruby
 
-RubyPGExtras.calls
+RubyPGExtras.calls(args: { limit: 10 })
 
                    qry                   |    exec_time     | prop_exec_time |   ncalls    | sync_io_time
 -----------------------------------------+------------------+----------------+-------------+--------------
@@ -223,6 +258,8 @@ RubyPGExtras.calls
 
 This command is much like `pg:outliers`, but ordered by the number of times a statement has been called.
 
+[More info](https://pawelurbanek.com/postgresql-fix-performance#missing-indexes)
+
 ### `blocking`
 
 ```ruby
@@ -237,6 +274,8 @@ RubyPGExtras.blocking
 
 This command displays statements that are currently holding locks that other statements are waiting to be released. This can be used in conjunction with `pg:locks` to determine which statements need to be terminated in order to resolve lock contention.
 
+[More info](https://pawelurbanek.com/postgresql-fix-performance#deadlocks)
+
 ### `total_index_size`
 
 ```ruby
@@ -332,7 +371,7 @@ This command displays the total size of each table and materialized view in the
 
 ```ruby
 
-RubyPGExtras.unused_indexes
+RubyPGExtras.unused_indexes(args: { min_scans: 20 })
 
           table      |                       index                | index_size | index_scans
 ---------------------+--------------------------------------------+------------+-------------
@@ -344,6 +383,26 @@ RubyPGExtras.unused_indexes
 
 This command displays indexes that have < 50 scans recorded against them, and are greater than 5 pages in size, ordered by size relative to the number of index scans. This command is generally useful for eliminating indexes that are unused, which can impact write performance, as well as read performance should they occupy space in memory.
 
+[More info](https://pawelurbanek.com/postgresql-fix-performance#unused-indexes)
+
+### `null_indexes`
+
+```ruby
+
+RubyPGExtras.null_indexes(args: { min_relation_size_mb: 10 })
+
+   oid   |         index      | index_size | unique | indexed_column | null_frac | expected_saving
+---------+--------------------+------------+--------+----------------+-----------+-----------------
+  183764 | users_reset_token  | 1445 MB    | t      | reset_token    |   97.00%  | 1401 MB
+   88732 | plan_cancelled_at  | 539 MB     | f      | cancelled_at   |    8.30%  | 44 MB
+ 9827345 | users_email        | 18 MB      | t      | email          |   28.67%  | 5160 kB
+
+```
+
+This command displays indexes that contain `NULL` values. A high ratio of `NULL` values means that using a partial index excluding them will be beneficial in case they are not used for searching.
+
+[More info](https://pawelurbanek.com/postgresql-fix-performance#null-indexes)
+
 ### `seq_scans`
 
 ```ruby
@@ -366,11 +425,13 @@ RubyPGExtras.seq_scans
 
 This command displays the number of sequential scans recorded against all tables, descending by count of sequential scans. Tables that have very high numbers of sequential scans may be under-indexed, and it may be worth investigating queries that read from these tables.
 
+[More info](https://pawelurbanek.com/postgresql-fix-performance#missing-indexes)
+
 ### `long_running_queries`
 
 ```ruby
 
-RubyPGExtras.long_running_queries
+RubyPGExtras.long_running_queries(args: { threshold: "200 milliseconds" })
 
 
   pid  |    duration     |                                      query
@@ -421,6 +482,8 @@ RubyPGExtras.bloat
 
 This command displays an estimation of table "bloat" – space allocated to a relation that is full of dead tuples, that has yet to be reclaimed. Tables that have a high bloat ratio, typically 10 or greater, should be investigated to see if vacuuming is aggressive enough, and can be a sign of high table churn.
 
+[More info](https://pawelurbanek.com/postgresql-fix-performance#bloat)
+
 ### `vacuum_stats`
 
 ```ruby

data/lib/ruby-pg-extras.rb

@@ -8,9 +8,9 @@ module RubyPGExtras
   @@database_url = nil
 
   QUERIES = %i(
-    bloat blocking cache_hit
+    bloat blocking cache_hit db_settings
     calls extensions table_cache_hit index_cache_hit
-    index_size index_usage locks all_locks
+    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
@@ -19,9 +19,10 @@ module RubyPGExtras
 
   DEFAULT_ARGS = Hash.new({}).merge({
     calls: { limit: 10 },
-    long_running_queries: { interval: '5 seconds' },
+    long_running_queries: { threshold: "500 milliseconds" },
     outliers: { limit: 10 },
-    unused_indexes: { min_scans: 50 }
+    unused_indexes: { min_scans: 50 },
+    null_indexes: { min_relation_size_mb: 10 }
   })
 
   QUERIES.each do |query_name|

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

@@ -0,0 +1,9 @@
+/* Values of selected PostgreSQL settings */
+
+SELECT name, setting, unit, short_desc FROM pg_settings
+WHERE name IN (
+  'max_connections', 'shared_buffers', 'effective_cache_size',
+  'maintenance_work_mem', 'checkpoint_completion_target', 'wal_buffers',
+  'default_statistics_target', 'random_page_cost', 'effective_io_concurrency',
+  'work_mem', 'min_wal_size', 'max_wal_size'
+);

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

@@ -9,6 +9,6 @@ FROM
 WHERE
   pg_stat_activity.query <> ''::text
   AND state <> 'idle'
-  AND now() - pg_stat_activity.query_start > interval '%{interval}'
+  AND now() - pg_stat_activity.query_start > interval '%{threshold}'
 ORDER BY
   now() - pg_stat_activity.query_start DESC;

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

@@ -0,0 +1,33 @@
+/* Find indexes with a high ratio of NULL values */
+
+SELECT
+    c.oid,
+    c.relname AS index,
+    pg_size_pretty(pg_relation_size(c.oid)) AS index_size,
+    i.indisunique AS unique,
+    a.attname AS indexed_column,
+    CASE s.null_frac
+        WHEN 0 THEN ''
+        ELSE to_char(s.null_frac * 100, '999.00%%')
+    END AS null_frac,
+    pg_size_pretty((pg_relation_size(c.oid) * s.null_frac)::bigint) AS expected_saving
+FROM
+    pg_class c
+    JOIN pg_index i ON i.indexrelid = c.oid
+    JOIN pg_attribute a ON a.attrelid = c.oid
+    JOIN pg_class c_table ON c_table.oid = i.indrelid
+    JOIN pg_indexes ixs ON c.relname = ixs.indexname
+    LEFT JOIN pg_stats s ON s.tablename = c_table.relname AND a.attname = s.attname
+WHERE
+    -- Primary key cannot be partial
+    NOT i.indisprimary
+    -- Exclude already partial indexes
+    AND i.indpred IS NULL
+    -- Exclude composite indexes
+    AND array_length(i.indkey, 1) = 1
+    -- Exclude indexes without null_frac ratio
+    AND coalesce(s.null_frac, 0) != 0
+    -- Larger than threshold
+    AND pg_relation_size(c.oid) > %{min_relation_size_mb} * 1024 ^ 2
+ORDER BY
+  pg_relation_size(c.oid) * s.null_frac DESC;

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

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-pg-extras
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.5.3
 platform: ruby
 authors:
 - pawurb
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-22 00:00:00.000000000 Z
+date: 2021-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -88,6 +88,7 @@ files:
 - lib/ruby-pg-extras/queries/blocking.sql
 - lib/ruby-pg-extras/queries/cache_hit.sql
 - lib/ruby-pg-extras/queries/calls.sql
+- lib/ruby-pg-extras/queries/db_settings.sql
 - lib/ruby-pg-extras/queries/extensions.sql
 - lib/ruby-pg-extras/queries/index_cache_hit.sql
 - lib/ruby-pg-extras/queries/index_size.sql
@@ -96,6 +97,7 @@ files:
 - lib/ruby-pg-extras/queries/locks.sql
 - lib/ruby-pg-extras/queries/long_running_queries.sql
 - lib/ruby-pg-extras/queries/mandelbrot.sql
+- lib/ruby-pg-extras/queries/null_indexes.sql
 - lib/ruby-pg-extras/queries/outliers.sql
 - lib/ruby-pg-extras/queries/records_rank.sql
 - lib/ruby-pg-extras/queries/seq_scans.sql