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