def perfometer_ipmi_sensors(row, check_command, perf_data):
state = row["service_state"]
color = "#39f"
value = float(perf_data[0][1])
crit = utils.savefloat(perf_data[0][4])
if not crit:
return "%d" % int(value), perfometer_logarithmic(value, 40, 1.2, color)
perc = value * 100.0 / crit
# some sensors get critical if the value is < crit (fans), some if > crit (temp)
if value <= crit:
data = [(perc, color), (100 - perc, get_themed_perfometer_bg_color())]
elif state == 0: # fan, OK
m = max(value, 10000.0)
perc_crit = crit * 100.0 / m
perc_value = (value - crit) * 100.0 / m
perc_free = (m - value) * 100.0 / m
data = [(perc_crit, color), (perc_value, color),
(perc_free, get_themed_perfometer_bg_color())]
else:
data = []
if perf_data[0][0] == "temp":
unit = "°C"
else:
unit = ""
return (u"%d%s" % (int(value), unit)), render_perfometer(data)
def perfometer_check_mk_ibm_svc_host(row, check_command, perf_data):
if len(perf_data) < 5:
return "", ""
active = int(perf_data[0][1])
inactive = int(perf_data[1][1])
degraded = int(perf_data[2][1])
offline = int(perf_data[3][1])
other = int(perf_data[4][1])
total = active + inactive + degraded + offline + other
data = []
if active > 0:
perc_active = active * 100.0 / total
data.append((perc_active, "#008000"))
if inactive > 0:
perc_inactive = inactive * 100.0 / total
data.append((perc_inactive, "#0000FF"))
if degraded > 0:
perc_degraded = degraded * 100.0 / total
data.append((perc_degraded, "#F84"))
if offline > 0:
perc_offline = offline * 100.0 / total
data.append((perc_offline, "#FF0000"))
if other > 0:
perc_other = other * 100.0 / total
data.append((perc_other, "#000000"))
if total == 0:
data.append((100, get_themed_perfometer_bg_color()))
return "%d active" % active, render_perfometer(data)
def perfometer_bandwidth(in_traffic, out_traffic, in_bw, out_bw, unit="B"):
traffic_multiplier = 1 if (unit == "B") else 8
# if we do not have bandwith make logarithmic perf-o-meter
if in_bw <= 0.0 or out_bw <= 0.0:
MB = 1000000.0
readable_in = number_human_readable(in_traffic * traffic_multiplier, 1,
unit)
readable_out = number_human_readable(out_traffic * traffic_multiplier,
1, unit)
text = "%s/s %s/s" % (readable_in, readable_out)
return text, perfometer_logarithmic_dual(in_traffic, "#0e6",
out_traffic, "#2af", MB, 5)
# if we have bandwidth
txt, data = [], []
for name, bytes_, bw, color in [("in", in_traffic, in_bw, "#0e6"),
("out", out_traffic, out_bw, "#2af")]:
rrate = bytes_ / bw # fixed: true-division
drate = max(0.02, rrate**0.5**0.5)
rperc = 100 * rrate
dperc = 100 * drate
a = (dperc / 2.0, color)
b = (50 - dperc / 2.0, get_themed_perfometer_bg_color())
txt.append("%.1f%%" % rperc)
if name == "in":
data.extend([b, a]) # white left, color right
else:
data.extend([a, b]) # color right, white left
return " ".join(txt), render_perfometer(data)
def perfometer_check_mk_ibm_svc_cache(row, check_command, perf_data):
write_cache_pc = int(perf_data[0][1])
total_cache_pc = int(perf_data[1][1])
read_cache_pc = total_cache_pc - write_cache_pc
free_cache_pc = 100 - total_cache_pc
data = [(write_cache_pc, "#60e0a0"), (read_cache_pc, "#60a0e0"),
(free_cache_pc, get_themed_perfometer_bg_color())]
return "%d %% write, %d %% read" % (write_cache_pc, read_cache_pc), render_perfometer(data)
def perfometer_hpux_snmp_cs_cpu(row, check_command, perf_data):
data = [
(float(perf_data[0][1]), "#60f020"),
(float(perf_data[1][1]), "#ff6000"),
(float(perf_data[2][1]), "#00d080"),
(float(perf_data[3][1]), get_themed_perfometer_bg_color()),
]
total = float(perf_data[0][1]) + float(perf_data[1][1]) + float(perf_data[2][1])
return "%.0f%%" % total, render_perfometer(data)
def perfometer_oracle_tablespaces(row, check_command, perf_data):
current = float(perf_data[0][1])
used = float(perf_data[1][1])
max_ = float(perf_data[2][1])
used_perc = used / max_ * 100 # fixed: true-division
curr_perc = (current / max_ * 100) - used_perc # fixed: true-division
data = [
(used_perc, "#f0b000"),
(curr_perc, "#00ff80"),
(100 - used_perc - curr_perc, "#80c0ff"),
]
return "%.1f%%" % used_perc, render_perfometer(data)
def perfometer_mssql_tablespaces(row, check_command, perf_data):
reserved = float(perf_data[2][1])
data = float(perf_data[3][1])
indexes = float(perf_data[4][1])
unused = float(perf_data[5][1])
data_perc = data / reserved * 100 # fixed: true-division
indexes_perc = indexes / reserved * 100 # fixed: true-division
unused_perc = unused / reserved * 100 # fixed: true-division
return ("%.1f%%" % (data_perc + indexes_perc),
render_perfometer([(data_perc, "#80c0ff"), (indexes_perc, "#00ff80"),
(unused_perc, "#f0b000")]))
def perfometer_check_mk_ntp(row, check_command, perf_data, unit="ms"):
offset = float(perf_data[0][1])
absoffset = abs(offset)
crit = float(perf_data[0][4])
max_ = crit * 2
absoffset = min(absoffset, max_)
rel = 50 * (absoffset / max_) # fixed: true-division
color = {0: "#0f8", 1: "#ff2", 2: "#f22", 3: "#fa2"}[row["service_state"]]
if offset > 0:
data = [(50, get_themed_perfometer_bg_color()), (rel, color),
(50 - rel, get_themed_perfometer_bg_color())]
else:
data = [(50 - rel, get_themed_perfometer_bg_color()), (rel, color),
(50, get_themed_perfometer_bg_color())]
return "%.2f %s" % (offset, unit), render_perfometer(data)
def perfometer_check_mk_mem_used(row, check_command, perf_data):
ram_used = None
for entry in perf_data:
# Get total and used RAM
if entry[0] == "ramused":
ram_used = float(entry[1]) # mem.include
ram_total = float(entry[6]) # mem.include
elif entry[0] == "mem_used":
ram_used = float(entry[1]) # mem.linux
elif entry[0] == "mem_total":
ram_total = float(entry[1]) # mem.linux
# Get total and used SWAP
elif entry[0] == "swapused":
swap_used = float(entry[1]) # mem.include
swap_total = float(entry[6]) # mem.include
elif entry[0] == "swap_used":
swap_used = float(entry[1]) # mem.linux
elif entry[0] == "swap_total":
swap_total = float(entry[1]) # mem.linux
if not ram_used:
return "", ""
virt_total = ram_total + swap_total
virt_used = ram_used + swap_used
# paint used ram and swap
ram_color, swap_color = "#80ff40", "#008030"
data = [
(ram_used * 100.0 / virt_total, ram_color),
(swap_used * 100.0 / virt_total, swap_color),
]
# used virtual memory < ram => show free ram and free total virtual memory
if virt_used < ram_total:
data.append(((ram_total - virt_used) * 100.0 / virt_total,
get_themed_perfometer_bg_color()))
data.append(((virt_total - ram_total) * 100.0 / virt_total, "#ccc"))
# usage exceeds ram => show only free virtual memory
else:
data.append((100 * (virt_total - virt_used), "#ccc"))
return "%d%%" % (100 * (virt_used / ram_total)), render_perfometer(
data) # fixed: true-division
def perfometer_esx_vsphere_datastores(row, check_command, perf_data):
used_mb = perf_data[0][1]
maxx = perf_data[0][-1]
# perf data might be incomplete, if trending perfdata is off...
uncommitted_mb = 0
for entry in perf_data:
if entry[0] == "uncommitted":
uncommitted_mb = entry[1]
break
perc_used = 100 * (float(used_mb) / float(maxx))
perc_uncommitted = 100 * (float(uncommitted_mb) / float(maxx))
perc_totally_free = 100 - perc_used - perc_uncommitted
if perc_used + perc_uncommitted <= 100:
# Regular handling, no overcommitt
data = [
(perc_used, "#00ffc6"),
(perc_uncommitted, "#eeccff"),
(perc_totally_free, get_themed_perfometer_bg_color()),
]
else:
# Visualize overcommitted space by scaling to total overcommittment value
# and drawing the capacity as red line in the perfometer
total = perc_used + perc_uncommitted
perc_used_bar = perc_used * 100.0 / total
perc_free = (100 - perc_used) * 100.0 / total
data = [
(perc_used_bar, "#00ffc6"),
(perc_free, "#eeccff"),
(1, "red"), # This line visualizes the capacity
(perc_uncommitted - perc_free, "#eeccff"),
]
legend = "%0.2f%%" % perc_used
if uncommitted_mb:
legend += " (+%0.2f%%)" % perc_uncommitted
return legend, render_perfometer(data)
def perfometer_mssql_counters_cache_hits(row, check_command, perf_data):
perc = float(perf_data[0][1])
data = [(perc, "#69EA96"), (100 - perc, get_themed_perfometer_bg_color())]
return "%.1f%%" % perc, render_perfometer(data)
