def check_memory_element( label, used, total, levels, label_total="", show_free=False, metric_name=None, create_percent_metric=False, ): """Return a check result for one memory element""" if show_free: show_value = total - used show_text = " free" else: show_value = used show_text = "" infotext = "%s: %s%s - %s of %s%s" % ( label, get_percent_human_readable(100.0 * show_value / total), show_text, get_bytes_human_readable(show_value, base=1024), get_bytes_human_readable(total, base=1024), (" %s" % label_total).rstrip(), ) try: mode, (warn, crit) = levels except (ValueError, TypeError): # handle None, "ignore" mode, (warn, crit) = "ignore", (None, None) warn, crit, levels_text = normalize_mem_levels(mode, warn, crit, total) state = _compute_state(used, warn, crit) if state and levels_text: infotext = "%s (%s)" % (infotext, levels_text) perf = [] if metric_name: perf.append((metric_name, used, warn, crit, 0, total)) if create_percent_metric: scale_to_perc = 100.0 / total perf.append(( "mem_used_percent", used * scale_to_perc, warn * scale_to_perc if warn is not None else None, crit * scale_to_perc if crit is not None else None, 0, None, # some times over 100%! )) return state, infotext, perf
def check_memory(params, meminfo): if isinstance(params, tuple): params = {"levels": params} memtotal = MemBytes(meminfo['MemTotal']) memused = MemBytes(memtotal.kb - meminfo['MemFree']) if "SwapFree" in meminfo: swaptotal = MemBytes(meminfo['SwapTotal']) swapused = MemBytes(swaptotal.kb - meminfo['SwapFree']) perfdata = [('swap_used', swapused.bytes, None, None, 0, swaptotal.bytes)] else: swaptotal = None swapused = None perfdata = [] # Size of Pagetable on Linux can be relevant e.g. on ORACLE # servers with much memory, that do not use HugeTables. We account # that for used if 'PageTables' in meminfo: pagetables = MemBytes(meminfo['PageTables']) perfdata.append(('mem_lnx_page_tables', pagetables.bytes)) else: pagetables = None # Buffers and Cached are optional. On Linux both mean basically the same. caches = MemBytes(meminfo.get('Buffers', 0) + meminfo.get('Cached', 0)) ramused = MemBytes(memused.kb - caches.kb) perfdata.append(('mem_used', ramused.bytes, None, None, 0, memtotal.bytes)) perfdata.append(('mem_used_percent', 100. * ramused.bytes / memtotal.bytes, None, None, 0, 100.)) totalused, totalused_descr = _get_total_usage(ramused, swapused, pagetables) infotext = check_memory_element( totalused_descr, totalused.bytes, memtotal.bytes, None, label_total="RAM" if totalused_descr != "RAM" else "", )[1] # Take into account averaging average_min = params.get("average") if average_min: totalused_mb_avg = get_average("mem.used.total", time.time(), totalused.mb, average_min, initialize_zero=False) totalused_perc_avg = totalused_mb_avg / memtotal.mb * 100 infotext += ", %d min average %.1f%%" % (average_min, totalused_perc_avg) perfdata.append(('memusedavg', totalused_mb_avg)) comp_mb = totalused_mb_avg else: comp_mb = totalused.mb # Normalize levels and check them totalvirt = MemBytes((swaptotal.kb if swaptotal is not None else 0) + memtotal.kb) warn, crit = params.get("levels", (None, None)) mode = get_levels_mode_from_value(warn) warn_mb, crit_mb, levels_text = normalize_mem_levels( mode, abs(warn), abs(crit), totalvirt.mb, _perc_total=memtotal.mb, render_unit=1024**2, ) perfdata.append(('mem_lnx_total_used', totalused.bytes, warn_mb * 1024**2, crit_mb * 1024**2, 0, totalvirt.bytes)) # Check levels state = _compute_state(comp_mb, warn_mb, crit_mb) if state and levels_text: infotext = "%s (%s)" % (infotext, levels_text) yield state, infotext, perfdata if totalused_descr != "RAM": yield check_memory_element( "RAM", ramused.bytes, # <- caches subtracted memtotal.bytes, None, ) if swaptotal and swaptotal.bytes: yield check_memory_element( "Swap", swapused.bytes, swaptotal.bytes, None, ) if pagetables: yield 0, "Pagetables: %s" % pagetables.render(), [] # Add additional metrics, provided by Linux. if meminfo.get('Mapped'): for key, label, metric in ( ('Mapped', 'Mapped', 'mem_lnx_mapped'), ('Committed_AS', 'Committed', 'mem_lnx_committed_as'), ('Shmem', 'Shared', 'mem_lnx_shmem'), ): value = MemBytes(meminfo.get(key, 0)) yield 0, "%s: %s" % (label, value.render()), [(metric, value.bytes) ]