def handle_graylog_messages(messages, params):
msgs_levels_upper = params.get("msgs_upper", (None, None))
msgs_levels_lower = params.get("msgs_lower", (None, None))
yield check_levels(
messages,
"messages",
msgs_levels_upper + msgs_levels_lower,
human_readable_func=int,
infoname="Total number of messages",
)
avg_key = "msgs_avg"
avg = params.get(avg_key, 30)
msgs_avg_levels_upper = params.get("msgs_avg_upper", (None, None))
msgs_avg_levels_lower = params.get("msgs_avg_lower", (None, None))
this_time = time.time()
rate = get_rate("graylog_%s.rate" % avg_key, this_time, messages)
avg_rate = get_average("graylog_%s.avg" % avg_key, this_time, rate, avg)
yield check_levels(
avg_rate,
avg_key,
msgs_avg_levels_upper + msgs_avg_levels_lower,
infoname="Average number of messages (%s)" %
get_age_human_readable(avg * 60),
)
diff_key = "msgs_diff"
timespan = params.get(diff_key, 1800)
diff_levels_upper = params.get("%s_upper" % diff_key, (None, None))
diff_levels_lower = params.get("%s_lower" % diff_key, (None, None))
diff = _get_value_diff("graylog_%s" % diff_key, messages, timespan)
yield check_levels(
diff,
"graylog_diff",
diff_levels_upper + diff_levels_lower,
infoname="Total number of messages last %s" %
get_age_human_readable(timespan),
)
def check_ups_capacity(_item, params, info):
# To support inventories with the old version
if isinstance(params, tuple): # old format with 2 params in tuple
warn, crit = params
cap_warn, cap_crit = (95, 90)
elif isinstance(params, dict): # new dict format
warn, crit = params.get('battime', (0, 0))
cap_warn, cap_crit = params.get('capacity', (95, 90))
else:
warn, crit = (0, 0)
cap_warn, cap_crit = (95, 90)
minutes_on_bat, minutes_left, percent_fuel = (
int(num) if num.strip() else None #
for num in info[0])
on_battery = minutes_left is not None and minutes_on_bat
# Check time left on battery
# `minutes_left` can be 0 which not always means that there's no time left but the device might
# also just be on main power supply
if on_battery:
yield check_levels(
minutes_left * 60,
"capacity",
(None, None, warn * 60, crit * 60),
human_readable_func=get_age_human_readable,
infoname="Minutes left",
)
else:
yield 0, "on mains"
# Check percentual capacity - note that capacity will only be checked on battery
if percent_fuel is not None:
yield check_levels(
percent_fuel,
"percent",
(None, None, cap_warn, cap_crit) if on_battery else None,
human_readable_func=get_percent_human_readable,
infoname="Percent",
)
# Output time on battery
if minutes_on_bat is not None and minutes_on_bat > 0:
yield 0, "Time running on battery: %s" % get_age_human_readable(minutes_on_bat * 60)
def check_diskstat_dict(item, params, disks):
# Take care of previously discovered services
if item in ("read", "write"):
yield 3, "Sorry, the new version of this check does not " \
"support one service for read and one for write anymore."
return
this_time = time.time()
disk = diskstat_select_disk(disks, item)
if not disk:
return
# Averaging
# Note: this check uses a simple method of averaging: As soon as averaging
# is turned on the actual metrics are *replaced* by the averaged ones. No
# duplication of performance data or check output here. This is because we
# have so many metrics...
prefix = ""
averaging = params.get("average") # in seconds here!
if averaging:
avg_disk = {} # Do not modify our arguments!!
for key, value in disk.items():
if isinstance(value, (int, float)):
avg_disk[key] = get_average("diskstat.%s.%s.avg" % (item, key), this_time, value,
averaging / 60.0)
else:
avg_disk[key] = value
disk = avg_disk
prefix = "%s average: " % get_age_human_readable(averaging)
# Utilization
if "utilization" in disk:
util = disk.pop("utilization")
yield check_levels(util,
"disk_utilization",
params.get("utilization"),
human_readable_func=lambda x: get_percent_human_readable(x * 100.0),
scale=0.01,
statemarkers=False,
infoname=prefix + "Utilization")
# Throughput
for what in "read", "write":
if what + "_throughput" in disk:
throughput = disk.pop(what + "_throughput")
yield check_levels(throughput,
"disk_" + what + "_throughput",
params.get(what),
unit="/s",
scale=1048576,
statemarkers=False,
human_readable_func=get_bytes_human_readable,
infoname=what.title())
# Average wait from end to end
for what in ["wait", "read_wait", "write_wait"]:
if "average_" + what in disk:
wait = disk.pop("average_" + what)
yield check_levels(wait,
"disk_average_" + what,
params.get(what),
unit="ms",
scale=0.001,
statemarkers=False,
infoname="Average %s" % what.title().replace("_", " "))
# Average disk latency
if "latency" in disk:
latency = disk.pop("latency")
yield check_levels(latency,
"disk_latency",
params.get("latency"),
unit="ms",
scale=0.001,
statemarkers=False,
infoname='Latency')
# Read/write disk latency
for what in ["read", "write"]:
latency_key = "%s_latency" % what
if latency_key not in disk:
continue
latency = disk.pop(latency_key)
if latency is not None:
yield check_levels(latency,
"disk_%s" % latency_key,
params.get(latency_key),
unit="ms",
scale=0.001,
statemarkers=False,
infoname='%s latency' % what.title())
# Queue lengths
for what, plugin_text in [
("queue_length", "Queue Length"),
("read_ql", "Read Queue Length"),
("write_ql", "Write Queue Length"),
]:
if what in disk:
ql = disk.pop(what)
yield check_levels(ql,
"disk_" + what,
params.get(what),
statemarkers=False,
infoname="Average %s" % plugin_text)
# I/O operations
for what in "read", "write":
if what + "_ios" in disk:
ios = disk.pop(what + "_ios")
yield check_levels(
ios,
"disk_" + what + "_ios",
params.get(what + "_ios"),
unit="1/s",
statemarkers=False,
infoname="%s operations" % what.title(),
)
# All the other metrics are currently not output in the plugin output - simply because
# of their amount. They are present as performance data and will shown in graphs.
# Send everything as performance data now. Sort keys alphabetically
perfdata = []
for key in sorted(disk):
value = disk[key]
if isinstance(value, (int, float)):
# Currently the levels are not shown in the perfdata
perfdata.append(("disk_" + key, value))
if perfdata:
yield 0, '', perfdata
