class PrometheusClient: def __init__(self): # # Start up the server to expose the metrics. start_http_server(EXPORT_PORT) self.g = Gauge('sensor_data', 'Value gathered by sensor', ['sensor_id', 'ipe_id', 'category_id', 'unit']) def export_data(self, xml_data=None): root = ET.fromstring(xml_data) ipe_id = root.find('./*[@name="ipeId"]').attrib['val'] app_id = root.find('./*[@name="appId"]').attrib['val'] category = root.find('./*[@name="category"]').attrib['val'] data = int(root.find('./*[@name="data"]').attrib['val']) unit = root.find('./*[@name="unit"]').attrib['val'] # json_body = [ # { # "measurement": "sensor_status", # "tags": { # "sensor_id": app_id, # "ipe_id": ipe_id, # "category": category # }, # "fields": { # "data": data, # "unit": unit # } # } # ] self.g.labels(app_id, ipe_id, category, unit).set(data)
def export_metric(device, id, type, value): global temperature_gauge if (temperature_gauge == None): temperature_gauge = Gauge('temperature', 'Temperatures from MQTT', ['device', 'id', 'type']) global gauges if (not id in gauges): gauges[id] = temperature_gauge.labels(device, id, type) logging.debug('New gauge added. Device: ' + device + ' Id: ' + str(id) + ', type: ' + type) gauges[id].set(value) logging.debug('Gauge temperature set with value: ' + str(value) + ' - Device: ' + device + ' Id: ' + id + ' Type: ' + type)
def inc_counter(self, key, amount=1): """ Increment counter """ prometheus_counter = Gauge( # pylint: disable=no-value-for-parameter key ) prometheus_counter.inc(amount)
def dec_counter(self, key, amount=1): """ Decrement metric """ prometheus_counter = Gauge( # pylint: disable=no-value-for-parameter key ) prometheus_counter.dec(amount)
def get_stats(self): registry = CollectorRegistry() labels = ['region'] label_values = [self.region] duration = Gauge('openstack_exporter_cache_refresh_duration_seconds', 'Cache refresh duration in seconds.', labels, registry=registry) duration.labels(*label_values).set(self.duration) return generate_latest(registry)
def increment(self, stat, by=1): self.stats[stat] += by # Update the associated Prometheus gauge. if stat not in self.prom_gauges: gauge = Gauge(sanitize_name("felix_" + self.name + " " + stat), "%s: %s" % (self.name, stat)) self.prom_gauges[stat] = gauge else: gauge = self.prom_gauges[stat] gauge.inc(by)
class HistogramRoller(RollerBase): """Accepts a Histogram object and creates a guage with multiple labels tracking bucket values over a given time period. """ def __init__(self, histogram, options=None, registry=REGISTRY, roller_registry=ROLLER_REGISTRY): self.hist = histogram if self.hist._type != 'histogram': raise ValueError('Only a Histogram object should be passed to HistogramRoller') options = options or {} self.extract_options(options) # Keys are 'le' values # Holds deques containing values for each gauge self.past_values = dict() full_name = "" for full_name, labels, _ in iter_hist_buckets(self.hist): le_label = labels['le'] self.past_values[le_label] = deque() self.configure_with_full_name(full_name, is_histogram=True) # A single top level gauge with bucket labels tracks the values self.gauge = Gauge( self.name, self.documentation, labelnames=('le',), registry=registry ) roller_registry[self.name] = self def collect(self): """Loop over current histogram bucket values and update gauges. Usage: * Collect should only be called about every second, not in a tight loop. * Should only be called in 1 thread at a time. """ now = datetime.datetime.now() # Fetch values from histograms for _, labels, value in iter_hist_buckets(self.hist): sample_key = labels['le'] # Add value self.past_values[sample_key].append((now, value)) # Drop old values remove_old_values(self.past_values[sample_key], now - self.retention_td) # Calculate and record new rolled value v = self.reducer(values_to_deltas(self.past_values[sample_key]), **self.reducer_kwargs) self.gauge.labels({'le': sample_key}).set(v)
def sendGauge(self,metric, description ,value, job, labels): for g in self.metrics: if g._name == metric and g._type == 'gauge': g.labels(resource_id=self.id,snmp_ip=labels['ip'],snmp_port=labels['port']).set(value) self.push(job=job) return g = Gauge(metric, description , ["resource_id","snmp_ip","snmp_port"], registry=self.registry) g.labels(resource_id=self.id,snmp_ip=labels['ip'],snmp_port=labels['port']).set(value) self.metrics.append(g) self.push(job=job)
class PrometheusMetricsCollector(MetricsCollector): def __init__(self): super(PrometheusMetricsCollector, self).__init__() self.registry = CollectorRegistry() self.task_started_counter = Counter( 'luigi_task_started_total', 'number of started luigi tasks', ['family'], registry=self.registry ) self.task_failed_counter = Counter( 'luigi_task_failed_total', 'number of failed luigi tasks', ['family'], registry=self.registry ) self.task_disabled_counter = Counter( 'luigi_task_disabled_total', 'number of disabled luigi tasks', ['family'], registry=self.registry ) self.task_done_counter = Counter( 'luigi_task_done_total', 'number of done luigi tasks', ['family'], registry=self.registry ) self.task_execution_time = Gauge( 'luigi_task_execution_time_seconds', 'luigi task execution time in seconds', ['family'], registry=self.registry ) def generate_latest(self): return generate_latest(self.registry) def handle_task_started(self, task): self.task_started_counter.labels(family=task.family).inc() self.task_execution_time.labels(family=task.family) def handle_task_failed(self, task): self.task_failed_counter.labels(family=task.family).inc() self.task_execution_time.labels(family=task.family).set(task.updated - task.time_running) def handle_task_disabled(self, task, config): self.task_disabled_counter.labels(family=task.family).inc() self.task_execution_time.labels(family=task.family).set(task.updated - task.time_running) def handle_task_done(self, task): self.task_done_counter.labels(family=task.family).inc() # time_running can be `None` if task was already complete if task.time_running is not None: self.task_execution_time.labels(family=task.family).set(task.updated - task.time_running) def configure_http_handler(self, http_handler): http_handler.set_header('Content-Type', CONTENT_TYPE_LATEST)
def __init__(self, histogram, options=None, registry=REGISTRY, roller_registry=ROLLER_REGISTRY): self.hist = histogram if self.hist._type != 'histogram': raise ValueError('Only a Histogram object should be passed to HistogramRoller') options = options or {} self.extract_options(options) # Keys are 'le' values # Holds deques containing values for each gauge self.past_values = dict() full_name = "" for full_name, labels, _ in iter_hist_buckets(self.hist): le_label = labels['le'] self.past_values[le_label] = deque() self.configure_with_full_name(full_name, is_histogram=True) # A single top level gauge with bucket labels tracks the values self.gauge = Gauge( self.name, self.documentation, labelnames=('le',), registry=registry ) roller_registry[self.name] = self
def __init__(self): super(PrometheusMetricsCollector, self).__init__() self.registry = CollectorRegistry() self.task_started_counter = Counter( 'luigi_task_started_total', 'number of started luigi tasks', ['family'], registry=self.registry ) self.task_failed_counter = Counter( 'luigi_task_failed_total', 'number of failed luigi tasks', ['family'], registry=self.registry ) self.task_disabled_counter = Counter( 'luigi_task_disabled_total', 'number of disabled luigi tasks', ['family'], registry=self.registry ) self.task_done_counter = Counter( 'luigi_task_done_total', 'number of done luigi tasks', ['family'], registry=self.registry ) self.task_execution_time = Gauge( 'luigi_task_execution_time_seconds', 'luigi task execution time in seconds', ['family'], registry=self.registry )
def get_stats(self): registry = CollectorRegistry() labels = ['region', 'host', 'aggregate', 'aggregate_id'] hypervisor_stats_cache = self.get_cache_data() for hypervisor_stat in hypervisor_stats_cache: stat_gauge = Gauge( self.gauge_name_sanitize( hypervisor_stat['stat_name']), 'Openstack Hypervisor statistic', labels, registry=registry) label_values = [self.osclient.region, hypervisor_stat.get('host', ''), hypervisor_stat.get('aggregate', ''), hypervisor_stat.get('aggregate_id', '')] stat_gauge.labels(*label_values).set(hypervisor_stat['stat_value']) return generate_latest(registry)
def get_stats(self): registry = CollectorRegistry() labels = ['region', 'host', 'service', 'state'] services_stats_cache = self.get_cache_data() for services_stat in services_stats_cache: stat_gauge = Gauge( self.gauge_name_sanitize( services_stat['stat_name']), 'Openstack Nova Service statistic', labels, registry=registry) label_values = [self.osclient.region, services_stat.get('host', ''), services_stat.get('service', ''), services_stat.get('state', '')] stat_gauge.labels(*label_values).set(services_stat['stat_value']) return generate_latest(registry)
def update_gauges(metrics): metric_dict = {} for (name_list, label_dict, value) in metrics: metric_name = format_metric_name(name_list) if metric_name not in metric_dict: metric_dict[metric_name] = (tuple(label_dict.keys()), {}) label_keys = metric_dict[metric_name][0] label_values = tuple([ format_label_value(label_dict[key]) for key in label_keys ]) metric_dict[metric_name][1][label_values] = value for metric_name, (label_keys, value_dict) in metric_dict.items(): if metric_name in gauges: (old_label_values_set, gauge) = gauges[metric_name] else: old_label_values_set = set() gauge = Gauge(metric_name, '', label_keys) new_label_values_set = set(value_dict.keys()) for label_values in old_label_values_set - new_label_values_set: gauge.remove(*label_values) for label_values, value in value_dict.items(): if label_values: gauge.labels(*label_values).set(value) else: gauge.set(value) gauges[metric_name] = (new_label_values_set, gauge)
class CounterRoller(RollerBase): """Accepts a Counter object and creates a gauge tracking its value over a given time period. """ def __init__(self, counter, options=None, registry=REGISTRY, roller_registry=ROLLER_REGISTRY): self.counter = counter if self.counter._type != 'counter': raise ValueError('Only a Counter object should be passed to CounterRoller') options = options or {} self.extract_options(options) self.past_values = deque() full_name, _, _ = self.get_sample() self.configure_with_full_name(full_name) self.gauge = Gauge( self.name, self.documentation, registry=registry ) roller_registry[self.name] = self def get_sample(self): """Returns (full_name, labels, value) """ return self.counter.collect()[0].samples[0] def collect(self): """Update tracked counter values and current gauge value """ now = datetime.datetime.now() # Fetch value from counter _, _, value = self.get_sample() # Add value self.past_values.append((now, value)) # Drop old values remove_old_values(self.past_values, now - self.retention_td) # Calculate and record new rolled value v = self.reducer(values_to_deltas(self.past_values), **self.reducer_kwargs) self.gauge.set(v)
def get_stats(self): registry = CollectorRegistry() labels = ['region', 'url', 'service'] check_api_data_cache = self.get_cache_data() for check_api_data in check_api_data_cache: label_values = [ check_api_data['region'], check_api_data['url'], check_api_data['service']] gague_name = self.gauge_name_sanitize( "check_{}_api".format(check_api_data['service'])) check_gauge = Gauge( gague_name, 'Openstack API check. fail = 0, ok = 1 and unknown = 2', labels, registry=registry) check_gauge.labels(*label_values).set(check_api_data['status']) return generate_latest(registry)
class PromClient: # pylint: disable=too-few-public-methods """Prometheus client.""" REQUIRED_LABELS = ['dp_id', 'dp_name'] _reg = REGISTRY def __init__(self, reg=None): if reg is not None: self._reg = reg # TODO: investigate faster alternative (https://bugs.launchpad.net/pbr/+bug/1688405) version = VersionInfo('faucet').semantic_version().release_string() self.faucet_version = PromGauge( # pylint: disable=unexpected-keyword-arg 'faucet_pbr_version', 'Faucet PBR version', ['version'], registry=self._reg) self.faucet_version.labels(version=version).set(1) # pylint: disable=no-member self.server = None self.thread = None def start(self, prom_port, prom_addr, use_test_thread=False): """Start webserver.""" if not self.server: app = make_wsgi_app(self._reg) if use_test_thread: from wsgiref.simple_server import make_server, WSGIRequestHandler import threading class NoLoggingWSGIRequestHandler(WSGIRequestHandler): """Don't log requests.""" def log_message(self, *_args): # pylint: disable=arguments-differ pass self.server = make_server( prom_addr, int(prom_port), app, handler_class=NoLoggingWSGIRequestHandler) self.thread = threading.Thread(target=self.server.serve_forever) self.thread.daemon = True self.thread.start() else: self.server = hub.WSGIServer((prom_addr, int(prom_port)), app) self.thread = hub.spawn(self.server.serve_forever) self.thread.name = 'prometheus'
def register_prometheus_gauges(export_internal_raspberry=False): g = Gauge("sensor_temperature_in_celsius", "Local room temperature around the raspberry pi", ["sensor"]) error_g = Gauge("faulty_sensor_read", "Is 1 if the sensor could not be read.", ["sensor"]) sensors = find_sensors() print "Found sensors:", ", ".join(map(lambda x: str(x), sensors)) for sensor in sensors: g.labels(str(sensor)).set_function(sensor) sensor.set_error_gauge(error_g.labels(str(sensor))) if export_internal_raspberry: g = Gauge("cpu_temperature_in_celsius", "CPU Temperature of the Raspberry Pi") g.set_function(read_raspberry_pi_temperature) return sensors
def collect_snmp(config, host, port=161): """Scrape a host and return prometheus text format for it""" start = time.time() metrics = {} for metric in config['metrics']: metrics[metric['name']] = Metric(metric['name'], 'SNMP OID {0}'.format(metric['oid']), 'untyped') values = walk_oids(host, port, config['walk']) oids = {} for oid, value in values: oids[tuple(oid)] = value for oid, value in oids.items(): for metric in config['metrics']: prefix = oid_to_tuple(metric['oid']) if oid[:len(prefix)] == prefix: value = float(value) indexes = oid[len(prefix):] labels = parse_indexes(indexes, metric.get('indexes', {}), metric.get('lookups', {}), oids) metrics[metric['name']].add_sample(metric['name'], value=value, labels=labels) class Collector(): def collect(self): return metrics.values() registry = CollectorRegistry() registry.register(Collector()) duration = Gauge('snmp_scrape_duration_seconds', 'Time this SNMP scrape took, in seconds', registry=registry) duration.set(time.time() - start) walked = Gauge('snmp_oids_walked', 'Number of oids walked in this scrape', registry=registry) walked.set(len(oids)) return generate_latest(registry)
def __init__(self, reg=None): if reg is not None: self._reg = reg # TODO: investigate faster alternative (https://bugs.launchpad.net/pbr/+bug/1688405) version = VersionInfo('faucet').semantic_version().release_string() self.faucet_version = PromGauge( # pylint: disable=unexpected-keyword-arg 'faucet_pbr_version', 'Faucet PBR version', ['version'], registry=self._reg) self.faucet_version.labels(version=version).set(1) # pylint: disable=no-member self.server = None self.thread = None
def collect_snmp(config, host, port=161): """Scrape a host and return prometheus text format for it""" start = time.time() metrics = {} for metric in config['metrics']: metrics[metric['name']] = Metric(metric['name'], 'SNMP OID {0}'.format(metric['oid']), 'untyped') do_bulkget = 'bulkget' not in config or config['bulkget'] values = walk_oids(host, port, config['walk'], config.get('community', 'public'), do_bulkget) oids = {} for oid, value in values: oids[oid_to_tuple(oid)] = value # Netsnmp doesn't tell us if an error has occured, so # try to spot it by no results. if not oids: raise Exception("No OIDs returned, device not responding?") # Build a tree from the rules based on oid for faster lookup. metric_tree = {} for metric in config['metrics']: prefix = oid_to_tuple(metric['oid']) head = metric_tree for i in prefix: head.setdefault('children', {}) head['children'].setdefault(i, {}) head = head['children'][i] head['entry'] = metric for oid, value in oids.items(): head = metric_tree for i in oid: head = head.get('children', {}).get(i) if not head: break if 'entry' in head: metric = head['entry'] prefix = oid_to_tuple(metric['oid']) value = float(value) indexes = oid[len(prefix):] labels = parse_indexes(indexes, metric.get('indexes', {}), metric.get('lookups', {}), oids) metrics[metric['name']].add_sample(metric['name'], value=value, labels=labels) break class Collector(): def collect(self): return metrics.values() registry = CollectorRegistry() registry.register(Collector()) duration = Gauge('snmp_scrape_duration_seconds', 'Time this SNMP scrape took, in seconds', registry=registry) duration.set(time.time() - start) walked = Gauge('snmp_oids_walked', 'Number of oids walked in this scrape', registry=registry) walked.set(len(oids)) return generate_latest(registry)
class Metric(object): __slots__ = ['_collect', '_base_metric'] def __init__(self, name, description, collect_fn): self._collect = collect_fn self._base_metric = Gauge('nvidia_' + name, description, ['device_index', 'device_name']) def metric_for(self, device_name, device_index, device_handle): m = self._base_metric.labels(device_index=device_index, device_name=device_name) def collect(): try: return self._collect(device_handle) except: return 0 m.set_function(collect) return m
def __init__(self, counter, options=None, registry=REGISTRY, roller_registry=ROLLER_REGISTRY): self.counter = counter if self.counter._type != 'counter': raise ValueError('Only a Counter object should be passed to CounterRoller') options = options or {} self.extract_options(options) self.past_values = deque() full_name, _, _ = self.get_sample() self.configure_with_full_name(full_name) self.gauge = Gauge( self.name, self.documentation, registry=registry ) roller_registry[self.name] = self
def get_prometheus_inventory_metrics(): registry = CollectorRegistry() g = Gauge('zentral_inventory_osx_apps', 'Zentral inventory OSX apps', ['name', 'version_str', 'source'], registry=registry) for r in osx_app_count(): count = r.pop('count') g.labels(**r).set(count) g = Gauge('zentral_inventory_os_versions', 'Zentral inventory OS Versions', ['name', 'major', 'minor', 'patch', 'build', 'source'], registry=registry) for r in os_version_count(): count = r.pop('count') g.labels(**r).set(count) return generate_latest(registry)
def __init__(self, name, desc, labels, value, value_converter, url, query, logger=None): ''' name -- metric name (e.g. node_network_status) desc -- metric description labels -- indexes (tuple of strings) in metric_data taken as labels value -- index in metric_data (dict) taken as value for metric value_converter -- sometime value may came in mixed format like - 5s, 3GB. we need to convert this value to numeric. pass a function reference to this converter, can be lambda as well. url -- elasticsearch url to index or GET query query -- elasticsearch query data for POST request logger -- instance of logging.Logger class ''' self.gauge = Gauge(name, desc, list(labels)) self.name = name self.labels = labels self.value = value self.value_converter = value_converter self.url = url self.query = query self.logger = logger
def push_inventory_metrics(): ppg = settings.get('apps', {}).get('zentral.contrib.inventory', {}).get('prometheus_push_gateway', None) if not ppg: return registry = CollectorRegistry() g = Gauge('zentral_inventory_osx_apps', 'Zentral inventory OSX apps', ['name', 'version_str', 'source'], registry=registry) for r in osx_app_count(): count = r.pop('count') g.labels(r).set(count) g = Gauge('zentral_inventory_os_versions', 'Zentral inventory OS Versions', ['name', 'major', 'minor', 'patch', 'build', 'source'], registry=registry) for r in os_version_count(): count = r.pop('count') g.labels(r).set(count) push_to_gateway(ppg, job='zentral_push_inventory_metrics', registry=registry)
def collect_snmp(config, host, port=161): """Scrape a host and return prometheus text format for it""" start = time.time() metrics = {} for metric in config['metrics']: prom_type = metric['metric_type'] if 'metric_type' in metric else 'gauge' prom_help = metric['metric_help'] if 'metric_help' in metric else 'SNMP OID {0}'.format( metric['oid'] if 'oid' in metric else "NaN" ) metrics[metric['name']] = Metric(metric['name'], prom_help, prom_type) values = walk_oids(host, port, config['walk'], config.get('community', 'public'), config.get('timeout', 5), config.get('retries', 3)) oids = {} for oid, value in values: if oid_to_tuple(oid) in oids: if (((not oids[oid_to_tuple(oid)]) or oids[oid_to_tuple(oid)] == None) and value): oids[oid_to_tuple(oid)] = value else: oids[oid_to_tuple(oid)] = value for oid, value in oids.items(): for metric in config['metrics']: prefix = oid_to_tuple(metric['oid']) if oid[:len(prefix)] == prefix: try: value = float(value) except ValueError as e: print(e) value = 0.0 indexes = oid[len(prefix):] labels = parse_indexes(indexes, metric.get('indexes', {}), metric.get('lookups', {}), oids) metrics[metric['name']].add_sample(metric['name'], value=value, labels=labels) class Collector(): def collect(self): return metrics.values() registry = CollectorRegistry() registry.register(Collector()) duration = Gauge('snmp_scrape_duration_seconds', 'Time this SNMP scrape took, in seconds', registry=registry) duration.set(time.time() - start) walked = Gauge('snmp_oids_walked', 'Number of oids walked in this scrape', registry=registry) walked.set(len(oids)) return generate_latest(registry)
def notify_success(self, source, hostname, filename, stats): registry = CollectorRegistry() s = Summary('backup_size', 'Size of backup file in bytes', registry=registry) s.observe(stats.size) s = Summary('backup_dumptime', 'Time taken to dump and compress/encrypt backup in seconds', registry=registry) s.observe(stats.dumptime) s = Summary('backup_uploadtime', 'Time taken to upload backup in seconds', registry=registry) s.observe(stats.uploadtime) if stats.retained_copies is not None: g = Gauge('backup_retained_copies', 'Number of retained backups found on destination', registry=registry) g.set(stats.retained_copies) g = Gauge('backup_timestamp', 'Time backup completed as seconds-since-the-epoch', registry=registry) g.set_to_current_time() def auth_handler(url, method, timeout, headers, data): return basic_auth_handler(url, method, timeout, headers, data, self.username, self.password) push_to_gateway(self.url, job=source.id, registry=registry, handler=auth_handler) logging.info("Pushed metrics for job '%s' to gateway (%s)" % (source.id, self.url))
from prometheus_client import start_http_server, Gauge from shared.setup_logging import setup_logging from providers.beacon_node import BeaconNode, GENESIS_DATETIME from db.tables import Balance from db.db_helpers import get_db_uri logger = logging.getLogger(__name__) engine = create_engine(get_db_uri(), executemany_mode="batch") START_DATE = "2020-01-01" ALREADY_INDEXED_SLOTS = set() SLOTS_WITH_MISSING_BALANCES = Gauge( "slots_with_missing_balances", "Slots for which balances still need to be indexed and inserted into the database", ) @contextmanager def session_scope(): """Provide a transactional scope around a series of operations.""" session = Session(bind=engine) try: yield session session.commit() except: session.rollback() raise finally: session.close()
def main(): parser = _create_parser() args = parser.parse_args() logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO) registry = core.REGISTRY total_fb_memory = Gauge('gpu_total_fb_memory_mb', 'Total installed frame buffer memory (in ' 'megabytes)', ['device'], registry=registry) free_fb_memory = Gauge('gpu_free_fb_memory_mb', 'Unallocated frame buffer memory (in ' 'megabytes)', ['device'], registry=registry) used_fb_memory = Gauge('gpu_used_fb_memory_mb', 'Allocated frame buffer memory (in megabytes).' ' Note that the diver/GPU will always set ' 'a small amount of memory fore bookkeeping.', ['device'], registry=registry) gpu_utilization = Gauge('gpu_utilization_pct', 'Percent of time over the past sample period ' 'during which one or more kernels was ' 'executing on the GPU.', ['device'], registry=registry) memory_utilization = Gauge('gpu_mem_utilization_pct', 'Percent of time over the past sample ' 'period during which global (device) memory ' 'was being read or written', ['device'], registry=registry) iteration = 0 try: log.debug('Initializing NVML...') nvmlInit() log.info('Started with nVidia driver version = %s', nvmlSystemGetDriverVersion()) device_count = nvmlDeviceGetCount() log.debug('%d devices found.', device_count) if args.port: log.debug('Starting http server on port %d', args.port) start_http_server(args.port) log.info('HTTP server started on port %d', args.port) while True: iteration += 1 log.debug('Current iteration = %d', iteration) for i in range(device_count): log.debug('Analyzing device %d...', i) try: log.debug('Obtaining handle for device %d...', i) handle = nvmlDeviceGetHandleByIndex(i) log.debug('Device handle for %d is %s', i, str(handle)) log.debug('Querying for memory information...') mem_info = nvmlDeviceGetMemoryInfo(handle) log.debug('Memory information = %s', str(mem_info)) total_fb_memory.labels(device=i).set(mem_info.total / 1024) free_fb_memory.labels(device=i).set(mem_info.free / 1024) used_fb_memory.labels(device=i).set(mem_info.used / 1024) log.debug('Obtaining utilization statistics...') utilization = nvmlDeviceGetUtilizationRates(handle) log.debug('Utilization statistics = %s', str(utilization)) gpu_utilization.labels(device=i).set(utilization.gpu / 100.0) memory_utilization.labels(device=i).set(utilization.memory / 100.0) except Exception as e: log.warning(e, exc_info=True) if args.gateway: log.debug('Pushing metrics to gateway at %s...', args.gateway) hostname = platform.node() push_to_gateway(args.gateway, job=hostname, registry=core.REGISTRY) log.debug('Push complete.') time.sleep(args.update_period) except Exception as e: log.error('Exception thrown - %s', e, exc_info=True) finally: nvmlShutdown()
#!/usr/bin/env python3 #coding:utf-8 import prometheus_client from prometheus_client import Counter, Gauge import logging, datetime, logging.config import tools from os import path from flask import Response, Flask import configparser from loguru import logger app = Flask(__name__) web_code = Gauge("web_code", "Web code of value", ["project", "env", "service_name", "host"]) # 数值可大可小 #metrics监控 @app.route("/metrics") def metrics(): #sop project sop_urls = ["http://*****:*****@10.80.82.203:30622/"] for index, url in enumerate(sop_urls): code = tools.get_content(url) web_code.labels("sop", "prod", "eurake" + str(index), url).set(code) logger.info(prometheus_client.generate_latest(web_code)) #ai project ai_urls = { "ai-gpu-prod": "http://47.103.96.111:9081/health_check", "ai-video-prod": "http://47.103.96.111:9083/health_check",
from prometheus_client import Gauge import pandas as pd import datetime from extra_metrics.compliance import ClientCompliance from extra_metrics.logs import logger device_checkin_days = Gauge( 'extra_metrics_devices_by_checkin_days', 'various interesting stats on a per device basis, days since checked, compliance status', [ "days", ]) device_client_modelnumber = Gauge( 'extra_metrics_per_device_modelnum', 'provides a value of the model number per device', ["device_name"]) device_client_compliance = Gauge( 'extra_metrics_per_device_compliance', 'provides a value of the compliance state per device, used for device health graph', ["compliance"]) device_client_version = Gauge('extra_metrics_per_device_client_version', 'number of devices rolled up by client version', ["fw_client_version"]) device_client_platform = Gauge('extra_metrics_per_device_platform', 'number of devices rolled up by platform', ["platform"]) device_client_tracked = Gauge('extra_metrics_per_device_tracked',
# port to listen on PORT = int(os.environ.get('PORT', 3001)) # URL of the GitLab instance, defaults to hosted GitLab URL = str(os.environ.get('URL', 'https://gitlab.com')) # Secret token for the app to authenticate itself TOKEN = str(os.environ.get('TOKEN')) # Login to GitLab gl = gitlab.Gitlab(URL, TOKEN) gl.auth() # Initialize Prometheus instrumentation projects_total = Gauge('gitlab_projects_total', 'Number of projects') builds_total = Gauge('gitlab_builds_total', 'Number of builds', ['project_id', 'project_name']) build_duration_seconds = Summary( 'gitlab_build_duration_seconds', 'Seconds the build took to run', ['project_id', 'project_name', 'stage', 'status', 'ref']) open_issues_total = Gauge('gitlab_open_issues_total', 'Number of open issues', ['project_id', 'project_name']) pipeline_duration_seconds = Summary( 'gitlab_pipeline_duration_seconds', 'Seconds the pipeline took to run', ['project_id', 'project_name', 'status', 'ref']) def get_projects(): try: projects = gl.projects.list(all=True)
def __init__(self, metrics_name, points): self.metrics = Gauge(metrics_name, '...', points)
import logging from datetime import datetime from tabi.core import InternalMessage from kafka.consumer import KafkaConsumer from kafka import KafkaClient from kafka.common import ProduceRequest from kafka.protocol import create_message from prometheus_client import Counter, Gauge, start_http_server raw_bgp_messages = Counter("raw_bgp_messages", "all the BGP messages", ["collector", "peer_as"]) latency = Gauge("latency", "BGP peers latency", ["collector", "peer_as"]) logger = logging.getLogger(__name__) RIPE_SERVERS = ["node{}.kafka.ris.ripe.net".format(i) for i in range(1, 6)] PARTITIONS = { "rrc18": 0, "rrc19": 1, "rrc20": 2, "rrc21": 3, }
def __init__(self, registry: CollectorRegistry) -> None: # # Interop # # libp2p_peers self.libp2p_peers = Gauge("libp2p_peers", "Tracks number of libp2p peers", registry=registry) # noqa: E501 # On slot transition self.beacon_slot = Gauge("beacon_slot", "Latest slot of the beacon chain state", registry=registry) # noqa: E501 # On block transition self.beacon_head_slot = Gauge( "beacon_head_slot", "Slot of the head block of the beacon chain", registry=registry, ) # noqa: E501 self.beacon_head_root = Gauge( "beacon_head_root", "Root of the head block of the beacon chain", registry=registry, ) # noqa: E501 # On epoch transition self.beacon_previous_justified_epoch = Gauge( "beacon_previous_justified_epoch", "Current previously justified epoch", registry=registry, ) # noqa: E501 self.beacon_previous_justified_root = Gauge( "beacon_previous_justified_root", "Current previously justified root", registry=registry, ) # noqa: E501 self.beacon_current_justified_epoch = Gauge( "beacon_current_justified_epoch", "Current justified epoch", registry=registry, ) # noqa: E501 self.beacon_current_justified_root = Gauge( "beacon_current_justified_root", "Current justified root", registry=registry) # noqa: E501 self.beacon_finalized_epoch = Gauge("beacon_finalized_epoch", "Current finalized epoch", registry=registry) # noqa: E501 self.beacon_finalized_root = Gauge("beacon_finalized_root", "Current finalized root", registry=registry) # noqa: E501 # # Other # # Validator self.validator_proposed_blocks = Counter( "validator_proposed_blocks", "counter of proposed blocks", registry=registry) # noqa: E501 self.validator_sent_attestation = Counter( "validator_sent_attestation", "counter of attested", registry=registry) # noqa: E501
from prometheus_client import Gauge, Counter from contextlib import contextmanager active_conns = Gauge("replayserver_active_connections_count", "Count of currently active connections.", ["category"]) served_conns = Counter("replayserver_served_connections_total", "How many connections we served to completion.", ["result"]) running_replays = Gauge("replayserver_running_replays_count", "Count of currently running replays.") finished_replays = Counter("replayserver_finished_replays_total", "Number of replays ran to completion.") saved_replays = Counter("replayserver_saved_replay_files_total", "Total replays successfully saved to disk.") @contextmanager def track(metric): try: metric.inc() yield finally: metric.dec()
from prometheus_client import CollectorRegistry, Gauge, push_to_gateway registry = CollectorRegistry() g = Gauge('mktemp_job_last_success_unixtime', 'Last time a batch job successfully finished', registry=registry) g.set_to_current_time() push_to_gateway('localhost:9091', job='mktemp', registry=registry)
def add_guage(self, latest_weather): for key, value in latest_weather.iteritems(): name = self.to_underscore(key) self.guages["{}".format(key)] = Gauge( "weather_{}".format(name), "Current Weather {}".format(name), ['city'])
from aiohttp import web from prometheus_client import ( REGISTRY, Counter, Gauge, Histogram, generate_latest, ) CLIENT_CONNECTIONS = Gauge( 'hpfeeds_broker_client_connections', 'Number of clients connected to broker', ) CONNECTION_MADE = Counter( 'hpfeeds_broker_connection_made', 'Number of connections established', ) CONNECTION_READY = Counter( 'hpfeeds_broker_connection_ready', 'Number of connections established + authenticated', ['ident'], ) CONNECTION_ERROR = Counter( 'hpfeeds_broker_connection_error', 'Number of connections that experienced a protocol error', ['ident', 'category'], )
import vaping import vaping.plugins from builtins import str from prometheus_client import start_http_server, Summary, Counter, Gauge min_latency = Summary('minimum_latency_milliseconds', 'Minimum latency in milliseconds.', ['host']) # NOQA max_latency = Summary('maximum_latency_milliseconds', 'Maximum latency in milliseconds.', ['host']) # NOQA avg_latency = Summary('average_latency_milliseconds', 'Average latency in milliseconds.', ['host']) # NOQA sent_packets = Counter('number_of_packets_sent', 'Number of pings sent to host.', ['host']) # NOQA packet_loss = Gauge('packet_loss', '% packet loss to host (0-100)', ['host']) # NOQA @vaping.plugin.register('prometheus') class Prometheus(vaping.plugins.EmitBase): def init(self): self.log.debug('init prometheus plugin') port = self.pluginmgr_config.get('port', 9099) start_http_server(port) def emit(self, data): raw_data = data.get('data') self.log.debug("data: " + str(raw_data)) for host_data in raw_data: host_name = host_data.get('host') min_latency.labels(host_name).observe(host_data.get('min')) max_latency.labels(host_name).observe(host_data.get('max'))
from awx.conf.license import get_license from awx.main.utils import (get_awx_version, get_ansible_version) from awx.main.analytics.collectors import ( counts, instance_info, job_instance_counts, job_counts, ) REGISTRY.unregister(PROCESS_COLLECTOR) REGISTRY.unregister(PLATFORM_COLLECTOR) REGISTRY.unregister(GC_COLLECTOR) SYSTEM_INFO = Info('awx_system', 'AWX System Information') ORG_COUNT = Gauge('awx_organizations_total', 'Number of organizations') USER_COUNT = Gauge('awx_users_total', 'Number of users') TEAM_COUNT = Gauge('awx_teams_total', 'Number of teams') INV_COUNT = Gauge('awx_inventories_total', 'Number of inventories') PROJ_COUNT = Gauge('awx_projects_total', 'Number of projects') JT_COUNT = Gauge('awx_job_templates_total', 'Number of job templates') WFJT_COUNT = Gauge('awx_workflow_job_templates_total', 'Number of workflow job templates') HOST_COUNT = Gauge('awx_hosts_total', 'Number of hosts', [ 'type', ]) SCHEDULE_COUNT = Gauge('awx_schedules_total', 'Number of schedules') INV_SCRIPT_COUNT = Gauge('awx_inventory_scripts_total', 'Number of invetory scripts') USER_SESSIONS = Gauge('awx_sessions_total', 'Number of sessions', [ 'type',
from celery import Celery from celery.events.receiver import EventReceiver from celery.utils.objects import FallbackContext import amqp.exceptions import httpx logging.basicConfig(level=logging.INFO) app = Celery("overseer", broker=os.environ["BROKER_URL"]) # Monitoring metrics (these are updated by `Receiver` and `Collector` below) event_processing = Summary("overseer_event_processing", "Summary of event processing duration") queue_length = Gauge("overseer_queue_length", "Number of jobs in the queue.", ["queue"]) workers_count = Gauge("overseer_workers_count", "Number of workers listening to the queue.", ["queue"]) queue_length_worker_ratio = Gauge( "overseer_queue_length_worker_ratio", "Ratio of the number of jobs to the number of workers for each queue.", ["queue"], ) # Setup API client api = httpx.Client( base_url=os.path.join(os.environ["DIRECTOR_URL"], "api/"), headers={ "content-type": "application/json",
import vaping import vaping.plugins min_latency = Summary( "minimum_latency_milliseconds", "Minimum latency in milliseconds.", ["host"] ) # NOQA max_latency = Summary( "maximum_latency_milliseconds", "Maximum latency in milliseconds.", ["host"] ) # NOQA avg_latency = Summary( "average_latency_milliseconds", "Average latency in milliseconds.", ["host"] ) # NOQA sent_packets = Counter( "number_of_packets_sent", "Number of pings sent to host.", ["host"] ) # NOQA packet_loss = Gauge("packet_loss", "% packet loss to host (0-100)", ["host"]) # NOQA @vaping.plugin.register("prometheus") class Prometheus(vaping.plugins.EmitBase): def init(self): self.log.debug("init prometheus plugin") port = self.pluginmgr_config.get("port", 9099) start_http_server(port) def emit(self, data): raw_data = data.get("data") self.log.debug("data: " + str(raw_data)) for host_data in raw_data:
def initialize(self, artifacts): self._req_count = Counter("my_req_count", "Number of incoming request") self._temp = Gauge("my_gauge", "Number of incoming request")
import logging from prometheus_client import Gauge eth_block_number = Gauge('eth_block_number', 'The number of most recent block.') net_peers = Gauge('net_peers', 'The number of peers currently connected to the client.') parity_net_active_peers = Gauge('parity_net_active_peers', 'The number of active peers.') parity_net_connected_peers = Gauge( 'parity_net_connected_peers', 'The number of peers currently connected to the client. Available only for Parity' ) def update_metrics(parity): total_peers, active_peers, connected_peers = parity.parity_net_peers() net_peers.set(total_peers) parity_net_active_peers.set(active_peers) parity_net_connected_peers.set(connected_peers) eth_block_number.set(parity.eth_blockNumber()) logging.info('Metric updated')
class PrometheusGaugeMetrics(object): def __init__(self, metrics_name, points): self.metrics = Gauge(metrics_name, '...', points) def update(self, labels, value): return self.metrics.labels(**labels).set(value)
metric_init = pc.get_current_metric_value(metric_name=metric) for unique_metric in metric_init: PREDICTOR_MODEL_LIST.append( model.MetricPredictor(unique_metric, Configuration.rolling_data_window_size)) # A gauge set for the predicted values GAUGE_DICT = dict() for predictor in PREDICTOR_MODEL_LIST: unique_metric = predictor.metric label_list = list(unique_metric.label_config.keys()) label_list.append("value_type") if unique_metric.metric_name not in GAUGE_DICT: GAUGE_DICT[unique_metric.metric_name] = Gauge( unique_metric.metric_name + "_" + predictor.model_name, predictor.model_description, label_list, ) class MainHandler(tornado.web.RequestHandler): async def get(self): # update metric value on every request and publish the metric for predictor_model in PREDICTOR_MODEL_LIST: # get the current metric value so that it can be compared with the # predicted values current_metric_value = Metric( pc.get_current_metric_value( metric_name=predictor_model.metric.metric_name, label_config=predictor_model.metric.label_config, )[0])
'subscriptionId', 'clientState', 'changeType', 'resource', 'dataType', 'url', 'id', ]) if PROMETHEUS: SUBSCR_COUNT = Counter('kopano_mfr_kopano_total_subscriptions', 'Total number of subscriptions') SUBSCR_EXPIRED = Counter('kopano_mfr_kopano_total_expired_subscriptions', 'Total number of subscriptions which expired') SUBSCR_ACTIVE = Gauge('kopano_mfr_kopano_active_subscriptions', 'Number of active subscriptions', multiprocess_mode='liveall') PROCESSOR_BATCH_HIST = Histogram( 'kopano_mfr_kopano_webhook_batch_size', 'Number of webhook posts processed in one batch') POST_COUNT = Counter('kopano_mfr_kopano_total_webhook_posts', 'Total number of webhook posts') POST_ERRORS = Counter('kopano_mfr_kopano_total_webhook_post_errors', 'Total number of webhook post errors') POST_HIST = Histogram('kopano_mfr_kopano_webhook_post_duration_seconds', 'Duration of webhook post requests in seconds') DANGLING_COUNT = Counter( 'kopano_mfr_kopano_total_broken_subscription_conns', 'Total number of broken subscription connections') QUEUE_SIZE_GAUGE = Gauge('kopano_mfr_kopano_subscription_queue_size', 'Current size of subscriptions processor queue',
PUSHGATEWAY_HTTP_RESPONSES_COUNTER = Counter( "sygnal_pushgateway_status_codes", "HTTP Response Codes given on the Push Gateway API", labelnames=["code"], ) NOTIFY_HANDLE_HISTOGRAM = Histogram( "sygnal_notify_time", "Time taken to handle /notify push gateway request", labelnames=["code"], ) REQUESTS_IN_FLIGHT_GUAGE = Gauge( "sygnal_requests_in_flight", "Number of HTTP requests in flight", labelnames=["resource"], ) class V1NotifyHandler(Resource): def __init__(self, sygnal): super().__init__() self.sygnal = sygnal isLeaf = True def _make_request_id(self): """ Generates a request ID, intended to be unique, for a request so it can be followed through logging.
import json import os import time import urllib.parse import re from prometheus_client import Gauge from tornado import gen from tornado.httpclient import AsyncHTTPClient, HTTPError from tornado.httputil import url_concat from traitlets import Dict, Unicode, Bool, default, List from traitlets.config import LoggingConfigurable GITHUB_RATE_LIMIT = Gauge('binderhub_github_rate_limit_remaining', 'GitHub rate limit remaining') SHA1_PATTERN = re.compile(r'[0-9a-f]{40}') def tokenize_spec(spec): """Tokenize a GitHub-style spec into parts, error if spec invalid.""" spec_parts = spec.split('/', 2) # allow ref to contain "/" if len(spec_parts) != 3: msg = 'Spec is not of the form "user/repo/ref", provided: "{spec}".'.format(spec=spec) if len(spec_parts) == 2 and spec_parts[-1] != 'master': msg += ' Did you mean "{spec}/master"?'.format(spec=spec) raise ValueError(msg) return spec_parts
import requests import os import time from prometheus_client import start_http_server, Gauge, Info TOKEN = os.environ["AQICN_TOKEN"] CITIES = os.environ["CITIES"].lower().split(",") aqi = Gauge('aqi_external', 'AQI from waqi', ['name']) pm25 = Gauge('pm25_external', 'PM25 from waqi', ['name']) temp = Gauge('temp_external', 'Temperature from waqi', ['name']) humidity = Gauge('humidity_external', 'humidity from waqi', ['name']) def exit_with_error(error): sys.exit(error) if __name__ == '__main__': port_number = 8000 def metrics_by_city(city, token): print("Scraping %s" % city) response = requests.get('https://api.waqi.info/feed/%s/?token=%s' % (city, token)) js_data = response.json()["data"] if isinstance(js_data, str): print("Error with %s: %s" % (city, js_data)) return
def gather_data(namespace, run_event): g_cpu_usage = Gauge("cpu_cumulative_usage", "CPU Cumulative Usage", ["service", "instance"]) g_cpu_utilization = Gauge('cpu_utilization', "CPU utilization", ["service", "instance"]) g_memory_usage = Gauge('memory_usage', "Memory Usage", ["servie", "instance"]) g_memory_utilization = Gauge('memory_utilization', "Memory Utilization", ["service", "instance"]) while run_event.is_set(): service_list = alauda_service_list(namespace) for service_inst in service_list: service_name = service_inst.name instance_list = alauda_instance_list(namespace, service_name) for instance in instance_list: end_time = int(time.time()) - 30 start_time = str(end_time - 100) #gather data every 1 minute, ensure we can get at least one metric end_time = str(end_time) data = alauda_get_instance_metrics(namespace, service_name, instance['uuid'], start_time, end_time, "1m") if data: g_cpu_usage.labels(service_name, instance['instance_name']).set(data['points'][0][1]) g_cpu_utilization.labels(service_name, instance['instance_name']).set(data['points'][0][2]) g_memory_usage.labels(service_name, instance['instance_name']).set(data['points'][0][3]) g_memory_utilization.labels(service_name, instance['instance_name']).set(data['points'][0][4]) time.sleep(20)
from prometheus_client import ( CollectorRegistry, Counter, Gauge, Summary, push_to_gateway, ) # A separate registry is used, as the default registry may contain other # metrics such as those from the Process Collector. REGISTRY = CollectorRegistry() JOB_DURATION = Summary('my_batch_job_duration_seconds', 'Duration of my batch job in seconds.', registry=REGISTRY) RESULT = Gauge('my_batch_job_result', 'This is a test', registry=REGISTRY) LAST_SUCCESS = Gauge('my_batch_job_last_success_unixtime', 'Last time my batch job succeeded, in unixtime.', registry=REGISTRY) @JOB_DURATION.time() def main(): if len(sys.argv) < 2: print("Usage: {} <Prometheus Pushgateway:port>".format(sys.argv[0])) return # Simulate some work time.sleep(random.random()) # Update metrics RESULT.set(random.random()) # Update success timestamp
SCMPTooManyHopByHop, SCMPUnspecified, ) from lib.packet.scmp.types import SCMPClass from lib.packet.scmp.util import scmp_type_name from lib.socket import ReliableSocket, SocketMgr, TCPSocketWrapper from lib.tcp.socket import SCIONTCPSocket, SockOpt from lib.thread import thread_safety_net, kill_self from lib.trust_store import TrustStore from lib.types import AddrType, L4Proto, PayloadClass from lib.topology import Topology from lib.util import hex_str, sleep_interval # Exported metrics. PKT_BUF_TOTAL = Gauge("se_pkt_buf_total", "Total packets in input buffer", ["server_id", "isd_as"]) PKT_BUF_BYTES = Gauge("se_pkt_buf_bytes", "Memory usage of input buffer", ["server_id", "isd_as"]) PKTS_DROPPED_TOTAL = Counter("se_packets_dropped_total", "Total packets dropped", ["server_id", "isd_as"]) UNV_SEGS_TOTAL = Gauge("se_unverified_segs_total", "# of unverified segments", ["server_id", "isd_as"]) PENDING_TRC_REQS_TOTAL = Gauge("se_pending_trc_reqs", "# of pending TRC requests", ["server_id", "isd_as"]) PENDING_CERT_REQS_TOTAL = Gauge("se_pending_cert_reqs", "# of pending CERT requests", ["server_id", "isd_as"]) CONNECTED_TO_DISPATCHER = Gauge( "se_connected_to_dispatcher", "Is the element successfully registered with the dispatcher.", ["server_id", "isd_as"])
import re import os from django.conf import settings from django.http.response import HttpResponse from django.views import View from prometheus_client import Gauge from prometheus_client.exposition import generate_latest from grantnav.index import get_index from grantnav.frontend.views import totals_query NUM_ERRORS_LOGGED = Gauge( "total_import_errors_logged", "Total number of errors logged by last import" ) TOTAL_GRANTS = Gauge( "total_grants", "Total number of grants in the system" ) class ServiceMetrics(View): def _num_errors_log(self): errors = 0 log_dir = getattr(settings, "GRANTNAV_LOG_DIR") index = get_index() search_term = re.compile("failure|failed|exception|error", re.IGNORECASE) log_file = os.path.join(log_dir, "load_%s.log" % index)
if len(lines) != 2: return False, 0 if lines[0].find('YES') == -1: return False, 0 d = lines[1].strip().split('=') if len(d) != 2: return False, 0 return True, int(d[1]) if __name__ == '__main__': gf = Gauge('backyard_temperature_f', 'Temperature of backyard in degrees F') gc = Gauge('backyard_temperature_c', 'Temperature of backyard in degrees C') devices = find_devices() start_http_server(8000) while True: for device in devices: valid, raw = read_temp(device) if valid: c = raw / 1000.0 f = celsius_to_fahrenheit(c) #print('{:0.2f} F'.format(f)) #print('{:0.2f} C'.format(c))
121726070319: 'east', 121726070375: 'west', 121727000255: 'south', 121726070274: 'west', 121726070045: 'east', 121726069685: 'south', 121726070431: 'south', 121727000392: 'south', 121726070213: 'south', 121726069957: 'west', 121726069138: 'south', } stream_gauges = { 'p': Gauge('meter_active_power_watts', 'Active Power', ['type', 'phase']), 'q': Gauge('meter_reactive_power_watts', 'Reactive Power', ['type', 'phase']), 's': Gauge('meter_apparent_power_watts', 'Apparent Power', ['type', 'phase']), 'v': Gauge('meter_voltage_volts', 'Voltage', ['type', 'phase']), 'i': Gauge('meter_current_amps', 'Current', ['type', 'phase']), 'f': Gauge('meter_frequency_hertz', 'Frequency', ['type', 'phase']), 'pf': Gauge('meter_power_factor_ratio', 'Power Factor', ['type', 'phase']), } production_gauges = { 'activeCount': Gauge('production_active_count', 'Active Count', ['type']), 'wNow': Gauge('power_now_watts', 'Active Count', ['type']), 'whToday': Gauge('production_today_watthours', 'Total production today', ['type']), 'whLastSevenDays': Gauge('production_7days_watthours', 'Total production last seven days', ['type']), 'whLifetime': Gauge('production_lifetime_watthours', 'Total production lifetime', ['type']), }
import socket import sys import threading import time from collections import namedtuple import urllib.request, urllib.error, urllib.parse from cachetools.func import lru_cache from flask import g, request from prometheus_client import push_to_gateway, REGISTRY, Histogram, Gauge, Counter logger = logging.getLogger(__name__) # DB connections db_pooled_connections_in_use = Gauge("quay_db_pooled_connections_in_use", "number of pooled db connections in use") db_pooled_connections_available = Gauge( "quay_db_pooled_connections_available", "number of pooled db connections available") db_connect_calls = Counter( "quay_db_connect_calls", "number of connect() calls made to db", ) db_close_calls = Counter( "quay_db_close_calls", "number of close() calls made to db", ) request_duration = Histogram( "quay_request_duration_seconds", "seconds taken to process a request",
password = environ["TADO_PASSWORD"] client_secret = environ["TADO_CLIENT_SECRET"] # 3 minutes seems the default tado app value refresh_rate = int(environ.get("TADO_EXPORTER_REFRESH_RATE", 180)) print("Starting tado exporter") start_http_server(8000) print("Connecting to tado API using account " + username) try: tado = Tado(username, password, client_secret) except KeyError: print( "Authentication failed. Check your username, password or client secret." ) exit(1) temp = Gauge('tado_temperature', 'Temperature as read by the sensor', labelnames=['zone_name'], unit='celsius') humi = Gauge('tado_humidity', 'Humidity as read by the sensor', labelnames=['zone_name'], unit='percentage') heat = Gauge('tado_heating', 'Heating power', labelnames=['zone_name'], unit='percentage') print("Exporter ready") while True: try: for zone in tado.get_zones(): temp.labels('zone_' + str(zone['id'])).set( tado.get_state(zone['id'])['sensorDataPoints']