ok
Mini Shell
import agent_util
from sys import platform, exc_info
import logging
import re
from agent_util import float
class DevicePathManager:
def __init__(self, execute_function=None):
if not execute_function:
self._execute_function = agent_util.execute_command
else:
self._execute_function = execute_function
try:
command = "lsblk --pairs"
if "darwin" in platform:
disk_util = agent_util.which("diskutil")
command = "{} list".format(disk_util)
self._output = self._execute_function(command)
self._output = self._output[1].split("\n")
except Exception:
logging.exception("Error getting devices")
self._output = []
def find_path(self, device):
if "darwin" in platform:
for line in self._output:
if line.startswith("/"):
mp = line.split(" ")[0]
if mp[len("/dev/") :] == device:
return mp
return None
else:
for line in self._output:
expression = r'^NAME="(%s)".*MOUNTPOINT="(.*)"$' % (device)
match = re.match(expression, line)
if match:
matched_mountpoint = match.groups()[1]
if matched_mountpoint == "":
# Some devices don't show a mountpoint, in those
# cases, return the same device.
return device
else:
return matched_mountpoint
class IOStatPlugin(agent_util.Plugin):
textkey = "iostat"
label = "IO"
metrics_list = [
"rrqm/s",
"wrqm/s",
"r/s",
"w/s",
"svctm",
"rkB/s",
"wkB/s",
"%w",
"%b",
"wait",
"actv",
"kr/s",
"kw/s",
"svc_t",
"%util",
]
metrics_labels = {
"rrqm/s": "Read requests queued",
"wrqm/s": "Write requests queued",
"r/s": "Read requests",
"w/s": "Write requests",
"svctm": "Average I/O request service time",
"%w": "% of time transactions are waiting",
"%b": "Percent of time the disk is busy",
"wait": "Average transactions waiting for service",
"actv": "Average transactions being serviced",
"kr/s": "Data read rate",
"kw/s": "Data write rate",
"svc_t": "Average response time",
"%util": "% of I/O CPU time",
}
metrics_units = {
"rrqm/s": "requests/second",
"wrqm/s": "requests/second",
"r/s": "requests/second",
"w/s": "requests/second",
"svctm": "ms",
"%w": "percent",
"%b": "percent",
"wait": "transactions",
"actv": "transactions",
"kr/s": "KB/s",
"kw/s": "KB/s",
"svc_t": "Average response time",
"%util": "% of I/O CPU time",
}
darwinMetricsMap = {"kbpt": "KB/t", "tps": "tps", "mbps": "MB/s"}
@classmethod
def get_metadata(self, config):
status = agent_util.SUPPORTED
msg = None
iostat_bin = agent_util.which("iostat")
if not iostat_bin:
self.log.info("iostat not found")
status = agent_util.MISCONFIGURED
msg = "Install iostat."
return {}
self.log.debug("Starting IOStat")
# get our devices to monitor
devices = []
data = {}
output = None
header = []
options_schema = {"resource": "string", "mountpoint": "string"}
device_path_manager = DevicePathManager()
if "hp-ux" in platform:
ret, out = agent_util.execute_command("%s | sed '/^loop/d' " % iostat_bin)
lines = out.strip().splitlines()
for line in lines:
if line.startswith("device") or line == "" or not line:
continue
device = line.split()[0]
mountpoint = device_path_manager.find_path(device)
devices.append(
{
"resource": device,
"mountpoint": mountpoint,
}
)
self.log.debug("Devices found: %s" % devices)
metdata = {
"bps": {
"label": "kilobytes per second",
"options": devices,
"status": status,
"error_message": msg,
"unit": "kb",
"options_schema": options_schema,
},
"sps": {
"label": "disk seeks per second",
"options": devices,
"status": status,
"error_message": msg,
"unit": "",
"options_schema": options_schema,
},
}
return metdata
elif "darwin" in platform:
ret, out = agent_util.execute_command("%s -d" % iostat_bin)
if 0 != ret:
status = agent_util.MISCONFIGURED
msg = "iostat failure code {}".format(ret)
else:
lines = out.strip().splitlines()
devs = lines[0].strip().split()
for device in devs:
mp = device_path_manager.find_path(device)
if mp:
devices.append({"resource": device, "mountpoint": mp})
else:
status = agent_util.MISCONFIGURED
msg = "Could not map device"
break
metadata = {
"kbpt": {
"label": "Kilobytes per transfer",
"options": devices,
"status": status,
"error_msg": msg,
"unit": "KB/s",
"options_schema": options_schema,
},
"tps": {
"label": "Transfers per second",
"options": devices,
"status": status,
"error_msg": msg,
"unit": "transfers/s",
"options_schema": options_schema,
},
"mbps": {
"label": "Megabytes per second",
"options": devices,
"status": status,
"error_msg": msg,
"unit": "MB/s",
"options_schema": options_schema,
},
}
return metadata
else:
ret_code, output = agent_util.execute_command(
"%s -dx | sed '/^loop/d' " % iostat_bin
)
output = output.strip().splitlines()
self.log.debug("#####################################################")
self.log.debug("IO stats command '%s -dx' output:" % iostat_bin)
self.log.debug(str(output))
self.log.debug("#####################################################")
for line in reversed(output):
if line.lower().startswith("device"):
header = line.split()
break
fields = line.strip().split()
dev = fields[0]
if dev.lower().startswith("dm-"):
continue
mountpoint = device_path_manager.find_path(dev)
devices.append({"resource": dev, "mountpoint": mountpoint})
self.log.debug("Devices: %s" % str(devices))
# no devices? no resources to monitor then
if not devices:
status = agent_util.MISCONFIGURED
msg = "No devices found from iostat."
for metric in header:
self.log.debug("###########\nMetric: %s" % str(metric))
if metric in self.metrics_list:
self.log.debug(
"metric %s has the index value of %s"
% (str(metric), str(header.index(metric)))
)
data[str(metric)] = {
"label": self.metrics_labels.get(str(metric), str(metric)),
"options": devices,
"options_schema": options_schema,
"status": status,
"error_message": msg,
}
if str(metric) in self.metrics_units:
data[str(metric)]["unit"] = self.metrics_units.get(str(metric))
return data
def check(self, textkey, device, config):
metrics_index = {}
iostat_bin = agent_util.which("iostat")
second_line = False
header_line = 2
if "freebsd" in platform:
header_line = 1
if "sunos" in platform:
second_line = True
ret, output = agent_util.execute_command(
"%s -dx 1 2 | sed '/^loop/d'" % (iostat_bin),
cache_timeout=agent_util.DEFAULT_CACHE_TIMEOUT,
)
header = output.strip().splitlines()[1].split()
elif "hp-ux" in platform:
ret, out = agent_util.execute_command(
"iostat 1 2 | sed '/^loop/d'",
cache_timeout=agent_util.DEFAULT_CACHE_TIMEOUT,
)
lines = out.strip().splitlines()
previously_seen = False
for line in lines:
line = line.strip()
if previously_seen is False and line.startswith(device):
previously_seen = True
self.log.debug("Found first instance of disk %s" % device)
elif previously_seen is True and line.startswith(device):
self.log.debug("Found second instance of disk %s" % device)
self.log.debug(line)
l = line.split()
if textkey == "bps":
return float(l[1])
elif textkey == "sps":
return float(l[2])
else:
return None
elif "darwin" in platform:
try:
outputKey = self.darwinMetricsMap.get(textkey, None)
if outputKey is None:
raise Exception("Unrecognized textkey {}".format(textkey))
ret, output = agent_util.execute_command(
"%s -d -c 2" % iostat_bin,
cache_timeout=agent_util.DEFAULT_CACHE_TIMEOUT,
)
if 0 != ret:
raise Exception("iostat failure, error {}".format(ret))
metricsCount = len(self.darwinMetricsMap)
lines = output.strip().split("\n")
if 4 != len(lines):
self.log.error("Unrecognized iostat output")
self.log.error(output)
raise Exception("Unrecognized iostat output")
devices = lines[0].split()
metrics = lines[1].split()
metric_values = lines[3].split()
devIndex = devices.index(device)
si = devIndex * metricsCount
ei = si + metricsCount
deviceMetrics = metrics[si:ei]
di = deviceMetrics.index(outputKey)
return float(metric_values[si:ei][di])
except Exception:
err = exc_info()[1]
error = str(err)
self.log.error(
"Collection error {}, {}: {}".format(device, textkey, error)
)
return None
else:
second_line = True
cmd_to_run = "%s -dx 1 2 | sed '/^loop/d'" % (iostat_bin)
ret, output = agent_util.execute_command(
cmd_to_run, cache_timeout=agent_util.DEFAULT_CACHE_TIMEOUT
)
if ret != 0:
self.log.error("{} failed with status {}".format(cmd_to_run, ret))
return None
header = output.strip().splitlines()[header_line].split()
splitted_lines = output.strip().split("\n")
full = list(
filter(lambda x: re.match(r"^%s .*$" % (device), x), splitted_lines)
)
if full:
if second_line:
full = full[1]
else:
full = full[0]
else:
self.log.error("Device %s could not be found in output!" % device)
return None
if not header:
self.log.error("Device %s no longer exists!" % device)
return None
for metric in header:
self.log.debug("###########\nMetric: %s" % str(metric))
if metric in self.metrics_list:
metrics_index[str(metric)] = header.index(str(metric))
self.log.debug("#####################################################")
self.log.debug(
"IO stats command '%s -dx %s 1 2' output:" % (iostat_bin, device)
)
self.log.debug(str(full))
self.log.debug("#####################################################")
self.log.debug("iostat -dx output: %s" % str(output))
j = full.strip().split()
if device in j[0]:
return float(j[int(metrics_index[str(textkey.split(".")[-1])])])
return 0
Zerion Mini Shell 1.0