#!/usr/bin/env python
#
# A MongoDB Nagios check script
#
# Script idea taken from a Tag1 script I found and I modified it a lot
#
# Main Author
# - Mike Zupan <mike@zcentric.com>
# Contributers
# - Frank Brandewiede <brande@travel-iq.com> <brande@bfiw.de> <brande@novolab.de>
# - Sam Perman <sam@brightcove.com>
# - Shlomo Priymak <shlomoid@gmail.com>
# - @jhoff909 on github
# - @jbraeuer on github
# - Dag Stockstad <dag.stockstad@gmail.com>
# - @Andor on github
# - Steven Richards - Captainkrtek on github
# - Max Vernimmen
#
# USAGE
#
# See the README.md
#
import sys
import time
import optparse
import textwrap
import re
import os
try:
import pymongo
except ImportError, e:
print e
sys.exit(2)
# As of pymongo v 1.9 the SON API is part of the BSON package, therefore attempt
# to import from there and fall back to pymongo in cases of older pymongo
if pymongo.version >= "1.9":
import bson.son as son
else:
import pymongo.son as son
#
# thanks to http://stackoverflow.com/a/1229667/72987
#
def optional_arg(arg_default):
def func(option, opt_str, value, parser):
if parser.rargs and not parser.rargs[0].startswith('-'):
val = parser.rargs[0]
parser.rargs.pop(0)
else:
val = arg_default
setattr(parser.values, option.dest, val)
return func
def performance_data(perf_data, params):
data = ''
if perf_data:
data = " |"
for p in params:
p += (None, None, None, None)
param, param_name, warning, critical = p[0:4]
data += "%s=%s" % (param_name, str(param))
if warning or critical:
warning = warning or 0
critical = critical or 0
data += ";%s;%s" % (warning, critical)
data += " "
return data
def numeric_type(param):
if ((type(param) == float or type(param) == int or param == None)):
return True
return False
def check_levels(param, warning, critical, message, ok=[]):
if (numeric_type(critical) and numeric_type(warning)):
if param >= critical:
print "CRITICAL - " + message
sys.exit(2)
elif param >= warning:
print "WARNING - " + message
sys.exit(1)
else:
print "OK - " + message
sys.exit(0)
else:
if param in critical:
print "CRITICAL - " + message
sys.exit(2)
if param in warning:
print "WARNING - " + message
sys.exit(1)
if param in ok:
print "OK - " + message
sys.exit(0)
# unexpected param value
print "CRITICAL - Unexpected value : %d" % param + "; " + message
return 2
def get_server_status(con):
try:
set_read_preference(con.admin)
data = con.admin.command(pymongo.son_manipulator.SON([('serverStatus', 1)]))
except:
data = con.admin.command(son.SON([('serverStatus', 1)]))
return data
def main(argv):
p = optparse.OptionParser(conflict_handler="resolve", description="This Nagios plugin checks the health of mongodb.")
p.add_option('-H', '--host', action='store', type='string', dest='host', default='127.0.0.1', help='The hostname you want to connect to')
p.add_option('-P', '--port', action='store', type='int', dest='port', default=27017, help='The port mongodb is runnung on')
p.add_option('-u', '--user', action='store', type='string', dest='user', default=None, help='The username you want to login as')
p.add_option('-p', '--pass', action='store', type='string', dest='passwd', default=None, help='The password you want to use for that user')
p.add_option('-W', '--warning', action='store', dest='warning', default=None, help='The warning threshold we want to set')
p.add_option('-C', '--critical', action='store', dest='critical', default=None, help='The critical threshold we want to set')
p.add_option('-A', '--action', action='store', type='choice', dest='action', default='connect', help='The action you want to take',
choices=['connect', 'connections', 'replication_lag', 'replication_lag_percent', 'replset_state', 'memory', 'memory_mapped', 'lock',
'flushing', 'last_flush_time', 'index_miss_ratio', 'databases', 'collections', 'database_size', 'database_indexes', 'collection_indexes', 'collection_size',
'queues', 'oplog', 'journal_commits_in_wl', 'write_data_files', 'journaled', 'opcounters', 'current_lock', 'replica_primary', 'page_faults',
'asserts', 'queries_per_second', 'page_faults', 'chunks_balance', 'connect_primary', 'collection_state', 'row_count', 'replset_quorum'])
p.add_option('--max-lag', action='store_true', dest='max_lag', default=False, help='Get max replication lag (for replication_lag action only)')
p.add_option('--mapped-memory', action='store_true', dest='mapped_memory', default=False, help='Get mapped memory instead of resident (if resident memory can not be read)')
p.add_option('-D', '--perf-data', action='store_true', dest='perf_data', default=False, help='Enable output of Nagios performance data')
p.add_option('-d', '--database', action='store', dest='database', default='admin', help='Specify the database to check')
p.add_option('--all-databases', action='store_true', dest='all_databases', default=False, help='Check all databases (action database_size)')
p.add_option('-s', '--ssl', dest='ssl', default=False, action='callback', callback=optional_arg(True), help='Connect using SSL')
p.add_option('-r', '--replicaset', dest='replicaset', default=None, action='callback', callback=optional_arg(True), help='Connect to replicaset')
p.add_option('-q', '--querytype', action='store', dest='query_type', default='query', help='The query type to check [query|insert|update|delete|getmore|command] from queries_per_second')
p.add_option('-c', '--collection', action='store', dest='collection', default='admin', help='Specify the collection to check')
p.add_option('-T', '--time', action='store', type='int', dest='sample_time', default=1, help='Time used to sample number of pages faults')
options, arguments = p.parse_args()
host = options.host
port = options.port
user = options.user
passwd = options.passwd
query_type = options.query_type
collection = options.collection
sample_time = options.sample_time
if (options.action == 'replset_state'):
warning = str(options.warning or "")
critical = str(options.critical or "")
else:
warning = float(options.warning or 0)
critical = float(options.critical or 0)
action = options.action
perf_data = options.perf_data
max_lag = options.max_lag
database = options.database
ssl = options.ssl
replicaset = options.replicaset
if action == 'replica_primary' and replicaset is None:
return "replicaset must be passed in when using replica_primary check"
elif not action == 'replica_primary' and replicaset:
return "passing a replicaset while not checking replica_primary does not work"
#
# moving the login up here and passing in the connection
#
start = time.time()
err, con = mongo_connect(host, port, ssl, user, passwd, replicaset)
if err != 0:
return err
conn_time = time.time() - start
conn_time = round(conn_time, 0)
if action == "connections":
return check_connections(con, warning, critical, perf_data)
elif action == "replication_lag":
return check_rep_lag(con, host, port, warning, critical, False, perf_data, max_lag, user, passwd)
elif action == "replication_lag_percent":
return check_rep_lag(con, host, port, warning, critical, True, perf_data, max_lag, user, passwd)
elif action == "replset_state":
return check_replset_state(con, perf_data, warning, critical)
elif action == "memory":
return check_memory(con, warning, critical, perf_data, options.mapped_memory)
elif action == "memory_mapped":
return check_memory_mapped(con, warning, critical, perf_data)
elif action == "queues":
return check_queues(con, warning, critical, perf_data)
elif action == "lock":
return check_lock(con, warning, critical, perf_data)
elif action == "current_lock":
return check_current_lock(con, host, warning, critical, perf_data)
elif action == "flushing":
return check_flushing(con, warning, critical, True, perf_data)
elif action == "last_flush_time":
return check_flushing(con, warning, critical, False, perf_data)
elif action == "index_miss_ratio":
index_miss_ratio(con, warning, critical, perf_data)
elif action == "databases":
return check_databases(con, warning, critical, perf_data)
elif action == "collections":
return check_collections(con, warning, critical, perf_data)
elif action == "oplog":
return check_oplog(con, warning, critical, perf_data)
elif action == "journal_commits_in_wl":
return check_journal_commits_in_wl(con, warning, critical, perf_data)
elif action == "database_size":
if options.all_databases:
return check_all_databases_size(con, warning, critical, perf_data)
else:
return check_database_size(con, database, warning, critical, perf_data)
elif action == "database_indexes":
return check_database_indexes(con, database, warning, critical, perf_data)
elif action == "collection_indexes":
return check_collection_indexes(con, database, collection, warning, critical, perf_data)
elif action == "collection_size":
return check_collection_size(con, database, collection, warning, critical, perf_data)
elif action == "journaled":
return check_journaled(con, warning, critical, perf_data)
elif action == "write_data_files":
return check_write_to_datafiles(con, warning, critical, perf_data)
elif action == "opcounters":
return check_opcounters(con, host, warning, critical, perf_data)
elif action == "asserts":
return check_asserts(con, host, warning, critical, perf_data)
elif action == "replica_primary":
return check_replica_primary(con, host, warning, critical, perf_data, replicaset)
elif action == "queries_per_second":
return check_queries_per_second(con, query_type, warning, critical, perf_data)
elif action == "page_faults":
check_page_faults(con, sample_time, warning, critical, perf_data)
elif action == "chunks_balance":
chunks_balance(con, database, collection, warning, critical)
elif action == "connect_primary":
return check_connect_primary(con, warning, critical, perf_data)
elif action == "collection_state":
return check_collection_state(con, database, collection)
elif action == "row_count":
return check_row_count(con, database, collection, warning, critical, perf_data)
elif action == "replset_quorum":
return check_replset_quorum(con, perf_data)
else:
return check_connect(host, port, warning, critical, perf_data, user, passwd, conn_time)
def mongo_connect(host=None, port=None, ssl=False, user=None, passwd=None, replica=None):
try:
# ssl connection for pymongo > 2.3
if pymongo.version >= "2.3":
if replica is None:
con = pymongo.MongoClient(host, port)
else:
con = pymongo.Connection(host, port, read_preference=pymongo.ReadPreference.SECONDARY, ssl=ssl, replicaSet=replica, network_timeout=10)
else:
if replica is None:
con = pymongo.Connection(host, port, slave_okay=True, network_timeout=10)
else:
con = pymongo.Connection(host, port, slave_okay=True, network_timeout=10)
#con = pymongo.Connection(host, port, slave_okay=True, replicaSet=replica, network_timeout=10)
if user and passwd:
db = con["admin"]
if not db.authenticate(user, passwd):
sys.exit("Username/Password incorrect")
except Exception, e:
if isinstance(e, pymongo.errors.AutoReconnect) and str(e).find(" is an arbiter") != -1:
# We got a pymongo AutoReconnect exception that tells us we connected to an Arbiter Server
# This means: Arbiter is reachable and can answer requests/votes - this is all we need to know from an arbiter
print "OK - State: 7 (Arbiter)"
sys.exit(0)
return exit_with_general_critical(e), None
return 0, con
def exit_with_general_warning(e):
if isinstance(e, SystemExit):
return e
else:
print "WARNING - General MongoDB warning:", e
return 1
def exit_with_general_critical(e):
if isinstance(e, SystemExit):
return e
else:
print "CRITICAL - General MongoDB Error:", e
return 2
def set_read_preference(db):
if pymongo.version >= "2.1":
db.read_preference = pymongo.ReadPreference.SECONDARY
def check_connect(host, port, warning, critical, perf_data, user, passwd, conn_time):
warning = warning or 3
critical = critical or 6
message = "Connection took %i seconds" % conn_time
message += performance_data(perf_data, [(conn_time, "connection_time", warning, critical)])
return check_levels(conn_time, warning, critical, message)
def check_connections(con, warning, critical, perf_data):
warning = warning or 80
critical = critical or 95
try:
data = get_server_status(con)
current = float(data['connections']['current'])
available = float(data['connections']['available'])
used_percent = int(float(current / (available + current)) * 100)
message = "%i percent (%i of %i connections) used" % (used_percent, current, current + available)
message += performance_data(perf_data, [(used_percent, "used_percent", warning, critical),
(current, "current_connections"),
(available, "available_connections")])
return check_levels(used_percent, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def check_rep_lag(con, host, port, warning, critical, percent, perf_data, max_lag, user, passwd):
# Get mongo to tell us replica set member name when connecting locally
if "127.0.0.1" == host:
host = con.admin.command("ismaster","1")["me"].split(':')[0]
if percent:
warning = warning or 50
critical = critical or 75
else:
warning = warning or 600
critical = critical or 3600
rs_status = {}
slaveDelays = {}
try:
set_read_preference(con.admin)
# Get replica set status
try:
rs_status = con.admin.command("replSetGetStatus")
except pymongo.errors.OperationFailure, e:
if e.code == None and str(e).find('failed: not running with --replSet"'):
print "OK - Not running with replSet"
return 0
serverVersion = tuple(con.server_info()['version'].split('.'))
if serverVersion >= tuple("2.0.0".split(".")):
#
# check for version greater then 2.0
#
rs_conf = con.local.system.replset.find_one()
for member in rs_conf['members']:
if member.get('slaveDelay') is not None:
slaveDelays[member['host']] = member.get('slaveDelay')
else:
slaveDelays[member['host']] = 0
# Find the primary and/or the current node
primary_node = None
host_node = None
for member in rs_status["members"]:
if member["stateStr"] == "PRIMARY":
primary_node = member
if member["name"].split(':')[0] == host and int(member["name"].split(':')[1]) == port:
host_node = member
# Check if we're in the middle of an election and don't have a primary
if primary_node is None:
print "WARNING - No primary defined. In an election?"
return 1
# Check if we failed to find the current host
# below should never happen
if host_node is None:
print "CRITICAL - Unable to find host '" + host + "' in replica set."
return 2
# Is the specified host the primary?
if host_node["stateStr"] == "PRIMARY":
if max_lag == False:
print "OK - This is the primary."
return 0
else:
#get the maximal replication lag
data = ""
maximal_lag = 0
for member in rs_status['members']:
if not member['stateStr'] == "ARBITER":
lastSlaveOpTime = member['optimeDate']
replicationLag = abs(primary_node["optimeDate"] - lastSlaveOpTime).seconds - slaveDelays[member['name']]
data = data + member['name'] + " lag=%d;" % replicationLag
maximal_lag = max(maximal_lag, replicationLag)
if percent:
err, con = mongo_connect(primary_node['name'].split(':')[0], int(primary_node['name'].split(':')[1]), False, user, passwd)
if err != 0:
return err
primary_timediff = replication_get_time_diff(con)
maximal_lag = int(float(maximal_lag) / float(primary_timediff) * 100)
message = "Maximal lag is " + str(maximal_lag) + " percents"
message += performance_data(perf_data, [(maximal_lag, "replication_lag_percent", warning, critical)])
else:
message = "Maximal lag is " + str(maximal_lag) + " seconds"
message += performance_data(perf_data, [(maximal_lag, "replication_lag", warning, critical)])
return check_levels(maximal_lag, warning, critical, message)
elif host_node["stateStr"] == "ARBITER":
print "OK - This is an arbiter"
return 0
# Find the difference in optime between current node and PRIMARY
optime_lag = abs(primary_node["optimeDate"] - host_node["optimeDate"])
if host_node['name'] in slaveDelays:
slave_delay = slaveDelays[host_node['name']]
elif host_node['name'].endswith(':27017') and host_node['name'][:-len(":27017")] in slaveDelays:
slave_delay = slaveDelays[host_node['name'][:-len(":27017")]]
else:
raise Exception("Unable to determine slave delay for {0}".format(host_node['name']))
try: # work starting from python2.7
lag = optime_lag.total_seconds()
except:
lag = float(optime_lag.seconds + optime_lag.days * 24 * 3600)
if percent:
err, con = mongo_connect(primary_node['name'].split(':')[0], int(primary_node['name'].split(':')[1]), False, user, passwd)
if err != 0:
return err
primary_timediff = replication_get_time_diff(con)
if primary_timediff != 0:
lag = int(float(lag) / float(primary_timediff) * 100)
else:
lag = 0
message = "Lag is " + str(lag) + " percents"
message += performance_data(perf_data, [(lag, "replication_lag_percent", warning, critical)])
else:
message = "Lag is " + str(lag) + " seconds"
message += performance_data(perf_data, [(lag, "replication_lag", warning, critical)])
return check_levels(lag, warning + slaveDelays[host_node['name']], critical + slaveDelays[host_node['name']], message)
else:
#
# less than 2.0 check
#
# Get replica set status
rs_status = con.admin.command("replSetGetStatus")
# Find the primary and/or the current node
primary_node = None
host_node = None
for member in rs_status["members"]:
if member["stateStr"] == "PRIMARY":
primary_node = (member["name"], member["optimeDate"])
if member["name"].split(":")[0].startswith(host):
host_node = member
# Check if we're in the middle of an election and don't have a primary
if primary_node is None:
print "WARNING - No primary defined. In an election?"
sys.exit(1)
# Is the specified host the primary?
if host_node["stateStr"] == "PRIMARY":
print "OK - This is the primary."
sys.exit(0)
# Find the difference in optime between current node and PRIMARY
optime_lag = abs(primary_node[1] - host_node["optimeDate"])
lag = optime_lag.seconds
if percent:
err, con = mongo_connect(primary_node['name'].split(':')[0], int(primary_node['name'].split(':')[1]))
if err != 0:
return err
primary_timediff = replication_get_time_diff(con)
lag = int(float(lag) / float(primary_timediff) * 100)
message = "Lag is " + str(lag) + " percents"
message += performance_data(perf_data, [(lag, "replication_lag_percent", warning, critical)])
else:
message = "Lag is " + str(lag) + " seconds"
message += performance_data(perf_data, [(lag, "replication_lag", warning, critical)])
return check_levels(lag, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def check_memory(con, warning, critical, perf_data, mapped_memory):
#
# These thresholds are basically meaningless, and must be customized to your system's ram
#
# Get the total system merory and calculate based on that how much memory used by Mongodb is ok or not.
meminfo = open('/proc/meminfo').read()
matched = re.search(r'^MemTotal:\s+(\d+)', meminfo)
if matched:
mem_total_kB = int(matched.groups()[0])
# Old way
#critical = critical or 16
# The new way. if using >80% then warn, if >90% then critical level
warning = warning or (mem_total_kB * 0.8) / 1024.0 / 1024.0
critical = critical or (mem_total_kB * 0.9) / 1024.0 / 1024.0
# debugging
#print "mem total: {0}kb, warn: {1}GB, crit: {2}GB".format(mem_total_kB,warning, critical)
try:
data = get_server_status(con)
if not data['mem']['supported'] and not mapped_memory:
print "OK - Platform not supported for memory info"
return 0
#
# convert to gigs
#
message = "Memory Usage:"
try:
mem_resident = float(data['mem']['resident']) / 1024.0
message += " %.2fGB resident," % (mem_resident)
except:
mem_resident = 0
message += " resident unsupported,"
try:
mem_virtual = float(data['mem']['virtual']) / 1024.0
message += " %.2fGB virtual," % mem_virtual
except:
mem_virtual = 0
message += " virtual unsupported,"
try:
mem_mapped = float(data['mem']['mapped']) / 1024.0
message += " %.2fGB mapped," % mem_mapped
except:
mem_mapped = 0
message += " mapped unsupported,"
try:
mem_mapped_journal = float(data['mem']['mappedWithJournal']) / 1024.0
message += " %.2fGB mappedWithJournal" % mem_mapped_journal
except:
mem_mapped_journal = 0
message += performance_data(perf_data, [("%.2f" % mem_resident, "memory_usage", warning, critical),
("%.2f" % mem_mapped, "memory_mapped"), ("%.2f" % mem_virtual, "memory_virtual"), ("%.2f" % mem_mapped_journal, "mappedWithJournal")])
#added for unsupported systems like Solaris
if mapped_memory and mem_resident == 0:
return check_levels(mem_mapped, warning, critical, message)
else:
return check_levels(mem_resident, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def check_memory_mapped(con, warning, critical, perf_data):
#
# These thresholds are basically meaningless, and must be customized to your application
#
warning = warning or 8
critical = critical or 16
try:
data = get_server_status(con)
if not data['mem']['supported']:
print "OK - Platform not supported for memory info"
return 0
#
# convert to gigs
#
message = "Memory Usage:"
try:
mem_mapped = float(data['mem']['mapped']) / 1024.0
message += " %.2fGB mapped," % mem_mapped
except:
mem_mapped = -1
message += " mapped unsupported,"
try:
mem_mapped_journal = float(data['mem']['mappedWithJournal']) / 1024.0
message += " %.2fGB mappedWithJournal" % mem_mapped_journal
except:
mem_mapped_journal = 0
message += performance_data(perf_data, [("%.2f" % mem_mapped, "memory_mapped"), ("%.2f" % mem_mapped_journal, "mappedWithJournal")])
if not mem_mapped == -1:
return check_levels(mem_mapped, warning, critical, message)
else:
print "OK - Server does not provide mem.mapped info"
return 0
except Exception, e:
return exit_with_general_critical(e)
def check_lock(con, warning, critical, perf_data):
warning = warning or 10
critical = critical or 30
try:
data = get_server_status(con)
#
# calculate percentage
#
lockTime = data['globalLock']['lockTime']
totalTime = data['globalLock']['totalTime']
if lockTime > totalTime:
lock_percentage = 0.00
else:
lock_percentage = float(lockTime) / float(totalTime) * 100
message = "Lock Percentage: %.2f%%" % lock_percentage
message += performance_data(perf_data, [("%.2f" % lock_percentage, "lock_percentage", warning, critical)])
return check_levels(lock_percentage, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def check_flushing(con, warning, critical, avg, perf_data):
#
# These thresholds mean it's taking 5 seconds to perform a background flush to issue a warning
# and 10 seconds to issue a critical.
#
warning = warning or 5000
critical = critical or 15000
try:
data = get_server_status(con)
if avg:
flush_time = float(data['backgroundFlushing']['average_ms'])
stat_type = "Average"
else:
flush_time = float(data['backgroundFlushing']['last_ms'])
stat_type = "Last"
message = "%s Flush Time: %.2fms" % (stat_type, flush_time)
message += performance_data(perf_data, [("%.2fms" % flush_time, "%s_flush_time" % stat_type.lower(), warning, critical)])
return check_levels(flush_time, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def index_miss_ratio(con, warning, critical, perf_data):
warning = warning or 10
critical = critical or 30
try:
data = get_server_status(con)
try:
serverVersion = tuple(con.server_info()['version'].split('.'))
if serverVersion >= tuple("2.4.0".split(".")):
miss_ratio = float(data['indexCounters']['missRatio'])
else:
miss_ratio = float(data['indexCounters']['btree']['missRatio'])
except KeyError:
not_supported_msg = "not supported on this platform"
if data['indexCounters'].has_key('note'):
print "OK - MongoDB says: " + not_supported_msg
return 0
else:
print "WARNING - Can't get counter from MongoDB"
return 1
message = "Miss Ratio: %.2f" % miss_ratio
message += performance_data(perf_data, [("%.2f" % miss_ratio, "index_miss_ratio", warning, critical)])
return check_levels(miss_ratio, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def check_replset_quorum(con, perf_data):
db = con['admin']
warning = 1
critical = 2
primary = 0
try:
rs_members = db.command("replSetGetStatus")['members']
for member in rs_members:
if member['state'] == 1:
primary += 1
if primary == 1:
state = 0
message = "Cluster is quorate"
else:
state = 2
message = "Cluster is not quorate and cannot operate"
return check_levels(state, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def check_replset_state(con, perf_data, warning="", critical=""):
try:
warning = [int(x) for x in warning.split(",")]
except:
warning = [0, 3, 5]
try:
critical = [int(x) for x in critical.split(",")]
except:
critical = [8, 4, -1]
ok = range(-1, 8) # should include the range of all posiible values
try:
try:
try:
set_read_preference(con.admin)
data = con.admin.command(pymongo.son_manipulator.SON([('replSetGetStatus', 1)]))
except:
data = con.admin.command(son.SON([('replSetGetStatus', 1)]))
state = int(data['myState'])
except pymongo.errors.OperationFailure, e:
if e.code == None and str(e).find('failed: not running with --replSet"'):
state = -1
if state == 8:
message = "State: %i (Down)" % state
elif state == 4:
message = "State: %i (Fatal error)" % state
elif state == 0:
message = "State: %i (Starting up, phase1)" % state
elif state == 3:
message = "State: %i (Recovering)" % state
elif state == 5:
message = "State: %i (Starting up, phase2)" % state
elif state == 1:
message = "State: %i (Primary)" % state
elif state == 2:
message = "State: %i (Secondary)" % state
elif state == 7:
message = "State: %i (Arbiter)" % state
elif state == -1:
message = "Not running with replSet"
else:
message = "State: %i (Unknown state)" % state
message += performance_data(perf_data, [(state, "state")])
return check_levels(state, warning, critical, message, ok)
except Exception, e:
return exit_with_general_critical(e)
def check_databases(con, warning, critical, perf_data=None):
try:
try:
set_read_preference(con.admin)
data = con.admin.command(pymongo.son_manipulator.SON([('listDatabases', 1)]))
except:
data = con.admin.command(son.SON([('listDatabases', 1)]))
count = len(data['databases'])
message = "Number of DBs: %.0f" % count
message += performance_data(perf_data, [(count, "databases", warning, critical, message)])
return check_levels(count, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def check_collections(con, warning, critical, perf_data=None):
try:
try:
set_read_preference(con.admin)
data = con.admin.command(pymongo.son_manipulator.SON([('listDatabases', 1)]))
except:
data = con.admin.command(son.SON([('listDatabases', 1)]))
count = 0
for db in data['databases']:
dbase = con[db['name']]
set_read_preference(dbase)
count += len(dbase.collection_names())
message = "Number of collections: %.0f" % count
message += performance_data(perf_data, [(count, "collections", warning, critical, message)])
return check_levels(count, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def check_all_databases_size(con, warning, critical, perf_data):
warning = warning or 100
critical = critical or 1000
try:
set_read_preference(con.admin)
all_dbs_data = con.admin.command(pymongo.son_manipulator.SON([('listDatabases', 1)]))
except:
all_dbs_data = con.admin.command(son.SON([('listDatabases', 1)]))
total_storage_size = 0
message = ""
perf_data_param = [()]
for db in all_dbs_data['databases']:
database = db['name']
data = con[database].command('dbstats')
storage_size = round(data['storageSize'] / 1024 / 1024, 1)
message += "; Database %s size: %.0f MB" % (database, storage_size)
perf_data_param.append((storage_size, database + "_database_size"))
total_storage_size += storage_size
perf_data_param[0] = (total_storage_size, "total_size", warning, critical)
message += performance_data(perf_data, perf_data_param)
message = "Total size: %.0f MB" % total_storage_size + message
return check_levels(total_storage_size, warning, critical, message)
def check_database_size(con, database, warning, critical, perf_data):
warning = warning or 100
critical = critical or 1000
perfdata = ""
try:
set_read_preference(con.admin)
data = con[database].command('dbstats')
storage_size = data['storageSize'] / 1024 / 1024
if perf_data:
perfdata += " | database_size=%i;%i;%i" % (storage_size, warning, critical)
#perfdata += " database=%s" %(database)
if storage_size >= critical:
print "CRITICAL - Database size: %.0f MB, Database: %s%s" % (storage_size, database, perfdata)
return 2
elif storage_size >= warning:
print "WARNING - Database size: %.0f MB, Database: %s%s" % (storage_size, database, perfdata)
return 1
else:
print "OK - Database size: %.0f MB, Database: %s%s" % (storage_size, database, perfdata)
return 0
except Exception, e:
return exit_with_general_critical(e)
def check_database_indexes(con, database, warning, critical, perf_data):
#
# These thresholds are basically meaningless, and must be customized to your application
#
warning = warning or 100
critical = critical or 1000
perfdata = ""
try:
set_read_preference(con.admin)
data = con[database].command('dbstats')
index_size = data['indexSize'] / 1024 / 1024
if perf_data:
perfdata += " | database_indexes=%i;%i;%i" % (index_size, warning, critical)
if index_size >= critical:
print "CRITICAL - %s indexSize: %.0f MB %s" % (database, index_size, perfdata)
return 2
elif index_size >= warning:
print "WARNING - %s indexSize: %.0f MB %s" % (database, index_size, perfdata)
return 1
else:
print "OK - %s indexSize: %.0f MB %s" % (database, index_size, perfdata)
return 0
except Exception, e:
return exit_with_general_critical(e)
def check_collection_indexes(con, database, collection, warning, critical, perf_data):
#
# These thresholds are basically meaningless, and must be customized to your application
#
warning = warning or 100
critical = critical or 1000
perfdata = ""
try:
set_read_preference(con.admin)
data = con[database].command('collstats', collection)
total_index_size = data['totalIndexSize'] / 1024 / 1024
if perf_data:
perfdata += " | collection_indexes=%i;%i;%i" % (total_index_size, warning, critical)
if total_index_size >= critical:
print "CRITICAL - %s.%s totalIndexSize: %.0f MB %s" % (database, collection, total_index_size, perfdata)
return 2
elif total_index_size >= warning:
print "WARNING - %s.%s totalIndexSize: %.0f MB %s" % (database, collection, total_index_size, perfdata)
return 1
else:
print "OK - %s.%s totalIndexSize: %.0f MB %s" % (database, collection, total_index_size, perfdata)
return 0
except Exception, e:
return exit_with_general_critical(e)
def check_queues(con, warning, critical, perf_data):
warning = warning or 10
critical = critical or 30
try:
data = get_server_status(con)
total_queues = float(data['globalLock']['currentQueue']['total'])
readers_queues = float(data['globalLock']['currentQueue']['readers'])
writers_queues = float(data['globalLock']['currentQueue']['writers'])
message = "Current queue is : total = %d, readers = %d, writers = %d" % (total_queues, readers_queues, writers_queues)
message += performance_data(perf_data, [(total_queues, "total_queues", warning, critical), (readers_queues, "readers_queues"), (writers_queues, "writers_queues")])
return check_levels(total_queues, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def check_collection_size(con, database, collection, warning, critical, perf_data):
warning = warning or 100
critical = critical or 1000
perfdata = ""
try:
set_read_preference(con.admin)
data = con[database].command('collstats', collection)
size = data['size'] / 1024 / 1024
if perf_data:
perfdata += " | collection_size=%i;%i;%i" % (size, warning, critical)
if size >= critical:
print "CRITICAL - %s.%s size: %.0f MB %s" % (database, collection, size, perfdata)
return 2
elif size >= warning:
print "WARNING - %s.%s size: %.0f MB %s" % (database, collection, size, perfdata)
return 1
else:
print "OK - %s.%s size: %.0f MB %s" % (database, collection, size, perfdata)
return 0
except Exception, e:
return exit_with_general_critical(e)
def check_queries_per_second(con, query_type, warning, critical, perf_data):
warning = warning or 250
critical = critical or 500
if query_type not in ['insert', 'query', 'update', 'delete', 'getmore', 'command']:
return exit_with_general_critical("The query type of '%s' is not valid" % query_type)
try:
db = con.local
data = get_server_status(con)
# grab the count
num = int(data['opcounters'][query_type])
# do the math
last_count = db.nagios_check.find_one({'check': 'query_counts'})
try:
ts = int(time.time())
diff_query = num - last_count['data'][query_type]['count']
diff_ts = ts - last_count['data'][query_type]['ts']
query_per_sec = float(diff_query) / float(diff_ts)
# update the count now
db.nagios_check.update({u'_id': last_count['_id']}, {'$set': {"data.%s" % query_type: {'count': num, 'ts': int(time.time())}}})
message = "Queries / Sec: %f" % query_per_sec
message += performance_data(perf_data, [(query_per_sec, "%s_per_sec" % query_type, warning, critical, message)])
except KeyError:
#
# since it is the first run insert it
query_per_sec = 0
message = "First run of check.. no data"
db.nagios_check.update({u'_id': last_count['_id']}, {'$set': {"data.%s" % query_type: {'count': num, 'ts': int(time.time())}}})
except TypeError:
#
# since it is the first run insert it
query_per_sec = 0
message = "First run of check.. no data"
db.nagios_check.insert({'check': 'query_counts', 'data': {query_type: {'count': num, 'ts': int(time.time())}}})
return check_levels(query_per_sec, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def check_oplog(con, warning, critical, perf_data):
""" Checking the oplog time - the time of the log currntly saved in the oplog collection
defaults:
critical 4 hours
warning 24 hours
those can be changed as usual with -C and -W parameters"""
warning = warning or 24
critical = critical or 4
try:
db = con.local
ol = db.system.namespaces.find_one({"name": "local.oplog.rs"})
if (db.system.namespaces.find_one({"name": "local.oplog.rs"}) != None):
oplog = "oplog.rs"
else:
ol = db.system.namespaces.find_one({"name": "local.oplog.$main"})
if (db.system.namespaces.find_one({"name": "local.oplog.$main"}) != None):
oplog = "oplog.$main"
else:
message = "neither master/slave nor replica set replication detected"
return check_levels(None, warning, critical, message)
try:
set_read_preference(con.admin)
data = con.local.command(pymongo.son_manipulator.SON([('collstats', oplog)]))
except:
data = con.admin.command(son.SON([('collstats', oplog)]))
ol_size = data['size']
ol_storage_size = data['storageSize']
ol_used_storage = int(float(ol_size) / ol_storage_size * 100 + 1)
ol = con.local[oplog]
firstc = ol.find().sort("$natural", pymongo.ASCENDING).limit(1)[0]['ts']
lastc = ol.find().sort("$natural", pymongo.DESCENDING).limit(1)[0]['ts']
time_in_oplog = (lastc.as_datetime() - firstc.as_datetime())
message = "Oplog saves " + str(time_in_oplog) + " %d%% used" % ol_used_storage
try: # work starting from python2.7
hours_in_oplog = time_in_oplog.total_seconds() / 60 / 60
except:
hours_in_oplog = float(time_in_oplog.seconds + time_in_oplog.days * 24 * 3600) / 60 / 60
approx_level = hours_in_oplog * 100 / ol_used_storage
message += performance_data(perf_data, [("%.2f" % hours_in_oplog, 'oplog_time', warning, critical), ("%.2f " % approx_level, 'oplog_time_100_percent_used')])
return check_levels(-approx_level, -warning, -critical, message)
except Exception, e:
return exit_with_general_critical(e)
def check_journal_commits_in_wl(con, warning, critical, perf_data):
""" Checking the number of commits which occurred in the db's write lock.
Most commits are performed outside of this lock; committed while in the write lock is undesirable.
Under very high write situations it is normal for this value to be nonzero. """
warning = warning or 10
critical = critical or 40
try:
data = get_server_status(con)
j_commits_in_wl = data['dur']['commitsInWriteLock']
message = "Journal commits in DB write lock : %d" % j_commits_in_wl
message += performance_data(perf_data, [(j_commits_in_wl, "j_commits_in_wl", warning, critical)])
return check_levels(j_commits_in_wl, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def check_journaled(con, warning, critical, perf_data):
""" Checking the average amount of data in megabytes written to the recovery log in the last four seconds"""
warning = warning or 20
critical = critical or 40
try:
data = get_server_status(con)
journaled = data['dur']['journaledMB']
message = "Journaled : %.2f MB" % journaled
message += performance_data(perf_data, [("%.2f" % journaled, "journaled", warning, critical)])
return check_levels(journaled, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def check_write_to_datafiles(con, warning, critical, perf_data):
""" Checking the average amount of data in megabytes written to the databases datafiles in the last four seconds.
As these writes are already journaled, they can occur lazily, and thus the number indicated here may be lower
than the amount physically written to disk."""
warning = warning or 20
critical = critical or 40
try:
data = get_server_status(con)
writes = data['dur']['writeToDataFilesMB']
message = "Write to data files : %.2f MB" % writes
message += performance_data(perf_data, [("%.2f" % writes, "write_to_data_files", warning, critical)])
return check_levels(writes, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def get_opcounters(data, opcounters_name, host):
try:
insert = data[opcounters_name]['insert']
query = data[opcounters_name]['query']
update = data[opcounters_name]['update']
delete = data[opcounters_name]['delete']
getmore = data[opcounters_name]['getmore']
command = data[opcounters_name]['command']
except KeyError, e:
return 0, [0] * 100
total_commands = insert + query + update + delete + getmore + command
new_vals = [total_commands, insert, query, update, delete, getmore, command]
return maintain_delta(new_vals, host, opcounters_name)
def check_opcounters(con, host, warning, critical, perf_data):
""" A function to get all opcounters delta per minute. In case of a replication - gets the opcounters+opcountersRepl"""
warning = warning or 10000
critical = critical or 15000
data = get_server_status(con)
err1, delta_opcounters = get_opcounters(data, 'opcounters', host)
err2, delta_opcounters_repl = get_opcounters(data, 'opcountersRepl', host)
if err1 == 0 and err2 == 0:
delta = [(x + y) for x, y in zip(delta_opcounters, delta_opcounters_repl)]
delta[0] = delta_opcounters[0] # only the time delta shouldn't be summarized
per_minute_delta = [int(x / delta[0] * 60) for x in delta[1:]]
message = "Test succeeded , old values missing"
message = "Opcounters: total=%d,insert=%d,query=%d,update=%d,delete=%d,getmore=%d,command=%d" % tuple(per_minute_delta)
message += performance_data(perf_data, ([(per_minute_delta[0], "total", warning, critical), (per_minute_delta[1], "insert"),
(per_minute_delta[2], "query"), (per_minute_delta[3], "update"), (per_minute_delta[5], "delete"),
(per_minute_delta[5], "getmore"), (per_minute_delta[6], "command")]))
return check_levels(per_minute_delta[0], warning, critical, message)
else:
return exit_with_general_critical("problem reading data from temp file")
def check_current_lock(con, host, warning, critical, perf_data):
""" A function to get current lock percentage and not a global one, as check_lock function does"""
warning = warning or 10
critical = critical or 30
data = get_server_status(con)
lockTime = float(data['globalLock']['lockTime'])
totalTime = float(data['globalLock']['totalTime'])
err, delta = maintain_delta([totalTime, lockTime], host, "locktime")
if err == 0:
lock_percentage = delta[2] / delta[1] * 100 # lockTime/totalTime*100
message = "Current Lock Percentage: %.2f%%" % lock_percentage
message += performance_data(perf_data, [("%.2f" % lock_percentage, "current_lock_percentage", warning, critical)])
return check_levels(lock_percentage, warning, critical, message)
else:
return exit_with_general_warning("problem reading data from temp file")
def check_page_faults(con, host, warning, critical, perf_data):
""" A function to get page_faults per second from the system"""
warning = warning or 10
critical = critical or 30
data = get_server_status(con)
try:
page_faults = float(data['extra_info']['page_faults'])
except:
# page_faults unsupported on the underlaying system
return exit_with_general_critical("page_faults unsupported on the underlaying system")
err, delta = maintain_delta([page_faults], host, "page_faults")
if err == 0:
page_faults_ps = delta[1] / delta[0]
message = "Page faults : %.2f ps" % page_faults_ps
message += performance_data(perf_data, [("%.2f" % page_faults_ps, "page_faults_ps", warning, critical)])
return check_levels(page_faults_ps, warning, critical, message)
else:
return exit_with_general_warning("problem reading data from temp file")
def check_asserts(con, host, warning, critical, perf_data):
""" A function to get asserts from the system"""
warning = warning or 1
critical = critical or 10
data = get_server_status(con)
asserts = data['asserts']
#{ "regular" : 0, "warning" : 6, "msg" : 0, "user" : 12, "rollovers" : 0 }
regular = asserts['regular']
warning_asserts = asserts['warning']
msg = asserts['msg']
user = asserts['user']
rollovers = asserts['rollovers']
err, delta = maintain_delta([regular, warning_asserts, msg, user, rollovers], host, "asserts")
if err == 0:
if delta[5] != 0:
#the number of rollovers were increased
warning = -1 # no matter the metrics this situation should raise a warning
# if this is normal rollover - the warning will not appear again, but if there will be a lot of asserts
# the warning will stay for a long period of time
# although this is not a usual situation
regular_ps = delta[1] / delta[0]
warning_ps = delta[2] / delta[0]
msg_ps = delta[3] / delta[0]
user_ps = delta[4] / delta[0]
rollovers_ps = delta[5] / delta[0]
total_ps = regular_ps + warning_ps + msg_ps + user_ps
message = "Total asserts : %.2f ps" % total_ps
message += performance_data(perf_data, [(total_ps, "asserts_ps", warning, critical), (regular_ps, "regular"),
(warning_ps, "warning"), (msg_ps, "msg"), (user_ps, "user")])
return check_levels(total_ps, warning, critical, message)
else:
return exit_with_general_warning("problem reading data from temp file")
def get_stored_primary_server_name(db):
""" get the stored primary server name from db. """
if "last_primary_server" in db.collection_names():
stored_primary_server = db.last_primary_server.find_one()["server"]
else:
stored_primary_server = None
return stored_primary_server
def check_replica_primary(con, host, warning, critical, perf_data, replicaset):
""" A function to check if the primary server of a replica set has changed """
if warning is None and critical is None:
warning = 1
warning = warning or 2
critical = critical or 2
primary_status = 0
message = "Primary server has not changed"
db = con["nagios"]
data = get_server_status(con)
if replicaset != data['repl'].get('setName'):
message = "Replica set requested: %s differs from the one found: %s" % (replicaset, data['repl'].get('setName'))
primary_status = 2
return check_levels(primary_status, warning, critical, message)
current_primary = data['repl'].get('primary')
saved_primary = get_stored_primary_server_name(db)
if current_primary is None:
current_primary = "None"
if saved_primary is None:
saved_primary = "None"
if current_primary != saved_primary:
last_primary_server_record = {"server": current_primary}
db.last_primary_server.update({"_id": "last_primary"}, {"$set": last_primary_server_record}, upsert=True, safe=True)
message = "Primary server has changed from %s to %s" % (saved_primary, current_primary)
primary_status = 1
return check_levels(primary_status, warning, critical, message)
def check_page_faults(con, sample_time, warning, critical, perf_data):
warning = warning or 10
critical = critical or 20
try:
try:
set_read_preference(con.admin)
data1 = con.admin.command(pymongo.son_manipulator.SON([('serverStatus', 1)]))
time.sleep(sample_time)
data2 = con.admin.command(pymongo.son_manipulator.SON([('serverStatus', 1)]))
except:
data1 = con.admin.command(son.SON([('serverStatus', 1)]))
time.sleep(sample_time)
data2 = con.admin.command(son.SON([('serverStatus', 1)]))
try:
#on linux servers only
page_faults = (int(data2['extra_info']['page_faults']) - int(data1['extra_info']['page_faults'])) / sample_time
except KeyError:
print "WARNING - Can't get extra_info.page_faults counter from MongoDB"
sys.exit(1)
message = "Page Faults: %i" % (page_faults)
message += performance_data(perf_data, [(page_faults, "page_faults", warning, critical)])
check_levels(page_faults, warning, critical, message)
except Exception, e:
exit_with_general_critical(e)
def chunks_balance(con, database, collection, warning, critical):
warning = warning or 10
critical = critical or 20
nsfilter = database + "." + collection
try:
try:
set_read_preference(con.admin)
col = con.config.chunks
nscount = col.find({"ns": nsfilter}).count()
shards = col.distinct("shard")
except:
print "WARNING - Can't get chunks infos from MongoDB"
sys.exit(1)
if nscount == 0:
print "WARNING - Namespace %s is not sharded" % (nsfilter)
sys.exit(1)
avgchunksnb = nscount / len(shards)
warningnb = avgchunksnb * warning / 100
criticalnb = avgchunksnb * critical / 100
for shard in shards:
delta = abs(avgchunksnb - col.find({"ns": nsfilter, "shard": shard}).count())
message = "Namespace: %s, Shard name: %s, Chunk delta: %i" % (nsfilter, shard, delta)
if delta >= criticalnb and delta > 0:
print "CRITICAL - Chunks not well balanced " + message
sys.exit(2)
elif delta >= warningnb and delta > 0:
print "WARNING - Chunks not well balanced " + message
sys.exit(1)
print "OK - Chunks well balanced across shards"
sys.exit(0)
except Exception, e:
exit_with_general_critical(e)
print "OK - Chunks well balanced across shards"
sys.exit(0)
def check_connect_primary(con, warning, critical, perf_data):
warning = warning or 3
critical = critical or 6
try:
try:
set_read_preference(con.admin)
data = con.admin.command(pymongo.son_manipulator.SON([('isMaster', 1)]))
except:
data = con.admin.command(son.SON([('isMaster', 1)]))
if data['ismaster'] == True:
print "OK - This server is primary"
return 0
phost = data['primary'].split(':')[0]
pport = int(data['primary'].split(':')[1])
start = time.time()
err, con = mongo_connect(phost, pport)
if err != 0:
return err
pconn_time = time.time() - start
pconn_time = round(pconn_time, 0)
message = "Connection to primary server " + data['primary'] + " took %i seconds" % pconn_time
message += performance_data(perf_data, [(pconn_time, "connection_time", warning, critical)])
return check_levels(pconn_time, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def check_collection_state(con, database, collection):
try:
con[database][collection].find_one()
print "OK - Collection %s.%s is reachable " % (database, collection)
return 0
except Exception, e:
return exit_with_general_critical(e)
def check_row_count(con, database, collection, warning, critical, perf_data):
try:
count = con[database][collection].count()
message = "Row count: %i" % (count)
message += performance_data(perf_data, [(count, "row_count", warning, critical)])
return check_levels(count, warning, critical, message)
except Exception, e:
return exit_with_general_critical(e)
def build_file_name(host, action):
#done this way so it will work when run independently and from shell
module_name = re.match('(.*//*)*(.*)\..*', __file__).group(2)
return "/tmp/" + module_name + "_data/" + host + "-" + action + ".data"
def ensure_dir(f):
d = os.path.dirname(f)
if not os.path.exists(d):
os.makedirs(d)
def write_values(file_name, string):
f = None
try:
f = open(file_name, 'w')
except IOError, e:
#try creating
if (e.errno == 2):
ensure_dir(file_name)
f = open(file_name, 'w')
else:
raise IOError(e)
f.write(string)
f.close()
return 0
def read_values(file_name):
data = None
try:
f = open(file_name, 'r')
data = f.read()
f.close()
return 0, data
except IOError, e:
if (e.errno == 2):
#no previous data
return 1, ''
except Exception, e:
return 2, None
def calc_delta(old, new):
delta = []
if (len(old) != len(new)):
raise Exception("unequal number of parameters")
for i in range(0, len(old)):
val = float(new[i]) - float(old[i])
if val < 0:
val = new[i]
delta.append(val)
return 0, delta
def maintain_delta(new_vals, host, action):
file_name = build_file_name(host, action)
err, data = read_values(file_name)
old_vals = data.split(';')
new_vals = [str(int(time.time()))] + new_vals
delta = None
try:
err, delta = calc_delta(old_vals, new_vals)
except:
err = 2
write_res = write_values(file_name, ";" . join(str(x) for x in new_vals))
return err + write_res, delta
def replication_get_time_diff(con):
col = 'oplog.rs'
local = con.local
ol = local.system.namespaces.find_one({"name": "local.oplog.$main"})
if ol:
col = 'oplog.$main'
firstc = local[col].find().sort("$natural", 1).limit(1)
lastc = local[col].find().sort("$natural", -1).limit(1)
first = firstc.next()
last = lastc.next()
tfirst = first["ts"]
tlast = last["ts"]
delta = tlast.time - tfirst.time
return delta
#
# main app
#
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))