postgres_monitor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 29ff454384341fa953a1ad421cd4f721fb91dd05
+  data.tar.gz: a81b7f4ff4e01d1f09cb192aa043c158a44caf32
+SHA512:
+  metadata.gz: 1ad9882350ef1698530d23e473f5ff08b6a83b3a7826279ceaad27469444bae602f6d6995382b25a01be553d86b5ed43cbb91d495b5df72b0efbe423eff853d4
+  data.tar.gz: fcec22dcca7f3eb0f8beb6c9a345f7fca7e49e33afc5e5da702124bdf66ce5e0b3a8e7a85a1caf0b484a6e7f2b9c6c5f1fa626ded3a35894e6f860accc692419

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler -v 1.10.5

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in postgres_monitor.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Scott Shea
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+# PostgresMonitor
+
+This gem is designed to expose a number of internal metrics and statistics for Postgres installations to the calling application. It borrows heavily from [Heroku's PG Extras](https://github.com/heroku/heroku-pg-extras) and [Boundless's plugin for New Relic](http://newrelic.com/plugins/boundless-production/109)-- [source](https://github.com/GoBoundless/newrelic_postgres_plugin).
+
+In each case there were drawbacks that led me to create this gem. Heroku PG Extra's only works on Heroku installations. The New Relic plugin only accepts numerical values; I wanted to see the actual queries in some cases.
+
+It uses the [PG gem](https://bitbucket.org/ged/ruby-pg/wiki/Home) for its connections to Postgres
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'postgres_monitor'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install postgres_monitor
+
+## Usage
+
+### Connection to the Database
+To create a connection you will need to supply the host name, user, password (can be nil), and dbname. Port will default to 5432 if it is not provided. sslmode will default to required if it is not supplied.
+
+#### Example
+
+```ruby
+@connection_params = {
+  host: 'localhost',
+  port: nil, # defaults to 5432
+  user: 'postgres',
+  password: 'password',
+  sslmode: 'allow',
+  dbname: 'postrges'
+}
+
+@monitor = PostgresMonitor::Monitor.new(@connection_params)
+```
+
+### Results from methods
+The methods return the raw [PG::Result](http://deveiate.org/code/pg/PG/Result.html) for interpretation. This is a collection of hashes, well sometimes just one hash, with the results and keys in them.
+
+#### Example
+```ruby
+results = @monitor.list_databases
+databases = []
+results.each do |row|
+  databases << row['datname']
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/scottshea/postgres_monitor. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "postgres_monitor"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/postgres_monitor/monitor.rb

@@ -0,0 +1,524 @@
+module PostgresMonitor
+  class Monitor
+      def initialize(connection_params)
+        @host     = connection_params[:host]
+        @port     = connection_params[:port] ? connection_params[:port] : self.port
+        @user     = connection_params[:user]
+        @password = connection_params[:password]
+        @sslmode  = connection_params[:sslmode] ? connection_params[:sslmode] : 'require'
+        @dbname   = connection_params[:dbname]
+
+        @connection = self.connect
+      end
+
+      # returns database version in SQL form
+      def get_database_version
+        execute_sql 'SELECT version();'
+      end
+
+      # returns database tranasction and row activity for the DB
+      def database_query
+        execute_sql "SELECT * FROM pg_stat_database WHERE datname='#{@dbname}';"
+      end
+
+      # returns Scheduled and Requested Checkpoints
+      def bgwriter_query
+        execute_sql 'SELECT * FROM pg_stat_bgwriter;'
+      end
+
+      # count of indexes in the database
+      def index_count_query
+        execute_sql "SELECT count(1) as indexes FROM pg_class WHERE relkind = 'i';"
+      end
+
+      def index_size_query
+        execute_sql 'SELECT sum(relpages::bigint*8192) AS size FROM pg_class WHERE reltype = 0;'
+      end
+
+      # show the count of sequential scans by table descending by order
+      def seq_scans
+        execute_sql 'SELECT relname AS name, seq_scan as count FROM pg_stat_user_tables ORDER BY seq_scan DESC;'
+      end
+
+      # show all tables and the number of rows in each ordered by number of rows descending
+      def records_rank
+        execute_sql 'SELECT relname AS name, n_live_tup AS estimated_count FROM pg_stat_user_tables ORDER BY n_live_tup DESC;'
+      end
+
+      # list all non-template DBs known
+      def list_databases
+        execute_sql 'SELECT datname FROM pg_database WHERE datistemplate = false;'
+      end
+
+      # returns Active and Idle connections from DB
+      def backend_query
+        sql = %Q(
+          SELECT ( SELECT count(*) FROM pg_stat_activity WHERE
+            #{
+              if nine_two?
+                "state <> 'idle'"
+              else
+                "current_query <> '<IDLE>'"
+              end
+            }
+          ) AS backends_active, ( SELECT count(*) FROM pg_stat_activity WHERE
+            #{
+              if nine_two?
+                "state = 'idle'"
+              else
+                "current_query = '<IDLE>'"
+              end
+            }
+          ) AS backends_idle FROM pg_stat_activity;
+        )
+
+        execute_sql(sql)
+      end
+
+      # calculates your cache hit rate (effective databases are at 99% and up)
+      def cache_hit
+        sql = %q(
+          SELECT
+            'index hit rate' AS name,
+            (sum(idx_blks_hit)) / nullif(sum(idx_blks_hit + idx_blks_read),0) AS ratio
+          FROM
+            pg_statio_user_indexes
+          UNION ALL
+          SELECT
+            'table hit rate' AS name,
+            sum(heap_blks_hit) / nullif(sum(heap_blks_hit) + sum(heap_blks_read),0) AS ratio
+          FROM
+            pg_statio_user_tables;
+        )
+
+        execute_sql(sql)
+      end
+
+      # show table and index bloat in your database ordered by most wasteful
+      def database_bloat
+         sql = %q(
+            WITH constants AS (
+                    SELECT current_setting('block_size')::numeric AS bs, 23 AS hdr, 4 AS ma
+                  ), bloat_info AS (
+                    SELECT
+                      ma,bs,schemaname,tablename,
+                      (datawidth+(hdr+ma-(case when hdr%ma=0 THEN ma ELSE hdr%ma END)))::numeric AS datahdr,
+                      (maxfracsum*(nullhdr+ma-(case when nullhdr%ma=0 THEN ma ELSE nullhdr%ma END))) AS nullhdr2
+                    FROM (
+                      SELECT
+                        schemaname, tablename, hdr, ma, bs,
+                        SUM((1-null_frac)*avg_width) AS datawidth,
+                        MAX(null_frac) AS maxfracsum,
+                        hdr+(
+                          SELECT 1+count(*)/8
+                          FROM pg_stats s2
+                          WHERE null_frac<>0 AND s2.schemaname = s.schemaname AND s2.tablename = s.tablename
+                        ) AS nullhdr
+                      FROM pg_stats s, constants
+                      GROUP BY 1,2,3,4,5
+                    ) AS foo
+                  ), table_bloat AS (
+                    SELECT
+                      schemaname, tablename, cc.relpages, bs,
+                      CEIL((cc.reltuples*((datahdr+ma-
+                        (CASE WHEN datahdr%ma=0 THEN ma ELSE datahdr%ma END))+nullhdr2+4))/(bs-20::float)) AS otta
+                    FROM bloat_info
+                      JOIN pg_class cc ON cc.relname = bloat_info.tablename
+                      JOIN pg_namespace nn ON cc.relnamespace = nn.oid AND nn.nspname = bloat_info.schemaname AND nn.nspname <> 'information_schema'
+                  ), index_bloat AS (
+                    SELECT
+                      schemaname, tablename, bs,
+                      COALESCE(c2.relname,'?') AS iname, COALESCE(c2.reltuples,0) AS ituples, COALESCE(c2.relpages,0) AS ipages,
+                      COALESCE(CEIL((c2.reltuples*(datahdr-12))/(bs-20::float)),0) AS iotta -- very rough approximation, assumes all cols
+                    FROM bloat_info
+                      JOIN pg_class cc ON cc.relname = bloat_info.tablename
+                      JOIN pg_namespace nn ON cc.relnamespace = nn.oid AND nn.nspname = bloat_info.schemaname AND nn.nspname <> 'information_schema'
+                      JOIN pg_index i ON indrelid = cc.oid
+                      JOIN pg_class c2 ON c2.oid = i.indexrelid
+                  )
+                  SELECT
+                    type, schemaname, object_name, bloat, pg_size_pretty(raw_waste) as waste
+                  FROM
+                  (SELECT
+                    'table' as type,
+                    schemaname,
+                    tablename as object_name,
+                    ROUND(CASE WHEN otta=0 THEN 0.0 ELSE table_bloat.relpages/otta::numeric END,1) AS bloat,
+                    CASE WHEN relpages < otta THEN '0' ELSE (bs*(table_bloat.relpages-otta)::bigint)::bigint END AS raw_waste
+                  FROM
+                    table_bloat
+                      UNION
+                  SELECT
+                    'index' as type,
+                    schemaname,
+                    tablename || '::' || iname as object_name,
+                    ROUND(CASE WHEN iotta=0 OR ipages=0 THEN 0.0 ELSE ipages/iotta::numeric END,1) AS bloat,
+                    CASE WHEN ipages < iotta THEN '0' ELSE (bs*(ipages-iotta))::bigint END AS raw_waste
+                  FROM
+                    index_bloat) bloat_summary
+                  ORDER BY raw_waste DESC, bloat DESC
+            )
+
+          execute_sql(sql)
+      end
+
+      # show dead rows and whether an automatic vacuum is expected to be triggered
+      def vacuum_stats
+         sql = %q(
+          WITH table_opts AS (
+            SELECT
+              pg_class.oid, relname, nspname, array_to_string(reloptions, '') AS relopts
+            FROM
+               pg_class INNER JOIN pg_namespace ns ON relnamespace = ns.oid
+          ), vacuum_settings AS (
+            SELECT
+              oid, relname, nspname,
+              CASE
+                WHEN relopts LIKE '%autovacuum_vacuum_threshold%'
+                  THEN regexp_replace(relopts, '.*autovacuum_vacuum_threshold=([0-9.]+).*', E'\\\\\\1')::integer
+                  ELSE current_setting('autovacuum_vacuum_threshold')::integer
+                END AS autovacuum_vacuum_threshold,
+              CASE
+                WHEN relopts LIKE '%autovacuum_vacuum_scale_factor%'
+                  THEN regexp_replace(relopts, '.*autovacuum_vacuum_scale_factor=([0-9.]+).*', E'\\\\\\1')::real
+                  ELSE current_setting('autovacuum_vacuum_scale_factor')::real
+                END AS autovacuum_vacuum_scale_factor
+            FROM
+              table_opts
+          )
+          SELECT
+            vacuum_settings.nspname AS schema,
+            vacuum_settings.relname AS table,
+            to_char(psut.last_vacuum, 'YYYY-MM-DD HH24:MI') AS last_vacuum,
+            to_char(psut.last_autovacuum, 'YYYY-MM-DD HH24:MI') AS last_autovacuum,
+            to_char(pg_class.reltuples, '9G999G999G999') AS rowcount,
+            to_char(psut.n_dead_tup, '9G999G999G999') AS dead_rowcount,
+            to_char(autovacuum_vacuum_threshold
+                 + (autovacuum_vacuum_scale_factor::numeric * pg_class.reltuples), '9G999G999G999') AS autovacuum_threshold,
+            CASE
+              WHEN autovacuum_vacuum_threshold + (autovacuum_vacuum_scale_factor::numeric * pg_class.reltuples) < psut.n_dead_tup
+              THEN 'yes'
+            END AS expect_autovacuum
+          FROM
+            pg_stat_user_tables psut INNER JOIN pg_class ON psut.relid = pg_class.oid
+              INNER JOIN vacuum_settings ON pg_class.oid = vacuum_settings.oid
+          ORDER BY 1
+       )
+
+        execute_sql(sql)
+      end
+
+     ## INDEX queries
+     # calculates your index hit rate
+     def index_usage
+       sql = %q(
+          SELECT
+            relname,
+             CASE idx_scan
+               WHEN 0 THEN 'Insufficient data'
+               ELSE (100 * idx_scan / (seq_scan + idx_scan))::text
+             END percent_of_times_index_used,
+             n_live_tup rows_in_table
+           FROM
+             pg_stat_user_tables
+           ORDER BY
+             n_live_tup DESC;
+        )
+
+       execute_sql(sql)
+     end
+
+     # show the total size of all indexes in MB
+     def total_index_size
+       sql = %q(
+          SELECT
+            pg_size_pretty(sum(c.relpages::bigint*8192)::bigint) AS size
+          FROM
+            pg_class c
+            LEFT JOIN pg_namespace n ON (n.oid = c.relnamespace)
+          WHERE
+            n.nspname NOT IN ('pg_catalog', 'information_schema')
+            AND n.nspname !~ '^pg_toast'
+            AND c.relkind='i';
+       )
+
+       self.execute(sql)
+     end
+
+     # show the size of indexes, descending by size
+     def index_size
+        sql = %q(
+          SELECT
+            c.relname AS name,
+            pg_size_pretty(sum(c.relpages::bigint*8192)::bigint) AS size
+          FROM
+            pg_class c
+            LEFT JOIN pg_namespace n ON (n.oid = c.relnamespace)
+          WHERE
+            n.nspname NOT IN ('pg_catalog', 'information_schema')
+            AND n.nspname !~ '^pg_toast'
+            AND c.relkind='i'
+          GROUP BY
+            c.relname
+          ORDER BY
+            sum(c.relpages) DESC;
+        )
+        execute_sql(sql)
+     end
+
+     # show unused and almost unused indexes, ordered by their size relative to
+     # the number of index scans. Exclude indexes of very small tables (less than
+     # 5 pages), where the planner will almost invariably select a sequential
+     # scan, but may not in the future as the table grows.
+     def unused_indexes
+        sql = %q(
+          SELECT
+            schemaname || '.' || relname AS table,
+            indexrelname AS index,
+            pg_size_pretty(pg_relation_size(i.indexrelid)) AS index_size,
+            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 < 50
+            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;
+         )
+
+        execute_sql(sql)
+     end
+
+     ## TABLE QUERIES
+     # show the size of the tables (excluding indexes), descending by size
+     def table_size
+        sql = %q(
+          SELECT
+            c.relname AS name,
+            pg_size_pretty(pg_table_size(c.oid)) AS size
+          FROM
+            pg_class c
+            LEFT JOIN pg_namespace n ON (n.oid = c.relnamespace)
+          WHERE
+            n.nspname NOT IN ('pg_catalog', 'information_schema')
+            AND n.nspname !~ '^pg_toast'
+            AND c.relkind='r'
+          ORDER BY
+          pg_table_size(c.oid) DESC;
+        )
+
+        execute_sql(sql)
+      end
+
+      # show the total size of all the indexes on each table, descending by size
+      def table_indexes_size
+          sql = %q(
+            SELECT
+              c.relname AS table,
+              pg_size_pretty(pg_indexes_size(c.oid)) AS index_size
+            FROM
+              pg_class c
+              LEFT JOIN pg_namespace n ON (n.oid = c.relnamespace)
+            WHERE
+              n.nspname NOT IN ('pg_catalog', 'information_schema')
+              AND n.nspname !~ '^pg_toast'
+              AND c.relkind='r'
+            ORDER BY
+              pg_indexes_size(c.oid) DESC;
+          )
+
+          execute_sql(sql)
+       end
+
+      # show the size of the tables (including indexes), descending by size
+      def total_table_size
+        sql = %q(
+          SELECT
+            c.relname AS name,
+            pg_size_pretty(pg_total_relation_size(c.oid)) AS size
+          FROM
+            pg_class c
+            LEFT JOIN pg_namespace n ON (n.oid = c.relnamespace)
+          WHERE
+            n.nspname NOT IN ('pg_catalog', 'information_schema')
+            AND n.nspname !~ '^pg_toast'
+            AND c.relkind='r'
+          ORDER BY
+            pg_total_relation_size(c.oid) DESC;
+        )
+
+        execute_sql(sql)
+      end
+
+      ## QUERY QUERIES [that feels wrong...]
+      # display queries holding locks other queries are waiting to be released
+      def blocking
+        query_column = self.query_column
+        pid_column = self.pid_column
+        sql = %Q(
+          SELECT
+              bl.pid AS blocked_pid,
+              ka.#{query_column} AS blocking_statement,
+              now() - ka.query_start AS blocking_duration,
+              kl.pid AS blocking_pid,
+              a.#{query_column} AS blocked_statement,
+              now() - a.query_start AS blocked_duration
+          FROM
+              pg_catalog.pg_locks bl
+          JOIN
+              pg_catalog.pg_stat_activity a ON bl.pid = a.#{pid_column}
+          JOIN
+              pg_catalog.pg_locks kl
+          JOIN
+              pg_catalog.pg_stat_activity ka
+              ON kl.pid = ka.#{pid_column}
+              ON bl.transactionid = kl.transactionid AND bl.pid != kl.pid
+          WHERE NOT
+            bl.granted
+        )
+
+        execute_sql(sql)
+      end
+
+      # display queries with active locks
+      def locks
+        query_column = self.query_column
+        pid_column = self.pid_column
+        sql = %Q(
+         SELECT
+            pg_stat_activity.#{pid_column},
+            pg_class.relname,
+            pg_locks.transactionid,
+            pg_locks.granted,
+            pg_stat_activity.#{query_column},
+            age(now(),pg_stat_activity.query_start) AS "age"
+         FROM
+            pg_stat_activity,pg_locks left
+            OUTER JOIN pg_class ON (pg_locks.relation = pg_class.oid)
+         WHERE
+            pg_stat_activity.#{query_column} <> '<insufficient privilege>'
+            AND pg_locks.pid = pg_stat_activity.#{pid_column}
+            AND pg_locks.mode = 'ExclusiveLock'
+            AND pg_stat_activity.#{pid_column} <> pg_backend_pid() order by query_start;
+        )
+
+        execute_sql(sql)
+      end
+
+      # show all queries longer than five minutes by descending duration
+      def long_running_queries
+        query_column = self.query_column
+        pid_column = self.pid_column
+        sql = %Q(
+          SELECT
+            #{pid_column},
+            now() - pg_stat_activity.query_start AS duration,
+            #{query_column} AS query
+          FROM
+            pg_stat_activity
+          WHERE
+            pg_stat_activity.#{query_column} <> ''::text
+            #{
+              if nine_two?
+                "AND state <> 'idle'"
+              else
+                "AND current_query <> '<IDLE>'"
+              end
+            }
+            AND now() - pg_stat_activity.query_start > interval '5 minutes'
+          ORDER BY
+            now() - pg_stat_activity.query_start DESC;
+        )
+
+        execute_sql(sql)
+      end
+
+      ##PG_STATS_STATEMENTS QUERIES
+      # reset pg_stats
+      def reset_pg_stats_statements
+        return unless extension_loaded? 'pg_stat_statements'
+        execute_sql 'SELECT pg_stat_statements_reset();'
+      end
+      # show 10 queries that have longest execution time in aggregate.
+      # needs pg_stat_statements extension
+      def outliers
+        return unless extension_loaded? 'pg_stat_statements'
+
+        sql = %q(
+            SELECT
+              query AS qry,
+              interval '1 millisecond' * total_time AS total_exec_time,
+              to_char((total_time/sum(total_time) OVER()) * 100, 'FM90D0') || '%'  AS prop_exec_time,
+              to_char(calls, 'FM999G999G999G990') AS ncalls,
+              interval '1 millisecond' * (blk_read_time + blk_write_time) AS sync_io_time
+            FROM
+              pg_stat_statements WHERE userid = (SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1)
+            ORDER BY
+            total_time DESC LIMIT 10
+        )
+
+        execute_sql(sql)
+      end
+
+      # show 10 most frequently called queries
+      # This is dependent on the pg_stat_statements being loaded
+      def calls
+        return unless extension_loaded? 'pg_stat_statements'
+        sql = %Q(
+          SELECT
+            query AS qry,
+            interval '1 millisecond' * total_time AS exec_time,
+            to_char((total_time/sum(total_time) OVER()) * 100, 'FM90D0') || '%'  AS prop_exec_time,
+            to_char(calls, 'FM999G999G990') AS ncalls,
+            interval '1 millisecond' * (blk_read_time + blk_write_time) AS sync_io_time
+        FROM
+          pg_stat_statements WHERE userid = (SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1)
+        ORDER BY
+          calls DESC LIMIT 10
+        )
+
+        execute_sql(sql)
+      end
+
+      ## GENERAL METHODS
+      def connect
+        PG::Connection.new(:host => @host, :port => @port, :user => @user, :password => @password, :sslmode => @sslmode, :dbname => @dbname)
+      end
+
+      def port
+        @port || 5432
+      end
+
+      # Certain queries are dependent on the Postgres version
+      def nine_two?
+        @connection.server_version >= 90200
+      end
+
+      def query_column
+        nine_two? ? 'query' : 'current_query'
+      end
+
+      def pid_column
+        nine_two? ? 'pid' : 'procpid'
+      end
+
+      def extension_loaded?(extname)
+        @connection.exec("SELECT count(*) FROM pg_extension WHERE extname = '#{extname}'") do |result|
+          result[0]['count'] == '1'
+        end
+      end
+
+      def close_connection
+        @connection.close
+      end
+
+      private
+      def execute_sql(query)
+        @connection.exec(query)
+      end
+  end
+end

data/lib/postgres_monitor/version.rb

@@ -0,0 +1,3 @@
+module PostgresMonitor
+  VERSION = '0.1.0'
+end

data/lib/postgres_monitor.rb

@@ -0,0 +1,7 @@
+require 'postgres_monitor/version'
+require 'postgres_monitor/monitor'
+require 'pg'
+
+module PostgresMonitor
+
+end

data/postgres_monitor.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'postgres_monitor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'postgres_monitor'
+  spec.version       = PostgresMonitor::VERSION
+  spec.authors       = ['Scott Shea']
+  spec.email         = ['scott.j.shea@gmail.com']
+
+  spec.summary       = %q{Gem to help monitor Postgres Instances}
+  spec.description   = %q{This gem is designed to open up SQL queries programatically so that Postgres Databases can be easily monitored}
+  spec.homepage      = 'https://github.com/scottshea/postgres_monitor'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency('pg', '~> 0.17', '>= 0.17.0')
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: postgres_monitor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Scott Shea
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-07-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem is designed to open up SQL queries programatically so that Postgres
+  Databases can be easily monitored
+email:
+- scott.j.shea@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/postgres_monitor.rb
+- lib/postgres_monitor/monitor.rb
+- lib/postgres_monitor/version.rb
+- postgres_monitor.gemspec
+homepage: https://github.com/scottshea/postgres_monitor
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Gem to help monitor Postgres Instances
+test_files: []
+has_rdoc: