sensu-plugins-postgres-mrtrotl 4.3.1

data/bin/check-postgres-query.rb

@@ -0,0 +1,142 @@
+#! /usr/bin/env ruby
+# frozen_string_literal: false
+
+#
+# check-postgres-query
+#
+# DESCRIPTION:
+#   This plugin queries a PostgreSQL database. It alerts when the numeric
+#   result hits a threshold. Can optionally alert on the number of tuples
+#   (rows) returned by the query.
+#
+# OUTPUT:
+#   plain-text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: pg
+#   gem: sensu-plugin
+#   gem: dentaku
+#
+# USAGE:
+#   check-postgres-query.rb -u db_user -p db_pass -h db_host -d db -q 'select foo from bar' -w 'value > 5' -c 'value > 10'
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright 2015, Eric Heydrick <eheydrick@gmail.com>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugins-postgres/pgpass'
+require 'sensu-plugin/check/cli'
+require 'pg'
+require 'dentaku'
+
+# Check PostgresSQL Query
+class CheckPostgresQuery < Sensu::Plugin::Check::CLI
+  option :pgpass,
+         description: 'Pgpass file',
+         short: '-f FILE',
+         long: '--pgpass',
+         default: ENV['PGPASSFILE'] || "#{ENV['HOME']}/.pgpass"
+
+  option :user,
+         description: 'Postgres User',
+         short: '-u USER',
+         long: '--user USER'
+
+  option :password,
+         description: 'Postgres Password',
+         short: '-p PASS',
+         long: '--password PASS'
+
+  option :hostname,
+         description: 'Hostname to login to',
+         short: '-h HOST',
+         long: '--hostname HOST'
+
+  option :port,
+         description: 'Database port',
+         short: '-P PORT',
+         long: '--port PORT'
+
+  option :database,
+         description: 'Database name',
+         short: '-d DB',
+         long: '--db DB'
+
+  option :query,
+         description: 'Database query to execute',
+         short: '-q QUERY',
+         long: '--query QUERY',
+         required: true
+
+  option :regex_pattern,
+         description: 'Regex pattern to match on query results and alert on if it does not match',
+         short: '-r REGEX',
+         long: '--regex-pattern REGEX'
+
+  option :check_tuples,
+         description: 'Check against the number of tuples (rows) returned by the query',
+         short: '-t',
+         long: '--tuples',
+         boolean: true,
+         default: false
+
+  option :warning,
+         description: 'Warning threshold expression',
+         short: '-w WARNING',
+         long: '--warning WARNING',
+         default: nil
+
+  option :critical,
+         description: 'Critical threshold expression',
+         short: '-c CRITICAL',
+         long: '--critical CRITICAL',
+         default: nil
+
+  option :timeout,
+         description: 'Connection timeout (seconds)',
+         short: '-T TIMEOUT',
+         long: '--timeout TIMEOUT',
+         default: 10,
+         proc: proc(&:to_i)
+
+  include Pgpass
+
+  def run
+    begin
+      pgpass
+      con = PG.connect(host: config[:hostname],
+                       dbname: config[:database],
+                       user: config[:user],
+                       password: config[:password],
+                       port: config[:port],
+                       connect_timeout: config[:timeout])
+      res = con.exec(config[:query].to_s)
+    rescue PG::Error => e
+      unknown "Unable to query PostgreSQL: #{e.message}"
+    end
+
+    value = if config[:check_tuples]
+              res.ntuples
+            else
+              res.first.values.first.to_f
+            end
+
+    calc = Dentaku::Calculator.new
+    if config[:critical] && calc.evaluate(config[:critical], value: value)
+      critical "Results: #{res.values}"
+    elsif config[:warning] && calc.evaluate(config[:warning], value: value)
+      warning "Results: #{res.values}"
+    elsif config[:regex_pattern] && (res.getvalue(0, 0) !~ /#{config[:regex_pattern]}/)
+      critical "Query result #{res.getvalue(0, 0)} doesn't match configured regex #{config[:regex_pattern]}"
+    else
+      ok 'Query OK'
+    end
+  end
+end

data/bin/check-postgres-replication.rb

@@ -0,0 +1,160 @@
+#! /usr/bin/env ruby
+# frozen_string_literal: false
+
+#
+#   check-postgres-replication
+#
+# DESCRIPTION:
+#
+#   This plugin checks postgresql replication lag
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: pg
+#
+# USAGE:
+#   ./check-postgres-replication.rb -m master_host -s slave_host -P port -d db -u db_user -p db_pass -w warn_threshold -c crit_threshold
+#
+# NOTES:
+#
+# LICENSE:
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugins-postgres/pgpass'
+require 'sensu-plugins-postgres/pgutil'
+require 'sensu-plugin/check/cli'
+require 'pg'
+
+class CheckPostgresReplicationStatus < Sensu::Plugin::Check::CLI
+  option :pgpass,
+         description: 'Pgpass file',
+         short: '-f FILE',
+         long: '--pgpass',
+         default: ENV['PGPASSFILE'] || "#{ENV['HOME']}/.pgpass"
+
+  option(:master_host,
+         short: '-m',
+         long: '--master-host=HOST',
+         required: true,
+         description: 'PostgreSQL master HOST')
+
+  option(:slave_host,
+         short: '-s',
+         long: '--slave-host=HOST',
+         required: true,
+         description: 'PostgreSQL slave HOST')
+
+  option(:port,
+         short: '-P',
+         long: '--port=PORT',
+         description: 'PostgreSQL port')
+
+  option(:database,
+         short: '-d',
+         long: '--database=NAME',
+         description: 'Database NAME')
+
+  option(:user,
+         short: '-u',
+         long: '--user=USER',
+         description: 'Database USER')
+
+  option(:password,
+         short: '-p',
+         long: '--password=PASSWORD',
+         description: 'Database PASSWORD')
+
+  option(:ssl,
+         short: '-S',
+         long: '--ssl',
+         boolean: true,
+         description: 'Require SSL')
+
+  option(:warn,
+         short: '-w',
+         long: '--warning=VALUE',
+         description: 'Warning threshold for replication lag (in MB)',
+         default: 900,
+         # #YELLOW
+         proc: lambda { |s| s.to_i }) # rubocop:disable Lambda
+
+  option(:crit,
+         short: '-c',
+         long: '--critical=VALUE',
+         description: 'Critical threshold for replication lag (in MB)',
+         default: 1800,
+         # #YELLOW
+         proc: lambda { |s| s.to_i }) # rubocop:disable Lambda
+
+  option(:timeout,
+         short: '-T TIMEOUT',
+         long: '--timeout=TIMEOUT',
+         default: 10,
+         description: 'Connection timeout (seconds)',
+         proc: proc(&:to_i))
+
+  include Pgpass
+  include PgUtil
+
+  def run
+    ssl_mode = config[:ssl] ? 'require' : 'prefer'
+
+    critical 'Master and slave cannot be the same host' if config[:master_host] == config[:slave_host]
+
+    # Establishing connection to the master
+    pgpass
+    conn_master = PG.connect(host: config[:master_host],
+                             dbname: config[:database],
+                             user: config[:user],
+                             password: config[:password],
+                             port: config[:port],
+                             sslmode: ssl_mode,
+                             connect_timeout: config[:timeout])
+
+    master = if check_vsn_newer_than_postgres9(conn_master)
+               conn_master.exec('SELECT pg_current_xlog_location()').getvalue(0, 0)
+             else
+               conn_master.exec('SELECT pg_current_wal_lsn()').getvalue(0, 0)
+             end
+    m_segbytes = conn_master.exec('SHOW wal_segment_size').getvalue(0, 0).sub(/\D+/, '').to_i << 20
+    conn_master.close
+
+    # Establishing connection to the slave
+    conn_slave = PG.connect(host: config[:slave_host],
+                            dbname: config[:database],
+                            user: config[:user],
+                            password: config[:password],
+                            port: config[:port],
+                            sslmode: ssl_mode,
+                            connect_timeout: config[:timeout])
+
+    slave = if check_vsn_newer_than_postgres9(conn_slave)
+              conn_slave.exec('SELECT pg_last_xlog_receive_location()').getvalue(0, 0)
+            else
+              conn_slave.exec('SELECT pg_last_wal_replay_lsn()').getvalue(0, 0)
+            end
+    conn_slave.close
+
+    # Computing lag
+    lag = compute_lag(master, slave, m_segbytes)
+    lag_in_mb = (lag.to_f / 1024 / 1024).abs
+
+    message = "replication delayed by #{lag_in_mb}MB :: master:#{master} slave:#{slave} m_segbytes:#{m_segbytes}"
+
+    if lag_in_mb >= config[:crit]
+      critical message
+    elsif lag_in_mb >= config[:warn]
+      warning message
+    else
+      ok message
+    end
+  end
+end

data/bin/metric-postgres-connections.rb

@@ -0,0 +1,130 @@
+#! /usr/bin/env ruby
+# frozen_string_literal: false
+
+#
+#   metric-postgres-connections
+#
+# DESCRIPTION:
+#
+#   This plugin collects postgres connection metrics
+#
+# OUTPUT:
+#   metric data
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: pg
+#
+# USAGE:
+#   ./metric-postgres-connections.rb -u db_user -p db_pass -h db_host -d db
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright (c) 2012 Kwarter, Inc <platforms@kwarter.com>
+#   Author Gilles Devaux <gilles.devaux@gmail.com>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugins-postgres/pgpass'
+require 'sensu-plugin/metric/cli'
+require 'pg'
+require 'socket'
+
+class PostgresStatsDBMetrics < Sensu::Plugin::Metric::CLI::Graphite
+  option :pgpass,
+         description: 'Pgpass file',
+         short: '-f FILE',
+         long: '--pgpass',
+         default: "#{ENV['HOME']}/.pgpass"
+
+  option :user,
+         description: 'Postgres User',
+         short: '-u USER',
+         long: '--user USER'
+
+  option :password,
+         description: 'Postgres Password',
+         short: '-p PASS',
+         long: '--password PASS'
+
+  option :hostname,
+         description: 'Hostname to login to',
+         short: '-h HOST',
+         long: '--hostname HOST'
+
+  option :port,
+         description: 'Database port',
+         short: '-P PORT',
+         long: '--port PORT'
+
+  option :database,
+         description: 'Database name',
+         short: '-d DB',
+         long: '--db DB'
+
+  option :scheme,
+         description: 'Metric naming scheme, text to prepend to $queue_name.$metric',
+         long: '--scheme SCHEME',
+         default: "#{Socket.gethostname}.postgresql"
+
+  option :timeout,
+         description: 'Connection timeout (seconds)',
+         short: '-T TIMEOUT',
+         long: '--timeout TIMEOUT',
+         default: 10,
+         proc: proc(&:to_i)
+
+  include Pgpass
+
+  def run
+    timestamp = Time.now.to_i
+    pgpass
+    con = PG.connect(host: config[:hostname],
+                     dbname: config[:database],
+                     user: config[:user],
+                     password: config[:password],
+                     port: config[:port],
+                     connect_timeout: config[:timeout])
+    request = [
+      "select case when count(*) = 1 then 'waiting' else",
+      "'case when wait_event_type is null then false else true end' end as wait_col",
+      'from information_schema.columns',
+      "where table_name = 'pg_stat_activity' and table_schema = 'pg_catalog'",
+      "and column_name = 'waiting'"
+    ]
+    wait_col = con.exec(request.join(' ')).first['wait_col']
+
+    request = [
+      "select count(*), #{wait_col} as waiting from pg_stat_activity",
+      "where datname = '#{config[:database]}' group by #{wait_col}"
+    ]
+
+    metrics = {
+      active: 0,
+      waiting: 0,
+      total: 0
+    }
+    con.exec(request.join(' ')) do |result|
+      result.each do |row|
+        if row['waiting'] == 't'
+          metrics[:waiting] = row['count']
+        elsif row['waiting'] == 'f'
+          metrics[:active] = row['count']
+        end
+      end
+    end
+
+    metrics[:total] = (metrics[:waiting].to_i + metrics[:active].to_i)
+
+    metrics.each do |metric, value|
+      output "#{config[:scheme]}.connections.#{config[:database]}.#{metric}", value, timestamp
+    end
+
+    ok
+  end
+end

data/bin/metric-postgres-dbsize.rb

@@ -0,0 +1,105 @@
+#! /usr/bin/env ruby
+# frozen_string_literal: false
+
+#
+#   metric-postgres-dbsize
+#
+# DESCRIPTION:
+#
+#   This plugin collects postgres database size metrics
+#
+# OUTPUT:
+#   metric data
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: pg
+#
+# USAGE:
+#   ./metric-postgres-dbsize.rb -u db_user -p db_pass -h db_host -d db
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright (c) 2012 Kwarter, Inc <platforms@kwarter.com>
+#   Author Gilles Devaux <gilles.devaux@gmail.com>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugins-postgres/pgpass'
+require 'sensu-plugin/metric/cli'
+require 'pg'
+require 'socket'
+
+class PostgresStatsDBMetrics < Sensu::Plugin::Metric::CLI::Graphite
+  option :pgpass,
+         description: 'Pgpass file',
+         short: '-f FILE',
+         long: '--pgpass',
+         default: ENV['PGPASSFILE'] || "#{ENV['HOME']}/.pgpass"
+
+  option :user,
+         description: 'Postgres User',
+         short: '-u USER',
+         long: '--user USER'
+
+  option :password,
+         description: 'Postgres Password',
+         short: '-p PASS',
+         long: '--password PASS'
+
+  option :hostname,
+         description: 'Hostname to login to',
+         short: '-h HOST',
+         long: '--hostname HOST'
+
+  option :port,
+         description: 'Database port',
+         short: '-P PORT',
+         long: '--port PORT'
+
+  option :database,
+         description: 'Database name',
+         short: '-d DB',
+         long: '--db DB'
+
+  option :scheme,
+         description: 'Metric naming scheme, text to prepend to $queue_name.$metric',
+         long: '--scheme SCHEME',
+         default: "#{Socket.gethostname}.postgresql"
+
+  option :timeout,
+         description: 'Connection timeout (seconds)',
+         short: '-T TIMEOUT',
+         long: '--timeout TIMEOUT',
+         default: 10,
+         proc: proc(&:to_i)
+
+  include Pgpass
+
+  def run
+    timestamp = Time.now.to_i
+    pgpass
+    con = PG.connect(host: config[:hostname],
+                     dbname: config[:database],
+                     user: config[:user],
+                     password: config[:password],
+                     port: config[:port],
+                     connect_timeout: config[:timeout])
+    request = [
+      "select pg_database_size('#{config[:database]}')"
+    ]
+
+    con.exec(request.join(' ')) do |result|
+      result.each do |row|
+        output "#{config[:scheme]}.size.#{config[:database]}", row['pg_database_size'], timestamp
+      end
+    end
+
+    ok
+  end
+end

data/bin/metric-postgres-graphite.rb

@@ -0,0 +1,140 @@
+#! /usr/bin/env ruby
+# frozen_string_literal: false
+
+#
+#   metric-postgres-graphite
+#
+# DESCRIPTION:
+#
+#   This plugin collects postgres replication lag metrics
+#
+# OUTPUT:
+#   metric data
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: pg
+#
+# USAGE:
+#   ./metric-postgres-graphite.rb -m master_host -s slave_host -d db -u db_user -p db_pass
+#
+# NOTES:
+#
+# LICENSE:
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugins-postgres/pgpass'
+require 'sensu-plugins-postgres/pgutil'
+require 'sensu-plugin/metric/cli'
+require 'pg'
+require 'socket'
+
+class CheckpostgresReplicationStatus < Sensu::Plugin::Metric::CLI::Graphite
+  option :pgpass,
+         description: 'Pgpass file',
+         short: '-f FILE',
+         long: '--pgpass',
+         default: ENV['PGPASSFILE'] || "#{ENV['HOME']}/.pgpass"
+
+  option :master_host,
+         short: '-m',
+         long: '--master=HOST',
+         description: 'PostgreSQL master HOST'
+
+  option :slave_host,
+         short: '-s',
+         long: '--slave=HOST',
+         description: 'PostgreSQL slave HOST',
+         default: 'localhost'
+
+  option :database,
+         short: '-d',
+         long: '--database=NAME',
+         description: 'Database NAME'
+
+  option :user,
+         short: '-u',
+         long: '--username=VALUE',
+         description: 'Database username'
+
+  option :password,
+         short: '-p',
+         long: '--password=VALUE',
+         description: 'Database password'
+
+  option :ssl,
+         short: '-S',
+         long: '--ssl',
+         boolean: true,
+         description: 'Require SSL'
+
+  option :scheme,
+         description: 'Metric naming scheme, text to prepend to metric',
+         short: '-g SCHEME',
+         long: '--scheme SCHEME',
+         default: "#{Socket.gethostname}.postgres.replication_lag"
+
+  option :port,
+         description: 'Database port',
+         short: '-P PORT',
+         long: '--port PORT'
+
+  option :timeout,
+         description: 'Connection timeout (seconds)',
+         short: '-T TIMEOUT',
+         long: '--timeout TIMEOUT',
+         default: 10,
+         proc: proc(&:to_i)
+
+  include Pgpass
+  include PgUtil
+
+  def run
+    ssl_mode = config[:ssl] ? 'require' : 'prefer'
+
+    # Establishing connections to the master
+    pgpass
+    conn_master = PG.connect(host: config[:master_host],
+                             dbname: config[:database],
+                             user: config[:user],
+                             password: config[:password],
+                             port: config[:port],
+                             sslmode: ssl_mode,
+                             connect_timeout: config[:timeout])
+
+    master = if check_vsn_newer_than_postgres9(conn_master)
+               conn_master.exec('SELECT pg_current_xlog_location()').getvalue(0, 0)
+             else
+               conn_master.exec('SELECT pg_current_wal_lsn()').getvalue(0, 0)
+             end
+    m_segbytes = conn_master.exec('SHOW wal_segment_size').getvalue(0, 0).sub(/\D+/, '').to_i << 20
+    conn_master.close
+
+    # Establishing connections to the slave
+    conn_slave = PG.connect(host: config[:slave_host],
+                            dbname: config[:database],
+                            user: config[:user],
+                            password: config[:password],
+                            port: config[:port],
+                            sslmode: ssl_mode,
+                            connect_timeout: config[:timeout])
+
+    slave = if check_vsn_newer_than_postgres9(conn_slave)
+              conn_slave.exec('SELECT pg_last_xlog_receive_location()').getvalue(0, 0)
+            else
+              conn_slave.exec('SELECT pg_last_wal_replay_lsn()').getvalue(0, 0)
+            end
+    conn_slave.close
+
+    # Compute lag
+    lag = compute_lag(master, slave, m_segbytes)
+    output config[:scheme].to_s, lag
+
+    ok
+  end
+end