def get_statistics(self):
args = (self.netbox.sysname, self.handler, self.id)
avail_id = metric_path_for_service_availability(*args)
rtime_id = metric_path_for_service_response_time(*args)
result = {
'availability': {
'data_source': avail_id,
},
'response_time': {
'data_source': rtime_id,
},
}
for time_frame in self.TIME_FRAMES:
avg = get_metric_average([avail_id, rtime_id],
start="-1%s" % time_frame)
# Availability
pktloss = avg.get(avail_id, None)
if pktloss is not None:
pktloss = 100 - (pktloss * 100)
result['availability'][time_frame] = pktloss
# Response time
result['response_time'][time_frame] = avg.get(rtime_id, None)
return result
def get_traffic_for(interfaces):
"""Get traffic average for the given interfaces using one request
:param QueryDict interfaces: interfaces to fetch data for
:returns: A dict of {interface: { suffix: value, suffix: value}}
"""
metric_mapping = {} # Store metric_name -> interface
targets = []
traffic = defaultdict(dict)
for interface in interfaces:
metrics = [
m for m in interface.get_port_metrics()
if m['suffix'] in [INOCTETS, OUTOCTETS]
]
for metric in metrics:
target = get_metric_meta(metric['id'])['target']
metric_mapping[target] = interface
targets.append(target)
data = get_metric_average(sorted(targets), start=TRAFFIC_TIMEPERIOD)
for metric, value in iteritems(data):
interface = metric_mapping[metric]
if INOCTETS in metric:
traffic[interface].update({INOCTETS: value})
elif OUTOCTETS:
traffic[interface].update({OUTOCTETS: value})
return traffic
def get_statistics(self):
args = (self.netbox.sysname, self.handler, self.id)
avail_id = metric_path_for_service_availability(*args)
rtime_id = metric_path_for_service_response_time(*args)
result = {
'availability': {
'data_source': avail_id,
},
'response_time': {
'data_source': rtime_id,
},
}
for time_frame in self.TIME_FRAMES:
avg = get_metric_average([avail_id, rtime_id],
start="-1%s" % time_frame)
# Availability
pktloss = avg.get(avail_id, None)
if pktloss is not None:
pktloss = 100 - (pktloss * 100)
result['availability'][time_frame] = pktloss
# Response time
result['response_time'][time_frame] = avg.get(rtime_id, None)
return result
def get_cpu_load(sysname, time_interval):
"""Returns the average 5 minute CPU load of sysname.
Question is, of _which_ CPU? Let's just get the one that has the highest
maximum value.
:param sysname: The sysname of the device whose CPU load we're to get.
:param time_interval: A dict(start=..., end=...) describing the desired
time interval in terms valid to Graphite web.
:returns: A floating number representation of the load between 0 and
100.0 (possibly higher in some multi-CPU settings).
"""
data = None
for path in (
metric_path_for_cpu_load(sysname, '*', interval=5),
metric_path_for_cpu_utilization(sysname, '*')
):
target = 'highestMax(%s,1)' % path
try:
data = get_metric_average(target,
start=time_interval['start'],
end=time_interval['end'],
ignore_unknown=True)
if data:
break
except Exception:
data = None
result = data.values()[0] if data else float('nan')
_logger.debug("get_cpu_load(%r, %r) == %r", sysname, time_interval, result)
return result
def get_data(self):
"""Gets the relevant data for this statistics"""
target = self.data_filter.format(serieslist=self.serieslist, rows=self.rows)
data = get_metric_average(target, start=self.timeframe)
if self.scale:
data = self.upscale(data)
return data
def get_link_load(sysname, ifname, time_interval):
"""Gets the link load of the interface, averaged over a time interval.
:param sysname: The sysname of the device we're measuring from.
:param ifname: An interface name.
:param time_interval: A dict(start=..., end=...) describing the desired
time interval in terms valid to Graphite web.
:returns: An (avg_in_Mbps, avg_out_Mbps) tuple.
"""
in_bps = out_bps = float('nan')
if sysname and ifname:
targets = [metric_path_for_interface(sysname, ifname, counter)
for counter in ('ifInOctets', 'ifOutOctets')]
targets = [get_metric_meta(t)['target'] for t in targets]
try:
data = get_metric_average(targets,
start=time_interval['start'],
end=time_interval['end'])
except GraphiteUnreachableError:
_logger.error("graphite unreachable on load query for %s:%s (%r)",
sysname, ifname, time_interval)
return in_bps, out_bps
for key, value in data.iteritems():
if 'ifInOctets' in key:
in_bps = value / MEGABIT
elif 'ifOutOctets' in key:
out_bps = value / MEGABIT
return in_bps, out_bps
def get_data(self):
targets = self.get_targets()
target = "substr(highestAverage(group(%s), %s),0)" % (
",".join(targets),
self.rows,
)
data = get_metric_average(target, start=self.timeframe)
return data
def get_values(self):
"""
Retrieves actual values from Graphite based on the evaluators target.
"""
start = "-{0}".format(interval_to_graphite(self.period))
averages = get_metric_average(
self.target, start=start, end='now', ignore_unknown=True)
_logger.debug("retrieved %d values from graphite for %r, "
"period %s: %r",
len(averages), self.target, self.period, averages)
self.result = dict((extract_series_name(key), dict(value=value))
for key, value in iteritems(averages))
return self.result
def get_interface_data(interface):
"""Get ifin/outoctets for an interface using a single request"""
in_bps = out_bps = None
targets = [metric_path_for_interface(interface.netbox.sysname,
interface.ifname, counter)
for counter in (INOCTETS, OUTOCTETS)]
targets = [get_metric_meta(t)['target'] for t in targets]
data = get_metric_average(targets, start=TRAFFIC_TIMEPERIOD)
for key, value in iteritems(data):
if 'ifInOctets' in key:
in_bps = value
elif 'ifOutOctets' in key:
out_bps = value
return in_bps, out_bps
def _get_metric_average(targets, time_interval):
try:
data = get_metric_average(targets,
start=time_interval['start'],
end=time_interval['end'])
_logger.debug("graphite returned %s metrics from %s targets",
len(data), len(targets))
return data
except GraphiteUnreachableError as err:
_logger.error(
"graphite unreachable on load query for %s targets "
"(%r): %s", len(targets), time_interval, err)
if isinstance(err.cause, HTTPError):
_logger.debug("error cause: %s", err.cause.read())
return {}
def _fetch_data(interface):
in_bps = out_bps = speed = None
if isinstance(interface, Interface):
speed = interface.speed
targets = [metric_path_for_interface(interface.netbox.sysname,
interface.ifname, counter)
for counter in ('ifInOctets', 'ifOutOctets')]
targets = [get_metric_meta(t)['target'] for t in targets]
data = get_metric_average(targets, start=TRAFFIC_TIMEPERIOD)
for key, value in data.iteritems():
if 'ifInOctets' in key:
in_bps = value
elif 'ifOutOctets' in key:
out_bps = value
return InterfaceLoad(in_bps, out_bps, speed)
def get_traffic_for(interfaces):
"""Get traffic average for the given interfaces using one request
:param QueryDict interfaces: interfaces to fetch data for
:returns: A dict of {interface: { suffix: value, suffix: value}}
"""
metric_mapping = {} # Store metric_name -> interface
metrics = []
traffic = defaultdict(dict)
_logger.debug("preparing to get traffic data for %d interfaces",
len(interfaces))
# assume transform is the same for all octet counters
transform = get_metric_meta("." + INOCTETS)["transform"]
for interface in interfaces:
# what we need
ifc_metrics = _get_traffic_counter_metrics_for(interface)
metrics.extend(ifc_metrics)
# what to look for in the response
transformed = [transform.format(id=m) for m in ifc_metrics]
metric_mapping.update({target: interface for target in transformed})
targets = [transform.format(id=m) for m in _merge_metrics(sorted(metrics))]
_logger.debug(
"getting data for %d targets in chunks of %d",
len(targets),
MAX_TARGETS_PER_REQUEST,
)
data = {}
for request in chunks(targets, MAX_TARGETS_PER_REQUEST):
data.update(get_metric_average(request, start=TRAFFIC_TIMEPERIOD))
_logger.debug("received %d metrics in response", len(data))
for metric, value in data.items():
interface = metric_mapping[metric]
if INOCTETS in metric:
traffic[interface].update({INOCTETS: value})
elif OUTOCTETS in metric:
traffic[interface].update({OUTOCTETS: value})
return traffic
def _fetch_data(interface):
in_bps = out_bps = speed = None
if isinstance(interface, Interface):
speed = interface.speed
targets = [
metric_path_for_interface(interface.netbox.sysname,
interface.ifname, counter)
for counter in ('ifInOctets', 'ifOutOctets')
]
targets = [get_metric_meta(t)['target'] for t in targets]
data = get_metric_average(targets, start=TRAFFIC_TIMEPERIOD)
for key, value in data.iteritems():
if 'ifInOctets' in key:
in_bps = value
elif 'ifOutOctets' in key:
out_bps = value
return InterfaceLoad(in_bps, out_bps, speed)
def get_data(self):
target = self.data_filter.format(serieslist=self.serieslist,
rows=self.rows)
data = get_metric_average(target, start=self.timeframe)
return data
