def info_metrics(self): """ Return a list of information tags for the PV Supervisor """ network_status = self.communication_interfaces interface_info = InfoMetricFamily( name="sunpower_pvs_communication_interface", documentation="Communications Interface Information", ) for comm in network_status.get("interfaces", []): value = dict(interface=comm["interface"], internet=comm["internet"], sms=comm["sms"], ) interface_info.add_metric(labels=[], value=value) grid_profile = self.grid_profile value = None if grid_profile: value = dict(id=grid_profile["active_id"], name=grid_profile["active_name"], percent=str(grid_profile["percent"]), status=grid_profile["status"], ) grid_info = InfoMetricFamily( name="sunpower_pvs_grid_profile", documentation="Grid Profile", value=value, ) return [dict(key="interface_info", metric=interface_info), dict(key="grid_profile", metric=grid_info) ]
def collect(self): yield InfoMetricFamily('smartmon', 'smartmontools information', get_smartctl_version_info()) dev_info_labels = [ 'device', 'type', 'protocol', 'model_family', 'serial_number', 'wwn', 'firmware_version', ] dev_info_metric = InfoMetricFamily('smartmon_device', 'S.M.A.R.T. device information') metrics = gen_metrics() attr_metrics = gen_attr_metrics() nvme_metrics = gen_nvme_metrics() for dev in get_devices(): get_device_metrics(dev, dev_info_metric, dev_info_labels, metrics, attr_metrics, nvme_metrics) yield dev_info_metric yield from (x[0] for x in metrics) yield from (x[0] for x in attr_metrics.values()) yield from (x[0] for x in nvme_metrics)
def collect(self): # Collect exporter information version = get_version() local_time = time.localtime() formatted_local_time = time.strftime('%Y-%m-%d %H.%M.%S', local_time) try: if local_time[8]: local_tzname = time.tzname[1] else: local_tzname = time.tzname[0] except AttributeError: local_tzname = 'UNKNOWN' # Update Prometheus metrics c = CounterMetricFamily( 'mqa_exporter_current_datetime_seconds', 'The current date and time of the server on which the exporter is running in epoch seconds ', labels=['appliance']) c.add_metric([self.appliance], datetime_to_epoch(formatted_local_time, '%Y-%m-%d %H.%M.%S')) yield c i = InfoMetricFamily('mqa_exporter', 'MQ Appliance exporter information') i.add_metric( ['appliance', 'version', 'localTimezone'], { 'appliance': self.appliance, 'version': version, 'localTimezone': local_tzname }) yield i
def collect(self): info = self.rpc.getinfo() info_labels = { k.replace('-', '_'): v for k, v in info.items() if isinstance(v, str) } node_info_fam = InfoMetricFamily( 'lightning_node', 'Static node information', labels=info_labels.keys(), ) node_info_fam.add_metric(info_labels, info_labels) yield node_info_fam blockheight = info['blockheight'] yield GaugeMetricFamily( 'lightning_node_blockheight', "Current Bitcoin blockheight on this node.", value=blockheight, ) fees_msat = info["msatoshi_fees_collected"] yield GaugeMetricFamily( 'lightning_fees_collected_msat', 'How much have we been paid to route payments?', value=fees_msat, )
def collect(self): """ Collect the metrics. Collect the metrics and yield them. Prometheus client library uses this method to respond to http queries or save them to disk. """ gauge = GaugeMetricFamily('node_net_ethtool', 'Ethtool data', labels=['device', 'type']) basic_info = InfoMetricFamily('node_net_ethtool', 'Ethtool device information', labels=['device']) xcvr_info = InfoMetricFamily('node_net_ethtool_xcvr', 'Ethtool device transceiver information', labels=['device']) sensors = GaugeMetricFamily('node_net_ethtool_xcvr_sensors', 'Ethtool transceiver sensors', labels=['device', 'type']) alarms = GaugeMetricFamily('node_net_ethtool_xcvr_alarms', 'Ethtool transceiver sensor alarms', labels=['device', 'type']) for iface in self.find_physical_interfaces(): self.update_ethtool_stats(iface, gauge) self.update_basic_info(iface, basic_info) self.update_xcvr_info(iface, xcvr_info, sensors, alarms) yield basic_info yield xcvr_info yield sensors yield alarms yield gauge
def collect(self): name = "dfinity" if time.time() - self.time > self.cache_timeout: self.cache = {} self.time = time.time() if name not in self.cache: try: response = requests.get(url=self.url, verify=False, stream=False, timeout=5) except requests.Timeout: pass except requests.ConnectionError: pass self.cache[name] = response.json() metric_counter = CounterMetricFamily( "repo__{}__tags_".format(name), "Repo `{}` tags total".format(name), labels=['tags']) metric_counter.add_metric([name], len(self.cache[name]["versions"])) yield metric_counter metric_info = InfoMetricFamily("repo__{}__tag".format(name), "Repo `{}` tag".format(name)) metric_info.add_metric(["tag"], {'name': self.cache[name]["tags"]["latest"]}) yield metric_info
def info_collector(name, decription, router_records, metric_labels=[]): BaseCollector._add_id_labels(metric_labels) collector = InfoMetricFamily(f'mktxp_{name}', decription) for router_record in router_records: label_values = {label: router_record.get(label) if router_record.get(label) else '' for label in metric_labels} collector.add_metric(metric_labels, label_values) return collector
def test_info_labels(self): cmf = InfoMetricFamily('i', 'help', labels=['a']) cmf.add_metric(['b'], {'c': 'd'}) self.custom_collector(cmf) self.assertEqual( 1, self.registry.get_sample_value('i_info', { 'a': 'b', 'c': 'd' }))
def collect(self): logger.info(f'{self.name} starts with collecting the metrics') for entry in self.custom_metrics: custom_info_metric = InfoMetricFamily(entry['metric'], 'vrops-exporter', labels=['target']) custom_info_metric.add_metric(labels=[self.target], value=entry['values_dict']) yield custom_info_metric
def collect(self): info = self.rpc.getinfo() info_labels = {k: v for k, v in info.items() if isinstance(v, str)} node_info_fam = InfoMetricFamily( 'node', 'Static node information', labels=info_labels.keys(), ) node_info_fam.add_metric(info_labels, info_labels) yield node_info_fam
def collect(self): """ Rundeck system info """ system_info = self.request_data_from('/system/info') api_version = system_info['system']['rundeck']['apiversion'] rundeck_system_info = InfoMetricFamily('rundeck_system', 'Rundeck system info') rundeck_system_info.add_metric( [], {x: str(y) for x, y in system_info['system']['rundeck'].items()}) yield rundeck_system_info """ Rundeck system stats """ for system_stats in self.get_system_stats(system_info): yield system_stats """ Rundeck counters """ if api_version >= self.args.rundeck_api_version < 25: logging.warning( f'Unsupported API version "{self.args.rundeck_api_version}" ' + f'for API request: /api/{self.args.rundeck_api_version}/metrics/metrics. ' + 'Minimum supported version is 25') else: metrics = self.request_data_from('/metrics/metrics') for counters in self.get_counters(metrics): yield counters """ Rundeck projects executions info """ if self.args.rundeck_projects_executions: endpoint = '/projects' if self.args.rundeck_projects_filter: projects = [{ "name": x } for x in self.args.rundeck_projects_filter] else: if self.args.rundeck_projects_executions_cache: projects = self.cached_request_data_from(endpoint) else: projects = self.request_data_from(endpoint) with ThreadPoolExecutor() as threadpool: project_executions = threadpool.map( self.get_project_executions, projects) for executions in project_executions: for execution in executions: if execution is not None: yield execution
def collect(self): """ Date time range within the executions has run """ dt_range = datime_range.DateTimeRange() time_range = dt_range.datetime_range_to_timestamp(self.args.rundeck_executions_time_range) """ Metrics Requests """ metrics = self.request_data_from('/metrics/metrics') system_info = self.request_data_from('/system/info') """ Rundeck system info """ rundeck_system_info = InfoMetricFamily('rundeck_system', 'Rundeck system info') rundeck_system_info.add_metric([], {x: str(y) for x, y in system_info['system']['rundeck'].items()}) yield rundeck_system_info """ Rundeck system stats """ for system_stats in self.get_system_stats(system_info): yield system_stats """ Rundeck counters """ for counters in self.get_counters(metrics): yield counters """ Rundeck projects executions info """ if self.args.rundeck_projects_executions: endpoint = '/projects' if self.args.rundeck_projects_filter: projects = [{"name": x} for x in self.args.rundeck_projects_filter] else: if self.args.rundeck_projects_executions_cache: projects = self.cached_request_data_from(endpoint) else: projects = self.request_data_from(endpoint) with ThreadPoolExecutor() as threadpool: project_executions = threadpool.map(self.get_project_executions, projects, time_range) for executions in project_executions: for execution in executions: if execution is not None: yield(execution)
def test_info_timestamps(self): families = text_string_to_metric_families("""# TYPE a info # HELP a help a_info{a="1",foo="bar"} 1 1 a_info{a="2",foo="bar"} 1 0 # EOF """) imf = InfoMetricFamily("a", "help") imf.add_sample("a_info", {"a": "1", "foo": "bar"}, 1, Timestamp(1, 0)) imf.add_sample("a_info", {"a": "2", "foo": "bar"}, 1, Timestamp(0, 0)) self.assertEqual([imf], list(families))
def get_metric_exporter_info(self): """ Information about the exporter """ m = InfoMetricFamily( 'crypto_exporter', f'Information about {__package__}', labels=['exchange', 'version', 'build'] ) m.add_metric( value={'version': f'{constants.VERSION}', 'build': f'{constants.BUILD}'}, labels=[f'{self.exchange.exchange}'], ) return m
def _process_info(data: Union[Dict, List[Dict]], label: str) -> List[InfoMetricFamily]: i = InfoMetricFamily(f'patroni_{label}', f'{label} info') # to ensure we have an iterable of dicts # the info datasets are different, some are lists of dicts, # some are dict only if not isinstance(data, (list, tuple)): data = [data] for dataset in data: i.add_metric([], {k: str(v) for k, v in dataset.items()}) return [i]
def collect(self, describing=False): if not describing: cli = CoAPAirClient(self.ip) status = cli.get_status() if "name" not in status: return labels = [self.ip, status["name"]] label_names = ["device_hostname", "name"] device_info = InfoMetricFamily('air_purifier_device_info', 'Air Purifier Device Information', labels=label_names) if not describing: device_info.add_metric(labels, { "type": status["type"], "mode": status["mode"], "model": status["modelid"], "software_version": status["swversion"], "wifi_version": status["WifiVersion"], "product_id": status["ProductId"], "device_id": status["DeviceId"], "status_type": status["StatusType"], "connect_type": status["ConnectType"], }) yield device_info def gauge(name, desc, field_name, xfrm=lambda x: x): if not describing and field_name not in status: return None g = GaugeMetricFamily("air_purifier_" + name, "Air Purifiier " + desc, labels=label_names) if not describing: g.add_metric(labels, xfrm(status[field_name])) yield g yield from gauge("runtime", "running time", "runtime", lambda x: x/1000) yield from gauge("on", "powered on", "pwr") def fan_speed_xfrm(om): if om == "s": fan_speed = 0 elif om == "t": fan_speed = 9 else: fan_speed = int(om) return fan_speed yield from gauge("fan_speed", "fan speed setting", "om", fan_speed_xfrm) yield from gauge("pm25", "PM 2.5 level ug/m3","pm25") yield from gauge("iaql", "Indoor Air Quality Index", "iaql") yield from gauge("pre_filter_time_til_clean", "Pre filter hours remaining", "fltsts0") yield from gauge("hepa_filter_time_til_replace", "Pre filter hours remaining", "fltsts1") yield from gauge("carbon_filter_time_til_replace", "Carbon filter hours remaining", "fltsts2")
def get_info_metrics(self, result): metric = InfoMetricFamily( 'dkron_info', 'Dkron job info', labels=["jobname"]) for job in result: name = job['name'] # If there's a null result, we want to export a zero. owner = job.get('owner') owner_email = job.get('owner_email') metric.add_metric([name], {'owner': owner, 'owner_email': owner_email}) # job_status = job['status'] return metric
def __init__(self, metric: Iterable[Metric]): """Computes the feature metadata from a list of collected feature histograms. :param metric: A list of Prometheus metrics returned from FeatureHistogramCollector :type metric: Iterable[Metric] """ self.metric = InfoMetricFamily( name="baseline_metrics", documentation="Metadata about the baseline training metrics", labels=["feature_name", "metric_name", "metric_type"], ) for m in metric: start = m.documentation.find(":") + 1 name = m.documentation[start:].strip() self.metric.add_metric(labels=[name, m.name, m.type], value={})
def generate_infos(self, calling_class, vrops_entity_name, labelnames): if not isinstance(labelnames, list): print("Can't generate Gauges without label list, called from", calling_class) return {} properties_yaml = self.read_collector_config()['properties'] if 'info_metrics' in properties_yaml[calling_class]: infos = dict() for property_pair in properties_yaml[calling_class][ 'info_metrics']: property_suffix = property_pair['metric_suffix'] infos[property_suffix] = { 'info': InfoMetricFamily('vrops_' + vrops_entity_name + '_' + property_suffix.lower(), 'vrops-exporter', labels=labelnames), 'property': property_pair['property'] } return infos if os.environ['DEBUG'] >= '1': print("No Info metric type generated, from", calling_class) return {}
def add_node_metrics(self): self.get_node_data() if self.node_data: labels = ['type'] metric_family = GaugeMetricFamily metric_name = 'storj_node' data = self.node_data documentation = 'Storj node info' keys = ['nodeID','wallet','lastPinged','upToDate','version','allowedVersion','startedAt'] yield from self.dict_to_metric(data, metric_name, documentation, InfoMetricFamily, keys, labels) metric_name = 'storj_total_diskspace' data = self.node_data.get('diskSpace', None) documentation = 'Storj total diskspace metrics' keys = ['used','available','trash'] yield from self.dict_to_metric(data, metric_name, documentation, metric_family, keys, labels) data = self.node_data.get('bandwidth', None) metric_name = 'storj_total_bandwidth' documentation = 'Storj total bandwidth metrics' keys = ['used','available'] yield from self.dict_to_metric(data, metric_name, documentation, metric_family, keys, labels) ## to be deprecated for key in ['nodeID','wallet','lastPinged','upToDate','version','allowedVersion','startedAt']: if key in self.node_data: value = str(self.node_data[key]) metric = InfoMetricFamily('storj_' + key, 'Storj ' + key, value={key : value}) yield metric
def _reset_metrics(self): # create all the metrics objects that we'll fill in elsewhere global metric_objs metric_objs = {'cmd_gather': GaugeMetricFamily('weka_gather_seconds', 'Time spent gathering statistics', labels=["cluster"]), 'wekainfo': InfoMetricFamily('weka', "Information about the Weka cluster"), 'wekauptime': GaugeMetricFamily('weka_uptime', "Weka cluster uptime", labels=["cluster"])} for name, parms in self.CLUSTERSTATS.items(): metric_objs["cluster_stat_" + name] = GaugeMetricFamily(name, parms[0], labels=parms[1]) for name, parms in self.INFOSTATS.items(): metric_objs[name] = GaugeMetricFamily(name, parms[0], labels=parms[1]) metric_objs['weka_protection'] = GaugeMetricFamily('weka_protection', 'Weka Data Protection Status', labels=["cluster", 'numFailures']) metric_objs['weka_rebuild'] = GaugeMetricFamily('weka_rebuild', 'Weka Rebuild Progress', labels=["cluster"]) metric_objs['weka_fs'] = GaugeMetricFamily('weka_fs', 'Filesystem information', labels=['cluster', 'name', 'stat']) metric_objs['weka_stats_gauge'] = GaugeMetricFamily('weka_stats', 'WekaFS statistics. For more info refer to: https://docs.weka.io/usage/statistics/list-of-statistics', labels=['cluster', 'host_name', 'host_role', 'node_id', 'node_role', 'category', 'stat', 'unit']) metric_objs['weka_io_histogram'] = GaugeHistogramMetricFamily("weka_blocksize", "weka blocksize distribution histogram", labels=['cluster', 'host_name', 'host_role', 'node_id', 'node_role', 'category', 'stat', 'unit']) metric_objs['alerts'] = GaugeMetricFamily('weka_alerts', 'Alerts from Weka cluster', labels=['cluster', 'type', 'title', 'host_name', 'host_id', 'node_id', 'drive_id']) metric_objs['drives'] = GaugeMetricFamily('weka_drives', 'Weka cluster drives', labels=['cluster', 'host_name', 'host_id', 'node_id', 'drive_id', 'vendor', 'model', 'serial', 'size', 'status', 'life'])
def generate_infos(self, calling_class, vrops_entity_name, labelnames): if not isinstance(labelnames, list): logger.error( f'Cannot generate Gauges without label list, called from {calling_class}' ) return {} properties_yaml = self.read_collector_config()['properties'] if 'info_metrics' in properties_yaml[calling_class]: infos = dict() for property_pair in properties_yaml[calling_class][ 'info_metrics']: property_suffix = property_pair['metric_suffix'] infos[property_suffix] = { 'info': InfoMetricFamily('vrops_' + vrops_entity_name + '_' + property_suffix.lower(), 'vrops-exporter', labels=labelnames), 'property': property_pair['property'] } return infos logger.info(f'No info metric type generated, from {calling_class}') return {}
def describe(self): if 'Stats' in self.__class__.__name__: statkey_yaml = self.read_collector_config()['statkeys'] for statkey_pair in statkey_yaml[self.__class__.__name__]: statkey_suffix = statkey_pair['metric_suffix'] yield GaugeMetricFamily( 'vrops_' + self.vrops_entity_name + '_' + statkey_suffix.lower(), 'vrops-exporter') if 'Properties' in self.__class__.__name__: properties_yaml = self.read_collector_config()['properties'] if 'number_metrics' in properties_yaml[self.__class__.__name__]: for num in properties_yaml[ self.__class__.__name__]['number_metrics']: yield GaugeMetricFamily( 'vrops_' + self.vrops_entity_name + '_' + num['metric_suffix'].lower(), 'vrops-exporter') if 'enum_metrics' in properties_yaml[self.__class__.__name__]: for enum in properties_yaml[ self.__class__.__name__]['enum_metrics']: yield UnknownMetricFamily( 'vrops_' + self.vrops_entity_name + '_' + enum['metric_suffix'].lower(), 'vrops-exporter') if 'info_metrics' in properties_yaml[self.__class__.__name__]: for info in properties_yaml[ self.__class__.__name__]['info_metrics']: yield InfoMetricFamily( 'vrops_' + self.vrops_entity_name + '_' + info['metric_suffix'].lower(), 'vrops-exporter')
def test_simple_info(self): families = text_string_to_metric_families("""# TYPE a info # HELP a help a_info{foo="bar"} 1 # EOF """) self.assertEqual([InfoMetricFamily("a", "help", {'foo': 'bar'})], list(families))
def create_info_collector(name, info, dicts, labels=[]): labels.append('routerboard_name') if type(dicts) is list: collector = InfoMetricFamily(f'routeros_{name}', info) for d in dicts: labels_values = {} for label in labels: if d.get(label): labels_values[label] = d.get(label) else: labels_values[label] = '' collector.add_metric(labels, labels_values) return collector else: raise Exception( f'{type(dicts)} is not a dictionary or a list of dictionaries.' )
def collect(self): info = self.rpc.getinfo() info_labels = {k: v for k, v in info.items() if isinstance(v, str)} node_info_fam = InfoMetricFamily( 'lightning_node', 'Static node information', labels=info_labels.keys(), ) node_info_fam.add_metric(info_labels, info_labels) yield node_info_fam blockheight = info['blockheight'] yield GaugeMetricFamily( 'lightning_node_blockheight', "Current Bitcoin blockheight on this node.", value=blockheight, )
def collect(self): info = InfoMetricFamily('xxxx', 'xxxxxx') info.add_metric(labels='version', value={ 'version': 'xxxxx', 'loglevel': 'xxx', 'root': 'xxxx', 'workers': 'xxxx', 'ip': 'xxxxx', 'port': 'xxx', 'config_name': 'xxxx', 'mode': 'xx', 'debug': 'xxx', 'node': 'xxx', 'pod': 'xxx', 'pid': str(os.getpid()) }) yield info
def collect(self): headers = { 'Authorization': 'token {}'.format(os.environ.get("TOKEN", "")) } for repo in self.repos: name = repo.replace('/', '_').replace('-', '_') if time.time() - self.time > self.cache_timeout: self.cache = {} self.time = time.time() if name not in self.cache: try: response = requests.get(url=self.url.format(repo), headers=headers, verify=False, stream=False, timeout=5) except requests.Timeout: continue except requests.ConnectionError: continue self.cache[name] = response.json() metric_counter = CounterMetricFamily( "repo__{}__tags_".format(name), "Repo `{}` tags total".format(name), labels=['tags']) metric_counter.add_metric([name], len(self.cache[name])) yield metric_counter metric_info = InfoMetricFamily("repo__{}__tag".format(name), "Repo `{}` tag".format(name)) metric_info.add_metric( ["tag"], { 'name': self.cache[name][0]['name'] if len(self.cache[name]) else 'inf' }) yield metric_info
def collect(self): start = time.time() # Perform REST API call to fetch data data = call_rest_api('/mgmt/status/default/IPMISelEvents', self.ip, self.port, self.session, self.timeout) if data == '': return # Update Prometheus metrics for ise in data['IPMISelEvents']: i = InfoMetricFamily('mqa_ipmi_sel_events', 'MQ Appliance IPMI SEL events information') i.add_metric( [ 'appliance', 'index', 'timestamp', 'recordType', 'sensorType', 'sensorNumber', 'sensorName', 'eventReadingTypeCode', 'eventData', 'eventDirection', 'extra' ], { 'appliance': self.appliance, 'index': str(ise['Index']), 'timestamp': ise['Timestamp'], 'recordType': ise['RecordType'], 'sensorType': ise['SensorType'], 'sensorNumber': ise['SensorNumber'], 'sensorName': ise['SensorName'], 'eventReadingTypeCode': ise['EventReadingTypeCode'], 'eventData': ise['EventData2'], 'eventDirection': ise['EventDirection'], 'extra': ise['Extra'] }) yield i g = GaugeMetricFamily( 'mqa_exporter_ipmi_sel_events_elapsed_time_seconds', 'Exporter eleapsed time to collect ipmi sel events metrics', labels=['appliance']) g.add_metric([self.appliance], time.time() - start) yield g
def array_info(self): """Assemble a simple information metric defining the scraped system.""" data = self.connection.get() yield InfoMetricFamily('purefa', 'FlashArray system information', value={ 'array_name': data['array_name'], 'system_id': data['id'], 'version': data['version'] })
def _info(self): """Assemble a simple information metric defining the scraped system.""" info = self.fb.get_array_info() self.info = InfoMetricFamily('purefb', 'FlashBlade system information', value={ 'array_name': info.name, 'system_id': info.id, 'os': info.os, 'version': info.version })