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_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