ok
Mini Shell
from datetime import datetime
import agent_util
import re
import datetime
from agent_util import float
import logging
def custom_json_converter(d):
if "__datetime__" in d:
dt = d["__datetime__"]
# handling for the two different type of datetime formats mongo uses
try:
dt = datetime.datetime.strptime(dt, "%Y-%m-%dT%H:%M:%SZ")
return dt
except:
dt = datetime.datetime.strptime(dt, "%Y-%m-%dT%H:%M:%S.%fZ")
return dt
return d
def execute_query(query, config):
mongo_bin = agent_util.which("mongo", exc=True)
hostname = config.get("hostname", "localhost").strip()
port = int(config.get("port", "27017"))
user = config.get("username", "").strip()
password = config.get("password", "").strip()
database = config.get("database", "").strip()
client_cert = config.get("client_cert", "").strip()
ca_cert = config.get("ca_cert", "").strip()
authenticationdb = config.get("authenticationdb", "").strip()
mongo_connection = "%s " % mongo_bin
if user:
mongo_connection += "-u %s " % user
if password:
mongo_connection += "-p %s" % password.strip()
if client_cert and ca_cert:
mongo_connection += (
"--ssl --sslPEMKeyFile %s --sslCAFile %s --authenticationDatabase '$external' --authenticationMechanism MONGODB-X509"
% (client_cert, ca_cert)
)
if authenticationdb:
mongo_connection += " --authenticationDatabase %s" % authenticationdb.strip()
mongo_connection += " %s:%s/%s" % (hostname, port, database)
query = "printjson(%s)" % query
cmd = "%s --quiet --eval %r" % (mongo_connection, query)
status, raw_output = agent_util.execute_command(cmd)
# strip out some of the special mongo objects from the JSON so we can parse it
result = raw_output.strip()
result = re.sub(
r"Timestamp\((.*?), (.*?)\)", r'{"__timestamp__": {"t": \1, "i": \2}}', result
)
result = re.sub(r"ISODate\((.*?)\)", r'{"__datetime__": \1}', result)
result = re.sub(r'NumberLong\("?-?([0-9]+)"?\)', r"\1", result)
result = re.sub(r"ObjectId\((.*?)\)", r"\1", result)
result = re.sub(
r"BinData\((.*?),(.*?)\)", r'{"__bindata__:": {"a": \1, "b": \2}}', result
)
# conver the cleaned JSON to a dict
try:
result = agent_util.json_loads(result, object_hook=custom_json_converter)
except:
result = {}
return (status, result, raw_output)
class MongoPlugin(agent_util.Plugin):
textkey = "mongo"
label = "Mongo"
@classmethod
def get_metadata(self, config):
# used for general, single node instances
status = agent_util.SUPPORTED
msg = None
# if mongo server is detected in replica set, extended options will become available
replica_set_status = agent_util.SUPPORTED
replica_set_msg = None
mongo = agent_util.which("mongo")
if not mongo:
self.log.info("mongo binary not found")
status = agent_util.UNSUPPORTED
msg = "mongo binary not found"
return {}
if status is agent_util.SUPPORTED:
# we're testing the general connection with this and if it's in a replica set
cmd_status, result, raw_output = execute_query("rs.status()", config)
self.log.debug("Mongo result: %s" % result)
# connection failed
if cmd_status != 0:
self.log.exception(
"error connecting to mongo server. raw output: %s" % raw_output
)
status = agent_util.MISCONFIGURED
msg = "Check your Mongo connection settings in the agent config file."
replica_set_status = agent_util.UNSUPPORTED
replica_set_msg = (
"Check your Mongo connection settings in the agent config file."
)
self.log.warning(replica_set_msg)
# connection succeeded, now check for replica set prescense
else:
if not int(result.get("ok", 0)):
replica_set_status = agent_util.UNSUPPORTED
replica_set_msg = "Mongo server is not part of a replica set"
self.log.warning(replica_set_msg)
self.log.error(raw_output)
self.log.error("Mongo keys: %s" % result.keys())
data = {
"reads": {
"label": "Reads",
"options": None,
"status": status,
"error_message": msg,
"unit": "reads/sec",
},
"writes": {
"label": "Writes",
"options": None,
"status": status,
"error_message": msg,
"unit": "writes/sec",
},
"objects": {
"label": "Objects",
"options": None,
"status": status,
"error_message": msg,
"unit": "objects",
},
"dataSize": {
"label": "Size of documents",
"options": None,
"status": status,
"error_message": msg,
"unit": "bytes",
},
"indexSize": {
"label": "Size of indexes",
"options": None,
"status": status,
"error_message": msg,
"unit": "bytes",
},
"extra_info.page_faults": {
"label": "Page Faults",
"options": None,
"status": status,
"error_message": msg,
"unit": "faults/sec",
},
"storageSize": {
"label": "Size of extents",
"options": None,
"status": status,
"error_message": msg,
"unit": "bytes",
},
"connections.current": {
"label": "Current connections",
"options": None,
"status": status,
"error_message": msg,
"unit": "connections",
},
"connections.available": {
"label": "Available connections",
"options": None,
"status": status,
"error_message": msg,
"unit": "connections",
},
"cursors.total_open": {
"label": "Open cursors",
"options": None,
"status": status,
"error_message": msg,
"unit": "cursors",
},
"cursors.timed_out": {
"label": "Timed out cursors",
"options": None,
"status": status,
"error_message": msg,
"unit": "cursors",
},
"globalLock.currentQueue.total": {
"label": "Total number of operations queued waiting for lock",
"options": None,
"status": status,
"error_message": msg,
"unit": "operations",
},
"globalLock.currentQueue.readers": {
"label": "Number of operations queued waiting for read lock",
"options": None,
"status": status,
"error_message": msg,
"unit": "operations",
},
"globalLock.currentQueue.writers": {
"label": "Number of operations queued waiting for write lock",
"options": None,
"status": status,
"error_message": msg,
"unit": "operations",
},
"replica_set.is_primary": {
"label": "Is replica set PRIMARY member",
"options": None,
"status": replica_set_status,
"error_message": replica_set_msg,
"unit": "boolean",
},
"replica_set.state": {
"label": "MongoDB replica set member state",
"options": None,
"status": replica_set_status,
"error_message": replica_set_msg,
"unit": "state",
},
"replica_set.health": {
"label": "MongoDB replica set member health",
"options": None,
"status": replica_set_status,
"error_message": replica_set_msg,
"unit": "health",
},
"replica_set.primary_optime_date_difference": {
"label": "Difference of primary node's optime date and realtime",
"options": None,
"status": replica_set_status,
"error_message": replica_set_msg,
"unit": "seconds",
},
"replica_set.max_members_ping_ms_difference": {
"label": "Maximum difference of members' ping ms from primary node's ping ms",
"options": None,
"status": replica_set_status,
"error_message": replica_set_msg,
"unit": "ms",
},
}
return data
@classmethod
def get_metadata_docker(self, container, config):
if "hostname" not in config:
try:
ip = agent_util.get_container_ip(container)
config["hostname"] = ip
except Exception:
self.log.exception("Docker metadata error")
config["from_docker"] = True
return self.get_metadata(config)
def get_mongo_cache(self, textkey, curr_reqs):
cache = self.get_cache_results("mongo:%s" % textkey, None)
if not cache:
self.log.info("Empty mongo cache! Building for the first time.")
self.cache_result("mongo:%s" % textkey, None, curr_reqs, replace=True)
return None, None
delta, previous_reqs = cache[0]
self.cache_result("mongo:%s" % textkey, None, curr_reqs, replace=True)
return delta, float(previous_reqs)
def check(self, textkey, data, config):
rs_status, rs_result, rs_raw_output = execute_query("rs.status()", config)
ss_status, ss_result, ss_raw_output = execute_query("db.serverStatus()", config)
db_stats, db_result, db_raw_output = execute_query("db.stats()", config)
self.log.debug("Debug Output from Mongo Plugin:")
self.log.debug(rs_result)
self.log.debug(ss_raw_output)
if textkey == "reads":
queries = ss_result.get("opcounters", {}).get("query", None)
get_mores = ss_result.get("opcounters", {}).get("getmore", None)
if queries is None or get_mores is None:
return None
queries = float(queries)
get_mores = float(get_mores)
curr_data = queries + get_mores
delta, previous_data = self.get_mongo_cache(textkey, curr_data)
if previous_data is None or curr_data < previous_data:
return None
return (curr_data - previous_data) / float(delta)
if textkey == "writes":
inserts = ss_result.get("opcounters", {}).get("insert", None)
updates = ss_result.get("opcounters", {}).get("update", None)
deletes = ss_result.get("opcounters", {}).get("delete", None)
if inserts is None or updates is None or deletes is None:
return None
inserts = float(inserts)
updates = float(updates)
deletes = float(deletes)
curr_data = inserts + updates + deletes
delta, previous_data = self.get_mongo_cache(textkey, curr_data)
if previous_data is None or curr_data < previous_data:
return None
return (curr_data - previous_data) / float(delta)
if textkey == "extra_info.page_faults":
curr_data = ss_result.get("extra_info", {}).get("page_faults", None)
if curr_data is None:
return None
curr_data = float(curr_data)
delta, previous_data = self.get_mongo_cache(textkey, curr_data)
if previous_data is None or curr_data < previous_data:
return None
return (curr_data - previous_data) / float(delta)
if textkey == "connections.current":
return ss_result.get("connections", {}).get("current", None)
if textkey == "dataSize":
return db_result.get("dataSize", None)
if textkey == "storageSize":
return db_result.get("storageSize", None)
if textkey == "indexSize":
return db_result.get("indexSize", None)
if textkey == "objects":
return db_result.get("objects", None)
elif textkey == "connections.available":
return ss_result.get("connections", {}).get("available", None)
elif textkey == "cursors.total_open":
return ss_result.get("cursors", {}).get("totalOpen", None)
elif textkey == "cursors.timed_out":
return ss_result.get("cursors", {}).get("timedOut", None)
elif textkey == "globalLock.currentQueue.total":
return (
ss_result.get("globalLock", {})
.get("currentQueue", {})
.get("total", None)
)
elif textkey == "globalLock.currentQueue.readers":
return (
ss_result.get("globalLock", {})
.get("currentQueue", {})
.get("readers", None)
)
elif textkey == "globalLock.currentQueue.writers":
return (
ss_result.get("globalLock", {})
.get("currentQueue", {})
.get("writers", None)
)
elif textkey == "replica_set.is_primary":
is_primary = 0
for member in rs_result.get("members", []):
if (
member.get("self") in (True, "true")
and member.get("stateStr") == "PRIMARY"
):
is_primary = 1
return is_primary
elif textkey == "replica_set.state":
return rs_result["myState"]
elif textkey == "replica_set.health":
health = None
for member in rs_result.get("members", []):
if member.get("self") in (True, "true"):
health = member.get("health", None)
return health
elif "all_members_healthy" in textkey:
for member in rs_result["members"]:
try:
if member["health"] != 1.0:
return False
except:
continue
return True
else:
try:
primaryNodeStatus = filter(
lambda node: node["stateStr"] == "PRIMARY", rs_result["members"]
)[0]
except:
return None
if "primary_optime_date_difference" in textkey:
try:
td = datetime.datetime.now() - primaryNodeStatus["optimeDate"]
return_val = (
td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6
) / float(10**6)
self.log.debug(
"primary_optime_date_difference: %s" % str(return_val)
)
return return_val
except:
return 999999
elif "max_members_ping_ms_difference" in textkey:
if "pingMs" not in primaryNodeStatus:
return 0
max_ping_ms_difference = -1
for member in status["members"]:
if member["stateStr"] != "PRIMARY":
try:
max_ping_ms_difference = max(
max_ping_ms_difference,
abs(primaryNodeStatus["pingMs"] - member["pingMs"]),
)
except:
continue
if max_ping_ms_difference == -1:
return 999999
self.log.debug("max_ping_ms_difference: %s" % max_ping_ms_difference)
return max_ping_ms_difference
def check_docker(self, container, textkey, data, config):
if "hostname" not in config:
try:
ip = agent_util.get_container_ip(container)
config["hostname"] = ip
except Exception as e:
self.log.exception(e)
config["from_docker"] = True
return self.check(textkey, data, config)
Zerion Mini Shell 1.0