postgrestats 1.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,19 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+gem "pg"
+gem "gmetric"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.8.0"
+  gem "yard", "~> 0.7"
+  gem "rdoc", "~> 3.12"
+  gem "cucumber", ">= 0"
+  gem "bundler", "> 1.0.0"
+  gem "jeweler", "~> 1.8.3"
+  gem (RUBY_VERSION =~ /^1\.9/ ? "simplecov" : "rcov"), ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Artem Veremey
+
+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,19 @@
+= postgrestats
+
+Postgrestats is a library that captures important PostgreSQL statistics.
+
+== Contributing to postgrestats
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Artem Veremey. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "postgrestats"
+  gem.homepage = "http://github.com/aia/postgrestats"
+  gem.license = "MIT"
+  gem.summary = %Q{Postgrestats is a library that captures important PostgreSQL statistics}
+  gem.description = %Q{Postgrestats is a library that captures important PostgreSQL statistics}
+  gem.email = "artem@veremey.net"
+  gem.authors = ["Artem Veremey"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+if RUBY_VERSION =~ /^1\.9/
+  desc "Code coverage detail"
+  task :simplecov do
+    ENV['COVERAGE'] = "true"
+    Rake::Task['spec'].execute
+  end
+else
+  RSpec::Core::RakeTask.new(:rcov) do |spec|
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.rcov = true
+  end
+end
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new(:features)
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/bin/postgrestats

@@ -0,0 +1,181 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'postgrestats'
+require 'yaml'
+require 'gmetric'
+
+@counter_list = {}
+
+def counter_to_gauge(prefix, counter, value)
+  field_name = [prefix, counter].join("_")
+  if @counter_list[field_name].nil?
+    @counter_list[field_name] = value.to_f
+    return 0.0
+  else
+    ret = value.to_f - @counter_list[field_name]
+    @counter_list[field_name] = value.to_f
+    return ret
+  end
+end
+
+def publish_table_metric(stats_ds, publish_host, name, value, slope, units)
+  type = @watch_table_double.include?(name) ? 'double' : 'uint32'
+  c_value = @watch_table_double.include?(name) ? value.to_f : value.to_i
+
+  Ganglia::GMetric.send(
+    stats_ds.config['gmond']['tables']['host'],
+    stats_ds.config['gmond']['tables']['port'], {
+      :name => name,
+      :units => units,
+      :type => type,
+      :value => c_value,
+      :tmax => 60,
+      :dmax => 300,
+      :group => 'staging_tables',
+      :slope => slope,
+      :spoof => 1,
+      :hostname => "#{publish_host}:#{publish_host}"
+   })
+end
+
+def publish_aggregate_metric(stats_ds, publish_host, name, value, slope, units)
+  type = @watch_aggregate_double.include?(name) ? 'double' : 'uint32'
+  c_value = @watch_aggregate_double.include?(name) ? value.to_f : value.to_i
+
+  Ganglia::GMetric.send(
+    stats_ds.config['gmond']['aggregate']['host'],
+    stats_ds.config['gmond']['aggregate']['port'], {
+      :name => name,
+      :units => units,
+      :type => type,
+      :value => c_value,
+      :tmax => 60,
+      :dmax => 300,
+      :group => 'staging_aggregate',
+      :slope => slope,
+      :spoof => 1,
+      :hostname => "#{publish_host}:#{publish_host}"
+  })
+end
+
+def publish_hierarchy(stats_ds, tree)
+  tree.each_key do |table_name|
+    if table_name =~ /aggregate/
+      tree[table_name].each_key do |metric|
+        publish_aggregate_metric(
+          stats_ds,
+          table_name,
+          metric,
+          tree[table_name][metric]['value'],
+          tree[table_name][metric]['slope'],
+          tree[table_name][metric]['units']
+        )
+      end
+    else
+      tree[table_name].each_key do |metric|
+        publish_table_metric(
+          stats_ds,
+          table_name,
+          metric,
+          tree[table_name][metric]['value'],
+          tree[table_name][metric]['slope'],
+          tree[table_name][metric]['units']
+        )
+      end
+    end
+  end
+end
+
+
+STDOUT.sync = true
+
+usage = <<-USAGE
+  postgrestats <configuration file>
+USAGE
+
+if !ARGV[0].nil? && File.exists?(ARGV[0])
+  config = YAML.load_file(ARGV[0])
+else
+  puts usage
+  exit
+end
+
+stats = PostgreStats.new(config)
+
+dbs = stats.get_databases
+
+@table_metrics = stats.get_table_metrics
+@aggregate_metrics = stats.get_aggregate_metrics
+@watch_aggregate_double = stats.get_aggregate_ganglia_double
+@watch_table_double = stats.get_table_ganglia_double
+
+hierarchy = {}
+
+while (true)
+  begin
+    dbs.each do |database|
+      time_start = Time.now()
+      
+      hierarchy["#{database}_aggregate"] = {}
+      
+      stats.table_gauges.each_key do |gauge|
+        stats.send(stats.table_gauges[gauge]['handler'].to_sym, database).each do |table, value|
+          hierarchy["#{database}_#{table}"] ||= {}
+          hierarchy["#{database}_#{table}"][gauge] = {}
+          hierarchy["#{database}_#{table}"][gauge]['value'] = value
+          hierarchy["#{database}_#{table}"][gauge]['units'] = stats.table_gauges[gauge]['units']
+          hierarchy["#{database}_#{table}"][gauge]['slope'] = 'both'
+        end
+      end
+  
+      stats.table_counters.each_key do |counter|
+        stats.send(stats.table_counters[counter]['handler'].to_sym, database).each do |table, value|
+          hierarchy["#{database}_#{table}"] ||= {}
+          hierarchy["#{database}_#{table}"][counter] = {}
+          hierarchy["#{database}_#{table}"][counter]['value'] = counter_to_gauge(
+            "#{database}_#{table}",
+            counter,
+            value
+          )
+          hierarchy["#{database}_#{table}"][counter]['units'] = stats.table_counters[counter]['units']
+          hierarchy["#{database}_#{table}"][counter]['slope'] = 'both'
+        end
+      end
+  
+      hierarchy["#{database}_aggregate"] = {}
+      
+      stats.aggregate_gauges.each_key do |gauge|
+        hierarchy["#{database}_aggregate"][gauge] = {}
+        hierarchy["#{database}_aggregate"][gauge]['value'] = stats.send(
+          stats.aggregate_gauges[gauge]['handler'].to_sym, database
+        )
+        hierarchy["#{database}_aggregate"][gauge]['units'] = stats.aggregate_gauges[gauge]['units']
+        hierarchy["#{database}_aggregate"][gauge]['slope'] = 'both'
+      end
+  
+      stats.aggregate_counters.each_key do |counter|
+        hierarchy["#{database}_aggregate"][counter] = {}
+        hierarchy["#{database}_aggregate"][counter]['value'] = counter_to_gauge(
+          "#{database}_aggregate",
+          counter,
+          stats.send(stats.aggregate_counters[counter]['handler'].to_sym, database)
+        )
+        hierarchy["#{database}_aggregate"][counter]['units'] = stats.aggregate_counters[counter]['units']
+        hierarchy["#{database}_aggregate"][counter]['slope'] = 'both'
+      end
+      
+      time_mid = Time.now
+      stats.log.info("Processed #{database} database in #{time_mid - time_start}")
+      
+      publish_hierarchy(stats, hierarchy)
+      hierarchy = {}
+    end
+  rescue Exception => e  
+    puts e.message  
+    puts e.backtrace.inspect
+  end
+  
+  sleep(config['sleep'] || 30)
+end

data/config/example.yml

@@ -0,0 +1,18 @@
+host: your database host
+user: the user to access your database
+password: user password to access te database
+dbname: initial database to connect to
+gmond:
+  tables:
+    host: your gmond host to send table data to
+    port: gmond port to send table data to
+    group: group name to publish table data as
+  aggregate:
+    host: your gmond host to send aggregate data to
+    port: gmond port to send aggregate data to
+    group: group name to publish aggregate data as
+exclude_dbs:
+  - template0
+  - template1
+  - postgres
+  - repmgr

data/features/postgrestats.feature

@@ -0,0 +1,9 @@
+Feature: something something
+  In order to something something
+  A user something something
+  something something something
+
+  Scenario: something something
+    Given inspiration
+    When I create a sweet new gem
+    Then everyone should see how awesome I am

data/features/support/env.rb

@@ -0,0 +1,13 @@
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'postgrestats'
+
+require 'rspec/expectations'

data/lib/postgrestats.rb

@@ -0,0 +1,747 @@
+require 'pg'
+require 'logger'
+
+class PostgreStats
+  
+  attr_accessor :config, :connection, :db, :log
+  attr_accessor :table_gauges, :table_counters, :aggregate_gauges, :aggregate_counters
+  
+  def initialize(config, logger = nil)
+    @config = config
+    
+    initialize_log unless logger
+    @log = logger if logger
+    @log.error("Logging started")
+    
+    initialize_metrics
+  end
+  
+  def initialize_log
+    @config['log'] = {
+      'file' => STDOUT,
+      'level' => 'INFO'
+    }.merge(@config['log'] || {})
+    
+    log_initialize = [@config['log']['file']]
+    log_initialize << @config['log']['shift_age'] if @config['log']['shift_age']
+    log_initialize << @config['log']['shift_size'] if @config['log']['shift_size']
+    
+    begin
+      @log = Logger.new(*log_initialize)
+      @log.level = Logger.const_get(@config['log']['level'])
+    rescue Exception => e
+      @config['log'] = {
+        'file' => STDOUT,
+        'level' => 'INFO'
+      }
+      @log = Logger.new(@config['log']['file'])
+      @log.level = Logger.const_get(@config['log']['level'])
+      @log.error("Caught a problem with log settings")
+      @log.error("#{e.message}")
+      @log.error("Setting log settings to defaults")
+    end
+  end
+  
+  def initialize_metrics
+    @table_gauges = {
+      'table_size' => {
+        'units' => 'bytes',
+        'handler' => :get_table_sizes
+      },
+      'index_size' => {
+        'units' => 'bytes',
+        'handler' => :get_index_sizes
+      },
+      'estimated_rows' => {
+        'units' => 'rows',
+        'handler' => :get_tables_estimated_rows
+      },
+      'dead' => {
+        'units' => 'rows',
+        'handler' => :get_dead_per_table
+      }, 
+      'last_vacuum' => {
+        'units' => 'seconds since',
+        'handler' => :get_last_autovacuum_per_table
+      }
+    }
+    
+    @table_counters = {
+      'inserts' => {
+        'units' => 'inserts/s',
+        'ganglia_double' => true,
+        'handler' => :get_inserts_per_table
+      }, 
+      'updates' => {
+        'units' => 'updates/s',
+        'ganglia_double' => true,
+        'handler' => :get_updates_per_table
+      },
+      'deletes' => {
+        'units' => 'deletes/s',
+        'ganglia_double' => true,
+        'handler' => :get_deletes_per_table
+      },
+      'hot_updates' => {
+        'units' => 'updates/s',
+        'ganglia_double' => true,
+        'handler' => :get_hot_updates_per_table
+      },
+      'seq_scan' => {
+        'units' => 'scans/s',
+        'ganglia_double' => true,
+        'handler' => :get_sequential_scans_per_table
+      },
+      'idx_scan' => {
+        'units' => 'scans/s',
+        'ganglia_double' => true,
+        'handler' => :get_index_scans_per_table
+      },
+      'seq_tup_read' => {
+        'units' => 'rows/s',
+        'ganglia_double' => true,
+        'handler' => :get_sequential_rows_read_per_table
+      },
+      'idx_tup_fetch' => {
+        'units' => 'rows/s',
+        'ganglia_double' => true,
+        'handler' => :get_index_rows_fetched_per_table
+      },
+      'heap_blks_read' => {
+        'units' => 'blocks/s',
+        'ganglia_double' => true,
+        'handler' => :get_heap_blocks_read_per_table
+      },
+      'heap_blks_hit' => {
+        'units' => 'blocks/s',
+        'ganglia_double' => true,
+        'handler' => :get_heap_blocks_hit_per_table
+      },
+      'idx_blks_read' => {
+        'units' => 'blocks/s',
+        'ganglia_double' => true,
+        'handler' => :get_index_blocks_read_per_table
+      },
+      'idx_blks_hit' => {
+        'units' => 'blocks/s',
+        'ganglia_double' => true,
+        'handler' => :get_index_blocks_hit_per_table
+      }
+    }
+    
+    @aggregate_gauges = {
+      'locks' => {
+        'units' => 'locks',
+        'handler' => :get_number_of_locks_per_database
+      },
+      'connections' => {
+        'units' => 'connections',
+        'handler' => :get_connections_per_database
+      }
+    }
+    
+    @aggregate_counters = {
+      'blocks_fetched' => {
+        'units' => 'blocks/s',
+        'ganglia_double' => true,
+        'handler' => :get_blocks_fetched_per_database
+      },
+      'blocks_hit' => {
+        'units' => 'blocks/s',
+        'ganglia_double' => true,
+        'handler' => :get_blocks_hit_per_database
+      },
+      'commits' => {
+        'units' => 'commits/s',
+        'ganglia_double' => true,
+        'handler' => :get_commits_per_database
+      },
+      'rollbacks' => {
+        'units' => 'rollbacks/s',
+        'ganglia_double' => true,
+        'handler' => :get_rollbacks_per_database
+      },
+      'inserts' => {
+        'units' => 'inserts/s',
+        'ganglia_double' => true,
+        'handler' => :get_inserts_per_database
+      },
+      'updates' => {
+        'units' => 'updates/s',
+        'ganglia_double' => true,
+        'handler' => :get_updates_per_database
+      },
+      'deletes' => {
+        'units' => 'deletes/s',
+        'ganglia_double' => true,
+        'handler' => :get_deletes_per_database
+      }
+    }
+  end
+  
+  def connect(db)
+    return if connection and (@db == db)
+    
+    connection.close if @db == db
+    
+    tmp_config ={
+      'host' => @config['host'],
+      'user' => @config['user'],
+      'password' => @config['password'],
+      'dbname' => db
+    }
+    
+    @connection = PG.connect(tmp_config)
+    @db = db
+  end
+  
+  def run_query(db, query)
+    connect(db)
+    
+    result = @connection.exec(query)
+    fields = result.fields
+    ret = []
+    
+    result.each do |row|
+      item = {}
+      fields.each { |field| item[field] = row[field] }
+      ret << item
+    end
+    
+    return ret
+  end
+  
+  def get_table_metrics()
+    return [table_gauges.keys, table_counters.keys].flatten
+  end
+  
+  def get_aggregate_metrics()
+    return [aggregate_gauges.keys, aggregate_counters.keys].flatten
+  end
+  
+  def get_table_ganglia_double()
+    return [
+      table_gauges.select{ |k, v| v.has_key?('ganglia_double') }.keys,
+      table_counters.select{ |k, v| v.has_key?('ganglia_double') }.keys
+    ].flatten
+  end
+  
+  def get_aggregate_ganglia_double()
+    return [
+      aggregate_gauges.select{ |k, v| v.has_key?('ganglia_double') }.keys,
+      aggregate_counters.select{ |k, v| v.has_key?('ganglia_double') }.keys
+    ].flatten
+  end
+  
+  def get_databases()
+    query = <<-END_GET_DATABASES_QUERY
+      SELECT pg_database.datname AS "Database", pg_user.usename AS "Owner"
+      FROM pg_database, pg_user
+      WHERE pg_database.datdba = pg_user.usesysid
+      UNION
+      SELECT pg_database.datname AS "Database", NULL AS "Owner"
+      FROM pg_database
+      WHERE pg_database.datdba NOT IN (SELECT usesysid FROM pg_user)
+      ORDER BY "Database"
+    END_GET_DATABASES_QUERY
+    
+    ret = run_query('postgres', query)
+    
+    ret.select!{ |v| not @config['exclude_dbs'].include?(v['Database']) }.map!{ |v| v['Database'] }
+    
+    return ret
+  end
+  
+  def get_tables(db)
+    query = <<-END_GET_TABLES_QUERY
+      SELECT c.relname FROM pg_catalog.pg_class c
+      LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+      WHERE c.relkind IN ('r','') AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
+      AND pg_catalog.pg_table_is_visible(c.oid)
+    END_GET_TABLES_QUERY
+    
+    ret = run_query(db, query)
+    
+    ret.map!{ |v| v['relname'] }
+    
+    return ret
+  end
+  
+   # * size per database/table
+   def get_table_sizes(db)
+     query = <<-END_GET_TABLE_SIZES_QUERY
+       SELECT table_name,pg_relation_size(table_name) AS size
+       FROM information_schema.tables
+       WHERE table_schema NOT IN ('information_schema', 'pg_catalog') AND table_type = 'BASE TABLE'
+     END_GET_TABLE_SIZES_QUERY
+     
+     ret = run_query(db, query)
+     
+     ret.map!{ |v| [v['table_name'], v['size'].to_i] }
+     
+     return Hash[*ret.flatten]
+   end
+   
+   # * size of indexes
+   def get_index_sizes(db)
+     query = <<-END_GET_INDEX_SIZES_QUERY
+       SELECT table_name,(pg_total_relation_size(table_name) - pg_relation_size(table_name)) AS size
+       FROM information_schema.tables
+       WHERE table_schema NOT IN ('information_schema', 'pg_catalog') AND table_type = 'BASE TABLE'
+     END_GET_INDEX_SIZES_QUERY
+     
+     ret = run_query(db, query)
+     
+     ret.map!{ |v| [v['table_name'], v['size'].to_i] }
+     
+     return Hash[*ret.flatten]
+   end
+   
+   # * size of individual indexes
+   # SELECT c3.relname AS "Table",
+   #        c2.relname AS "Index",
+   #        pg_size_pretty(pg_relation_size(c3.relname::text)) AS "Data Size",
+   #        pg_size_pretty(pg_relation_size(c2.relname::text)) AS "Index Size",
+   #        pg_size_pretty(pg_total_relation_size(c3.relname::text)) AS "Total"
+   #   FROM pg_class c2
+   #   LEFT JOIN pg_index i  ON c2.oid = i.indexrelid
+   #   LEFT JOIN pg_class c1 ON c1.oid = i.indrelid
+   #  RIGHT OUTER JOIN pg_class c3 ON c3.oid = c1.oid
+   #   LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c3.relnamespace
+   #  WHERE c3.relkind IN ('r','')
+   #    AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
+   #    AND pg_catalog.pg_table_is_visible(c3.oid)
+   #  ORDER BY c3.relpages DESC;
+   
+   # * estimated rows per database/table
+   def get_table_estimated_rows(db, table)
+     query = <<-END_GET_TABLE_ESTIMATED_ROWS_QUERY
+       SELECT (
+         CASE 
+         WHEN reltuples > 0 THEN pg_relation_size('#{table}')/(8192*relpages::bigint/reltuples)
+         ELSE 0
+         END
+       )::bigint AS estimated_row_count
+       FROM pg_class
+       WHERE oid = '#{table}'::regclass;
+     END_GET_TABLE_ESTIMATED_ROWS_QUERY
+     
+     ret = run_query(db, query)
+     
+     return ret.first['estimated_row_count'].to_i
+   end
+   
+   # * estimated rows for every table in the database
+   def get_tables_estimated_rows(db)
+     ret = {}
+     
+     get_tables(db).each do |table|
+        ret[table] = get_table_estimated_rows(db, table)
+     end
+     
+     return ret
+   end
+   
+   # * number of connections
+   def get_connections_per_database(db = nil)
+     query = <<-END_GET_CONNECTIONS_PER_DATABASE_QUERY
+       SELECT datname, count(*) FROM pg_stat_activity GROUP BY datname;
+     END_GET_CONNECTIONS_PER_DATABASE_QUERY
+     
+     ret = run_query('postgres', query)
+     
+     ret.select!{ |v| not @config['exclude_dbs'].include?(v['datname']) }.map!{ |v| [v['datname'], v['count'].to_i] }
+     
+     if db
+       res = Hash[*ret.flatten][db].to_i || 0
+     else
+       res = Hash[*ret.flatten]
+     end
+     
+     return res
+   end
+   
+   # * dead unused space taken up in a table or index
+   # * number of seconds since the last checkpoint per database
+   # * number of seconds since the last autovacuum per database/table
+   
+   def get_last_autovacuum_per_table(db)
+     query = <<-END_GET_LAST_AUTOVACUUM_PER_DATABASE_QUERY
+       SELECT current_database() AS datname, nspname AS sname, relname AS tname,
+         CASE WHEN v IS NULL THEN -1 ELSE round(extract(epoch FROM now()-v)) END AS ltime
+       FROM (
+         SELECT nspname, relname, pg_stat_get_last_autovacuum_time(c.oid) AS v
+         FROM pg_class c, pg_namespace n
+         WHERE relkind = 'r'
+         AND n.oid = c.relnamespace
+         AND n.nspname <> 'information_schema'
+         AND n.nspname = 'public'
+         ORDER BY 3
+        ) AS foo
+     END_GET_LAST_AUTOVACUUM_PER_DATABASE_QUERY
+     
+     ret = run_query(db, query)
+     
+     ret.map!{ |v| [v['tname'], v['ltime']] }
+     
+     return Hash[*ret.flatten]
+   end
+   
+   # * number of blocks fetched per database
+   
+   def get_blocks_fetched_per_database(db)
+     query = <<-END_GET_BLOCKS_FETCHED_PER_DATABASE_QUERY
+       SELECT pg_stat_get_db_blocks_fetched(oid)
+       FROM pg_database
+       WHERE datname = '#{db}'
+     END_GET_BLOCKS_FETCHED_PER_DATABASE_QUERY
+     
+     ret = run_query(db, query)
+     
+     return ret.first['pg_stat_get_db_blocks_fetched'].to_i
+   end
+   
+   # * number of blocks hit per database
+   
+   def get_blocks_hit_per_database(db)
+     query = <<-END_GET_BLOCK_HITS_PER_DATABASE_QUERY
+       SELECT pg_stat_get_db_blocks_hit(oid)
+       FROM pg_database
+       WHERE datname = '#{db}'
+     END_GET_BLOCK_HITS_PER_DATABASE_QUERY
+     
+     ret = run_query(db, query)
+     
+     return ret.first['pg_stat_get_db_blocks_hit'].to_i
+   end
+   
+   # * number of commits per database
+   
+   def get_commits_per_database(db)
+     query = <<-END_GET_COMMITS_PER_DATABASE_QUERY
+       SELECT pg_stat_get_db_xact_commit(oid)
+       FROM pg_database
+       WHERE datname = '#{db}'
+     END_GET_COMMITS_PER_DATABASE_QUERY
+     
+     ret = run_query(db, query)
+     
+     return ret.first['pg_stat_get_db_xact_commit'].to_i
+   end
+   
+   # * number of rollbacks per database
+   
+   def get_rollbacks_per_database(db)
+     query = <<-END_GET_ROLLBACKS_PER_DATABASE_QUERY
+       SELECT pg_stat_get_db_xact_rollback(oid)
+       FROM pg_database
+       WHERE datname = '#{db}'
+     END_GET_ROLLBACKS_PER_DATABASE_QUERY
+     
+     ret = run_query(db, query)
+     
+     return ret.first['pg_stat_get_db_xact_rollback'].to_i
+   end
+   
+   # * number of disk block reads per database
+   # * number of buffer hits per database
+   # * number of rows returned per database
+   # * number of rows inserted per database
+   
+   def get_inserts_per_database(db)
+     query = <<-END_GET_INSERTS_PER_DATABASE_QUERY
+       SELECT pg_stat_get_db_tuples_inserted(oid)
+       FROM pg_database
+       WHERE datname = '#{db}'
+     END_GET_INSERTS_PER_DATABASE_QUERY
+     
+     ret = run_query(db, query)
+     
+     return ret.first['pg_stat_get_db_tuples_inserted'].to_i
+   end
+   
+   # * number of rows updates per database
+   
+   def get_updates_per_database(db)
+     query = <<-END_GET_UPDATES_PER_DATABASE_QUERY
+       SELECT pg_stat_get_db_tuples_updated(oid)
+       FROM pg_database
+       WHERE datname = '#{db}'
+     END_GET_UPDATES_PER_DATABASE_QUERY
+     
+     ret = run_query(db, query)
+     
+     return ret.first['pg_stat_get_db_tuples_updated'].to_i
+   end
+   
+   # * number of rows deleted per database
+   
+   def get_deletes_per_database(db)
+     query = <<-END_GET_DELETES_PER_DATABASE_QUERY
+       SELECT pg_stat_get_db_tuples_deleted(oid)
+       FROM pg_database
+       WHERE datname = '#{db}'
+     END_GET_DELETES_PER_DATABASE_QUERY
+     
+     ret = run_query(db, query)
+     
+     return ret.first['pg_stat_get_db_tuples_deleted'].to_i
+   end
+   
+   # * number of sequential scans per table
+   # * number of index scans per table
+
+   # * list of locks
+   
+   def get_locks_per_database(db)
+     query = <<-END_GET_LOCKS_PER_DATABASE_QUERY
+       SELECT pid, virtualxid, datname, relname, locktype, mode
+       FROM pg_locks l 
+       LEFT JOIN pg_database d ON (d.oid=l.database)
+       LEFT JOIN pg_class c on (c.oid=l.relation)
+       WHERE datname = '#{db}' AND NOT relname ~ 'pg_'
+     END_GET_LOCKS_PER_DATABASE_QUERY
+     
+     ret = run_query(db, query)
+     
+     return ret
+   end
+   
+   # * number of locks
+   def get_number_of_locks_per_database(db)
+     return get_locks_per_database(db).size
+   end
+   
+   # * number of "idle in transaction" queries per database
+   # * number of open transactions per database
+   
+   # * number of returned rows per table
+   
+   def get_returned_per_table(db)
+      query = <<-END_GET_RETURNED_PER_TABLE_QUERY
+        SELECT c.relname, pg_stat_get_tuples_returned(c.oid) FROM pg_catalog.pg_class c
+        LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relkind IN ('r','') AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
+        AND pg_catalog.pg_table_is_visible(c.oid)
+      END_GET_RETURNED_PER_TABLE_QUERY
+
+      ret = run_query(db, query)
+
+      ret.map!{ |v| [v['relname'], v['pg_stat_get_tuples_returned'].to_i] }
+
+      return Hash[*ret.flatten]
+   end
+   
+   # * number of fetched rows per table
+   
+   def get_fetched_per_table(db)
+      query = <<-END_GET_FETCHED_PER_TABLE_QUERY
+        SELECT c.relname, pg_stat_get_tuples_fetched(c.oid) FROM pg_catalog.pg_class c
+        LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relkind IN ('r','') AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
+        AND pg_catalog.pg_table_is_visible(c.oid)
+      END_GET_FETCHED_PER_TABLE_QUERY
+
+      ret = run_query(db, query)
+
+      ret.map!{ |v| [v['relname'], v['pg_stat_get_tuples_fetched'].to_i] }
+
+      return Hash[*ret.flatten]
+   end
+   
+   # * number of inserted rows per table
+   
+   def get_inserts_per_table(db)
+      query = <<-END_GET_INSERTS_PER_TABLE_QUERY
+        SELECT c.relname, pg_stat_get_tuples_inserted(c.oid) FROM pg_catalog.pg_class c
+        LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relkind IN ('r','') AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
+        AND pg_catalog.pg_table_is_visible(c.oid)
+      END_GET_INSERTS_PER_TABLE_QUERY
+
+      ret = run_query(db, query)
+
+      ret.map!{ |v| [v['relname'], v['pg_stat_get_tuples_inserted'].to_i] }
+
+      return Hash[*ret.flatten]
+   end
+   
+   # * number of updates rows per table
+   
+   def get_updates_per_table(db)
+      query = <<-END_GET_UPDATES_PER_TABLE_QUERY
+        SELECT c.relname, pg_stat_get_tuples_updated(c.oid) FROM pg_catalog.pg_class c
+        LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relkind IN ('r','') AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
+        AND pg_catalog.pg_table_is_visible(c.oid)
+      END_GET_UPDATES_PER_TABLE_QUERY
+
+      ret = run_query(db, query)
+
+      ret.map!{ |v| [v['relname'], v['pg_stat_get_tuples_updated'].to_i] }
+
+      return Hash[*ret.flatten]
+   end
+   
+   def get_hot_updates_per_table(db)
+      query = <<-END_GET_HOT_UPDATES_PER_TABLE_QUERY
+        SELECT c.relname, pg_stat_get_tuples_hot_updated(c.oid) FROM pg_catalog.pg_class c
+        LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relkind IN ('r','') AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
+        AND pg_catalog.pg_table_is_visible(c.oid)
+      END_GET_HOT_UPDATES_PER_TABLE_QUERY
+
+      ret = run_query(db, query)
+
+      ret.map!{ |v| [v['relname'], v['pg_stat_get_tuples_hot_updated'].to_i] }
+
+      return Hash[*ret.flatten]
+   end
+   
+   # * number of deleted rows per table
+   
+   def get_deletes_per_table(db)
+      query = <<-END_GET_DELETES_PER_TABLE_QUERY
+        SELECT c.relname, pg_stat_get_tuples_deleted(c.oid) FROM pg_catalog.pg_class c
+        LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relkind IN ('r','') AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
+        AND pg_catalog.pg_table_is_visible(c.oid)
+      END_GET_DELETES_PER_TABLE_QUERY
+
+      ret = run_query(db, query)
+
+      ret.map!{ |v| [v['relname'], v['pg_stat_get_tuples_deleted'].to_i] }
+
+      return Hash[*ret.flatten]
+   end
+   
+   # * number of dead rows per table
+   
+   def get_dead_per_table(db)
+     query = <<-END_GET_DEAD_PER_TABLE_QUERY
+       SELECT c.relname, pg_stat_get_dead_tuples(c.oid) FROM pg_catalog.pg_class c
+       LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+       WHERE c.relkind IN ('r','') AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
+       AND pg_catalog.pg_table_is_visible(c.oid)
+     END_GET_DEAD_PER_TABLE_QUERY
+
+     ret = run_query(db, query)
+
+     ret.map!{ |v| [v['relname'], v['pg_stat_get_dead_tuples'].to_i] }
+
+     return Hash[*ret.flatten]
+   end
+   
+   def get_sequential_scans_per_table(db)
+     query = <<-END_GET_SEQ_SCANS_PER_TABLE_QUERY
+       SELECT stat.relname AS relname, seq_scan
+       FROM pg_stat_user_tables stat
+       RIGHT JOIN pg_statio_user_tables statio ON stat.relid=statio.relid;
+     END_GET_SEQ_SCANS_PER_TABLE_QUERY
+
+     ret = run_query(db, query)
+
+     ret.map!{ |v| [v['relname'], v['seq_scan'].to_i] }
+
+     return Hash[*ret.flatten]
+   end
+   
+   def get_sequential_rows_read_per_table(db)
+     query = <<-END_GET_SEQ_ROWS_READ_PER_TABLE_QUERY
+       SELECT stat.relname AS relname, seq_tup_read
+       FROM pg_stat_user_tables stat
+       RIGHT JOIN pg_statio_user_tables statio ON stat.relid=statio.relid;
+     END_GET_SEQ_ROWS_READ_PER_TABLE_QUERY
+
+     ret = run_query(db, query)
+
+     ret.map!{ |v| [v['relname'], v['seq_tup_read'].to_i] }
+
+     return Hash[*ret.flatten]
+   end
+   
+   def get_index_scans_per_table(db)
+     query = <<-END_GET_INDEX_SCANS_PER_TABLE_QUERY
+       SELECT stat.relname AS relname, idx_scan
+       FROM pg_stat_user_tables stat
+       RIGHT JOIN pg_statio_user_tables statio ON stat.relid=statio.relid;
+     END_GET_INDEX_SCANS_PER_TABLE_QUERY
+
+     ret = run_query(db, query)
+
+     ret.map!{ |v| [v['relname'], v['idx_scan'].to_i] }
+
+     return Hash[*ret.flatten]
+   end
+   
+   def get_index_rows_fetched_per_table(db)
+     query = <<-END_GET_INDEX_ROWS_FETCHED_PER_TABLE_QUERY
+       SELECT stat.relname AS relname, idx_tup_fetch
+       FROM pg_stat_user_tables stat
+       RIGHT JOIN pg_statio_user_tables statio ON stat.relid=statio.relid;
+     END_GET_INDEX_ROWS_FETCHED_PER_TABLE_QUERY
+
+     ret = run_query(db, query)
+
+     ret.map!{ |v| [v['relname'], v['idx_tup_fetch'].to_i] }
+
+     return Hash[*ret.flatten]
+   end
+   
+   def get_heap_blocks_read_per_table(db)
+     query = <<-END_GET_HEAP_BLOCKS_READ_PER_TABLE_QUERY
+       SELECT stat.relname AS relname, heap_blks_read
+       FROM pg_stat_user_tables stat
+       RIGHT JOIN pg_statio_user_tables statio ON stat.relid=statio.relid;
+     END_GET_HEAP_BLOCKS_READ_PER_TABLE_QUERY
+
+     ret = run_query(db, query)
+
+     ret.map!{ |v| [v['relname'], v['heap_blks_read'].to_i] }
+
+     return Hash[*ret.flatten]
+   end
+   
+   def get_heap_blocks_hit_per_table(db)
+     query = <<-END_GET_HEAP_BLOCKS_HIT_PER_TABLE_QUERY
+       SELECT stat.relname AS relname, heap_blks_hit
+       FROM pg_stat_user_tables stat
+       RIGHT JOIN pg_statio_user_tables statio ON stat.relid=statio.relid;
+     END_GET_HEAP_BLOCKS_HIT_PER_TABLE_QUERY
+
+     ret = run_query(db, query)
+
+     ret.map!{ |v| [v['relname'], v['heap_blks_hit'].to_i] }
+
+     return Hash[*ret.flatten]
+   end
+   
+   def get_index_blocks_read_per_table(db)
+     query = <<-END_GET_INDEX_BLOCKS_READ_PER_TABLE_QUERY
+       SELECT stat.relname AS relname, idx_blks_read
+       FROM pg_stat_user_tables stat
+       RIGHT JOIN pg_statio_user_tables statio ON stat.relid=statio.relid;
+     END_GET_INDEX_BLOCKS_READ_PER_TABLE_QUERY
+
+     ret = run_query(db, query)
+
+     ret.map!{ |v| [v['relname'], v['idx_blks_read'].to_i] }
+
+     return Hash[*ret.flatten]
+   end
+   
+   def get_index_blocks_hit_per_table(db)
+     query = <<-END_GET_INDEX_BLOCKS_HIT_PER_TABLE_QUERY
+       SELECT stat.relname AS relname, idx_blks_hit
+       FROM pg_stat_user_tables stat
+       RIGHT JOIN pg_statio_user_tables statio ON stat.relid=statio.relid;
+     END_GET_INDEX_BLOCKS_HIT_PER_TABLE_QUERY
+
+     ret = run_query(db, query)
+
+     ret.map!{ |v| [v['relname'], v['idx_blks_hit'].to_i] }
+
+     return Hash[*ret.flatten]
+   end
+end
+

data/spec/postgrestats_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Postgrestats" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+if RUBY_VERSION =~ /^1\.9/
+  require 'simplecov'
+
+  module SimpleCov::Configuration
+    def clean_filters
+      @filters = []
+    end
+  end
+
+  SimpleCov.configure do
+    clean_filters
+    load_adapter 'test_frameworks'
+  end
+
+  ENV["COVERAGE"] && SimpleCov.start do
+    add_filter "/.rvm/"
+  end
+end
+
+require 'rspec'
+require 'postgrestats'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: postgrestats
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Artem Veremey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: &70239789569380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70239789569380
+- !ruby/object:Gem::Dependency
+  name: gmetric
+  requirement: &70239789567620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70239789567620
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70239789583240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *70239789583240
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &70239789582260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: *70239789582260
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &70239789581240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: *70239789581240
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: &70239789580580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70239789580580
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70239789579900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70239789579900
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70239789579040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: *70239789579040
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &70239789578200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70239789578200
+description: Postgrestats is a library that captures important PostgreSQL statistics
+email: artem@veremey.net
+executables:
+- postgrestats
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- bin/postgrestats
+- config/example.yml
+- features/postgrestats.feature
+- features/step_definitions/postgrestats_steps.rb
+- features/support/env.rb
+- lib/postgrestats.rb
+- spec/postgrestats_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/aia/postgrestats
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -785327322279302061
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Postgrestats is a library that captures important PostgreSQL statistics
+test_files: []