def start_exporter(config, port, interval): """ run the exporter every <interval> seconds """ REGISTRY.register(NovaCollector(config)) start_http_server(port) while True: generate_latest(REGISTRY) time.sleep(30)
def collect_snmp(config, host, port=161): """Scrape a host and return prometheus text format for it""" 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', {}), 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()) return generate_latest(registry)
def _amqp_loop(self): for method, props, unused_body in self._channel.consume( self._routing_key, exclusive=True, no_ack=True): self._channel.publish("", props.reply_to, prometheus_client.generate_latest(prometheus_client.REGISTRY), pika.BasicProperties(correlation_id=props.correlation_id))
def metrics(): try: content = generate_latest(REGISTRY) return content, 200, {'Content-Type': CONTENT_TYPE_LATEST} except Exception as error: logging.exception("Any exception occured during scraping") abort(Response("Scrape failed: {}".format(error), status=502))
def test_histogram(self): s = Histogram("hh", "A histogram", registry=self.registry) s.observe(0.05) self.assertEqual( b"""# HELP hh A histogram # TYPE hh histogram hh_bucket{le="0.005"} 0.0 hh_bucket{le="0.01"} 0.0 hh_bucket{le="0.025"} 0.0 hh_bucket{le="0.05"} 1.0 hh_bucket{le="0.075"} 1.0 hh_bucket{le="0.1"} 1.0 hh_bucket{le="0.25"} 1.0 hh_bucket{le="0.5"} 1.0 hh_bucket{le="0.75"} 1.0 hh_bucket{le="1.0"} 1.0 hh_bucket{le="2.5"} 1.0 hh_bucket{le="5.0"} 1.0 hh_bucket{le="7.5"} 1.0 hh_bucket{le="10.0"} 1.0 hh_bucket{le="+Inf"} 1.0 hh_count 1.0 hh_sum 0.05 """, generate_latest(self.registry), )
def test_summary(self): s = Summary("ss", "A summary", ["a", "b"], registry=self.registry) s.labels("c", "d").observe(17) self.assertEqual( b'# HELP ss A summary\n# TYPE ss summary\nss_count{a="c",b="d"} 1.0\nss_sum{a="c",b="d"} 17.0\n', generate_latest(self.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']: 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 _get_prometheus_snapshot(self) -> str: # Actually, this will produce all registered metrics, from all Metrics instances, # due to the ``core.REGISTRY`` nature. # Will fix it sometimes later. snapshot = generate_latest(core.REGISTRY).decode() if self._process_collector is not None: snapshot += self._process_collector.text_snapshot() return snapshot
def collect_metrics(): registry = CollectorRegistry() MultiProcessCollector(registry) PlatformCollector(registry) ExternalMetrics(registry) data = generate_latest(registry) return Response(data, mimetype=CONTENT_TYPE_LATEST)
def ExportToDjangoView(request): """Exports /metrics as a Django view. You can use django_prometheus.urls to map /metrics to this view. """ metrics_page = prometheus_client.generate_latest() return HttpResponse( metrics_page, content_type=prometheus_client.CONTENT_TYPE_LATEST)
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 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)
def prometheus_app(environ, start_response): query_str = environ.get('QUERY_STRING', '') params = parse_qs(query_str) reg = registry if 'name[]' in params: reg = reg.restricted_registry(params['name[]']) output = generate_latest(reg) status = str('200 OK') headers = [(str('Content-type'), CONTENT_TYPE_LATEST)] start_response(status, headers) return [output]
def do_GET(self): try: response = generate_latest(REGISTRY) status = 200 except Exception: logger.exception('Fetch failed') response = '' status = 500 self.send_response(status) self.send_header('Content-Type', CONTENT_TYPE_LATEST) self.end_headers() self.wfile.write(response)
def do_GET(self): if self.path == '/': self.send_response(200) self.send_header('Content-type', 'text/html') self.end_headers() self.wfile.write('<html><body><p><a href="/metrics">Metrics</a></p></body></html>') elif self.path == '/metrics': self.send_response(200) self.send_header('Content-Type', 'text/plain; version=0.0.4; charset=utf-8') self.end_headers() self.wfile.write(prometheus_client.generate_latest()) else: self.serve_file(self.path, True)
def ExportToDjangoView(request): """Exports /metrics as a Django view. You can use django_prometheus.urls to map /metrics to this view. """ if 'prometheus_multiproc_dir' in os.environ: registry = prometheus_client.CollectorRegistry() multiprocess.MultiProcessCollector(registry) else: registry = prometheus_client.REGISTRY metrics_page = prometheus_client.generate_latest(registry) return HttpResponse( metrics_page, content_type=prometheus_client.CONTENT_TYPE_LATEST)
def collect_metrics(): from prometheus_client import ( CollectorRegistry, core, generate_latest, multiprocess, ) if 'prometheus_multiproc_dir' in os.environ: registry = CollectorRegistry() multiprocess.MultiProcessCollector(registry) else: registry = core.REGISTRY with try_prometheus_lock(): return generate_latest(registry)
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 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 test_collect(self): # used generate_latest method for easy assert prom_metrics_text = generate_latest(self.marathon_collector) expected_text = '''# HELP marathon_org_eclipse_jetty_servlet_servletcontexthandler_percent_4xx_15m from org.eclipse.jetty.servlet.ServletContextHandler.percent-4xx-15m # TYPE marathon_org_eclipse_jetty_servlet_servletcontexthandler_percent_4xx_15m gauge marathon_org_eclipse_jetty_servlet_servletcontexthandler_percent_4xx_15m 0.01139209265037441 # HELP marathon_service_mesosphere_marathon_state_marathonstore_appdefinition_read_data_size from service.mesosphere.marathon.state.MarathonStore.AppDefinition.read-data-size # TYPE marathon_service_mesosphere_marathon_state_marathonstore_appdefinition_read_data_size summary marathon_service_mesosphere_marathon_state_marathonstore_appdefinition_read_data_size_count 1870979.0 marathon_service_mesosphere_marathon_state_marathonstore_appdefinition_read_data_size_sum 2244691348.289432 marathon_service_mesosphere_marathon_state_marathonstore_appdefinition_read_data_size{quantile="0.98"} 1558.0 marathon_service_mesosphere_marathon_state_marathonstore_appdefinition_read_data_size{quantile="0.99"} 1558.0 marathon_service_mesosphere_marathon_state_marathonstore_appdefinition_read_data_size{quantile="0.75"} 1516.0 marathon_service_mesosphere_marathon_state_marathonstore_appdefinition_read_data_size{quantile="0.95"} 1557.0 marathon_service_mesosphere_marathon_state_marathonstore_appdefinition_read_data_size{quantile="0.5"} 1231.0 marathon_service_mesosphere_marathon_state_marathonstore_appdefinition_read_data_size{quantile="0.999"} 1732.0 # HELP marathon_mesosphere_marathon_state_apprepository_read_request_errors_rate from mesosphere.marathon.state.AppRepository.read-request-errors # TYPE marathon_mesosphere_marathon_state_apprepository_read_request_errors_rate gauge marathon_mesosphere_marathon_state_apprepository_read_request_errors_rate{window="1m"} 7.0 marathon_mesosphere_marathon_state_apprepository_read_request_errors_rate{window="5m"} 3.0 marathon_mesosphere_marathon_state_apprepository_read_request_errors_rate{window="15m"} 15.0 marathon_mesosphere_marathon_state_apprepository_read_request_errors_rate{window="mean"} 7.0 # HELP marathon_mesosphere_marathon_state_apprepository_read_request_errors_count from mesosphere.marathon.state.AppRepository.read-request-errors_count # TYPE marathon_mesosphere_marathon_state_apprepository_read_request_errors_count counter marathon_mesosphere_marathon_state_apprepository_read_request_errors_count 100.0 # HELP marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson_rate from mesosphere.marathon.api.v2.AppTasksResource$$EnhancerByGuice$$bd9fb6d1.indexJson # TYPE marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson_rate gauge marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson_rate{window="1m"} 7.0 marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson_rate{window="5m"} 3.0 marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson_rate{window="15m"} 15.0 marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson_rate{window="mean"} 7.0 # HELP marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson from mesosphere.marathon.api.v2.AppTasksResource$$EnhancerByGuice$$bd9fb6d1.indexJson # TYPE marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson summary marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson_count 1870979.0 marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson_sum 2244691348.289432 marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson{quantile="0.98"} 1558.0 marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson{quantile="0.75"} 1516.0 marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson{quantile="0.99"} 1558.0 marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson{quantile="0.95"} 1557.0 marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson{quantile="0.999"} 1732.0 marathon_mesosphere_marathon_api_v2_apptasksresource__enhancerbyguice__bd9fb6d1_indexjson{quantile="0.5"} 1231.0 # HELP marathon_org_eclipse_jetty_servlet_servletcontexthandler_active_dispatches from org.eclipse.jetty.servlet.ServletContextHandler.active-dispatches # TYPE marathon_org_eclipse_jetty_servlet_servletcontexthandler_active_dispatches counter marathon_org_eclipse_jetty_servlet_servletcontexthandler_active_dispatches 1.0 ''' self.assertEqual(expected_text, prom_metrics_text)
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 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)
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 test_reports_metrics(self): """ ``MetricsResource`` serves the metrics from the provided registry. """ c = Counter('cc', 'A counter', registry=self.registry) c.inc() root = Resource() root.putChild(b'metrics', MetricsResource(registry=self.registry)) server = reactor.listenTCP(0, Site(root)) self.addCleanup(server.stopListening) agent = Agent(reactor) port = server.getHost().port url = "http://localhost:{port}/metrics".format(port=port) d = agent.request(b"GET", url.encode("ascii")) d.addCallback(readBody) d.addCallback(self.assertEqual, generate_latest(self.registry)) return d
def metrics(): resp = make_response(generate_latest()) resp.mimetype = CONTENT_TYPE_LATEST return resp
def requests_count(): res = [] for k,v in graphs.items(): res.append(prometheus_client.generate_latest(v)) return Response(res, mimetype="text/plain")
def metrics_view_func(self): # noinspection PyProtectedMember from prometheus_client import generate_latest return generate_latest()
def push_metrics(data: FieldData): update_fun(data) data = generate_latest(registry) resp = requests.post(service, data=data) resp.raise_for_status()
def list(self): return Response(generate_latest(), mimetype='text')
def test_counter(self): c = Counter('cc', 'A counter', registry=self.registry) c.inc() self.assertEqual(b'# HELP cc A counter\n# TYPE cc counter\ncc 1.0\n', generate_latest(self.registry))
def index(self): return Response(generate_latest(), mimetype='text/plain')
def metrics(): """Expose Prometheus metrics.""" return prometheus_client.generate_latest()
def generate_latest_metrics(): """Generate Latest.""" return generate_latest()
def root(): metrics = generate_latest(registry).decode("utf-8") response = make_response(metrics, 200) response.mimetype = "text/plain" return response
def get_data(): return Response(generate_latest(), mimetype=CONTENT_TYPE_LATEST)
def prom_metrics(environ, start_response): status = "200 OK" headers = [("Content-type", CONTENT_TYPE_LATEST)] start_response(status, headers) return [generate_latest(REGISTRY)]
def expose_metrics(): return Response(generate_latest(), headers=_HEADERS)
def expose_metrics_multiprocess(): registry = CollectorRegistry() multiprocess.MultiProcessCollector(registry) return Response(generate_latest(registry), headers=_HEADERS)
async def metrics(request): return response.raw( prometheus_client.generate_latest(), content_type="text/plain; version=0.0.4; charset=utf-8")
async def metrics(_: Request) -> StreamResponse: resp = web.Response(body=prometheus_client.generate_latest()) resp.content_type = prometheus_client.CONTENT_TYPE_LATEST return resp
def test_gauge(self): g = Gauge('gg', 'A gauge', registry=self.registry) g.set(17) self.assertEqual(b'# HELP gg A gauge\n# TYPE gg gauge\ngg 17.0\n', generate_latest(self.registry))
def get(self): import prometheus_client self.write(prometheus_client.generate_latest()) self.set_header("Content-Type", "text/plain; version=0.0.4")
def get_metrics(self, path, params): """Return metric list in printable form""" return generate_latest(self._reg).decode('utf-8')
def exporter(): """Agent execution function""" # definition tag registry = CollectorRegistry(auto_describe=False) service_status = Gauge("Node_Get_ServiceStatus", SERVICE_STATUS_TITLE, ["NodeIP", "NodePort"], registry=registry) first_block_details = Gauge("Node_Get_FirstBlockNumberDetails", FIRST_BLOCK_DETAILS_TITLE, ["NodeIP", "NodePort", "FirstBlockNumberHash"], registry=registry) chain_info = Gauge("Node_Get_ChainInfo", CHAIN_INFO_TITLE, [ "NodeIP", "NodePort", "ChainName", "Operator", "TokenName", "TokenSymbol", "Version" ], registry=registry) node_peers = Gauge("Node_Get_NodePeers", NODE_PEERS_TITLE, ["NodeIP", "NodePort"], registry=registry) chain_nodes = Gauge("Node_Get_ChainNodes", CHAIN_NODES_TITLE, ["NodeIP", "NodePort"], registry=registry) last_block_number = Gauge("Node_Get_LastBlockNumber", LAST_BLOCK_NUMBER_TITLE, [ "NodeIP", "NodePort", "FirstBlockNumberHash", "NodeID", "NodeAddress" ], registry=registry) check_proposer = Gauge("Node_CheckProposer", CHECK_PROPOSER_TITLE, ["NodeIP", "NodePort"], registry=registry) last_block_details = Gauge( "Node_Get_LastBlockNumberDetails", LAST_BLOCK_DETAILS_TITLE, [ "NodeIP", "NodePort", "LastBlocknumber", "LastBlockProposer", "LastBlockHash", "NodeID", "HostPlatform", "HostName", "ConsensusStatus", "SoftVersion" ], registry=registry) block_height_difference = Gauge( "Node_Get_BlockDifference", BLOCK_HEIGHT_DIFFERENCE_TITLE, ["NodeIP", "NodePort", "CurrentHeight", "PreviousHeight"], registry=registry) dir_total_size = Gauge("Node_Get_DirInfo_TotalFileSize", DIR_TOTAL_SIZE_TITLE, ["NodeIP", "NodePort", "NodeDir", "NodeDisk"], registry=registry) block_interval = Gauge("Node_Get_BlockTimeDifference", BLOCK_INTERVAL_TITLE, ["NodeIP", "NodePort"], registry=registry) last_block_transactions = Gauge("Node_Get_LastBlockNumberTransactions", LAST_BLOCK_TRANSACTIONS_TITLE, ["NodeIP", "NodePort"], registry=registry) last_block_quota_used = Gauge("Node_Get_LastBlockNumberQuotaUsed", LAST_BLOCK_QUOTA_USED_TITLE, ["NodeIP", "NodePort"], registry=registry) chain_quota_price = Gauge("Node_Get_QuotaPrice", CHAIN_QUOTA_PRICE_TITLE, ["NodeIP", "NodePort"], registry=registry) block_quota_limit = Gauge("Node_Get_BlockQuotaLimit", BLOCK_QUOTA_LIMIT_TITLE, ["NodeIP", "NodePort"], registry=registry) # run exporter node_ip = str(NODE.split(':')[0]) node_port = str(NODE.split(':')[1]) check_process = os.popen("ps alx |grep 'cita-chain' |grep -c -v grep") if check_process.read() == '0\n': service_status.labels(NodeIP=node_ip, NodePort=node_port).set(0) return Response(prometheus_client.generate_latest(registry), mimetype="text/plain") service_status.labels(NodeIP=node_ip, NodePort=node_port).set(1) class_result = ExporterFunctions(node_ip, node_port) if ',' in NODE_FILE_PATH: path_list = NODE_FILE_PATH.split(',') for path in path_list: dir_analysis(path) dir_total_size.labels(NodeIP=node_ip, NodePort=node_port, NodeDir=path, NodeDisk=DISK_TOTAL).set(FILE_TOTAL_SIZE) else: path = NODE_FILE_PATH dir_analysis(path) dir_total_size.labels(NodeIP=node_ip, NodePort=node_port, NodeDir=path, NodeDisk=DISK_TOTAL).set(FILE_TOTAL_SIZE) first_block_info = class_result.block_number_detail('0x0') if 'result' in first_block_info: first_block_hash = first_block_info['result']['hash'] first_block_time = first_block_info['result']['header']['timestamp'] first_block_details.labels( NodeIP=node_ip, NodePort=node_port, FirstBlockNumberHash=first_block_hash).set(first_block_time) else: print(first_block_info) metadata_info = class_result.metadata() if 'result' in metadata_info: chain_name = metadata_info['result']['chainName'] operator = metadata_info['result']['operator'] token_name = metadata_info['result']['tokenName'] token_symbol = metadata_info['result']['tokenSymbol'] economical_model = metadata_info['result']['economicalModel'] chain_version = metadata_info['result']['version'] chain_info.labels(NodeIP=node_ip, NodePort=node_port, ChainName=chain_name, Operator=operator, TokenName=token_name, TokenSymbol=token_symbol, Version=chain_version).set(economical_model) consensus_node_list = metadata_info['result']['validators'] consensus_node_count = len(consensus_node_list) chain_nodes.labels(NodeIP=node_ip, NodePort=node_port).set(consensus_node_count) else: print(metadata_info) block_number_info = class_result.block_number() if 'result' in block_number_info: hex_number = block_number_info['result'] previous_hex_number = hex(int(hex_number, 16) - 1) last_block_number.labels(NodeIP=node_ip, NodePort=node_port, FirstBlockNumberHash=first_block_hash, NodeID=NODE_ID, NodeAddress=ADDRESS).set(int(hex_number, 16)) else: print(block_number_info) block_info = class_result.block_number_detail(hex_number) previous_block_info = class_result.block_number_detail(previous_hex_number) if 'result' in block_info and 'result' in previous_block_info: block_head_info = block_info['result']['header'] if block_head_info.get('quotaUsed'): block_quota_used = int(block_head_info['quotaUsed'], 16) else: #Get the previous version of CITA v0.19.1 gasUsed block_head_info.get('gasUsed') block_quota_used = int(block_head_info['gasUsed'], 16) block_hash = block_info['result']['hash'] block_time = int(block_head_info['timestamp']) block_transactions = int( len(block_info['result']['body']['transactions'])) block_proposer = block_head_info['proposer'] previous_block_time = int( previous_block_info['result']['header']['timestamp']) interval = abs(block_time - previous_block_time) if ADDRESS in consensus_node_list: consensus = 1 else: consensus = 0 last_block_details.labels(NodeIP=node_ip, NodePort=node_port, LastBlocknumber=int(hex_number, 16), LastBlockProposer=block_proposer, LastBlockHash=block_hash, NodeID=NODE_ID, HostPlatform=EXPORTER_PLATFORM, HostName=AGENT_NAME, ConsensusStatus=consensus, SoftVersion=SOFT_VERSION).set(block_time) block_height_difference.labels(NodeIP=node_ip, NodePort=node_port, CurrentHeight=int(hex_number, 16), PreviousHeight=int( previous_hex_number, 16)).set(interval) block_interval.labels(NodeIP=node_ip, NodePort=node_port).set(interval) last_block_transactions.labels( NodeIP=node_ip, NodePort=node_port).set(block_transactions) last_block_quota_used.labels(NodeIP=node_ip, NodePort=node_port).set(block_quota_used) if ADDRESS == block_proposer: proposer = 1 else: proposer = 0 check_proposer.labels(NodeIP=node_ip, NodePort=node_port).set(proposer) else: print(block_info) print(previous_block_info) peer_info = class_result.peer_count() if 'result' in peer_info: peers = peer_info['result'] node_peers.labels(NodeIP=node_ip, NodePort=node_port).set(int(peers, 16)) else: print(peer_info) quota_price = class_result.quota_price() if 'result' in quota_price: price = quota_price['result'] chain_quota_price.labels(NodeIP=node_ip, NodePort=node_port).set(int(price, 16)) else: print(quota_price) block_limit = class_result.block_limit() if 'result' in block_limit: limit = block_limit['result'] block_quota_limit.labels(NodeIP=node_ip, NodePort=node_port).set(int(limit, 16)) else: print(block_limit) return Response(prometheus_client.generate_latest(registry), mimetype="text/plain")
def metrics(): license_info = get_license(show_key=False) SYSTEM_INFO.info({ 'install_uuid': settings.INSTALL_UUID, 'insights_analytics': str(settings.INSIGHTS_TRACKING_STATE), 'tower_url_base': settings.TOWER_URL_BASE, 'tower_version': get_awx_version(), 'ansible_version': get_ansible_version(), 'license_type': license_info.get('license_type', 'UNLICENSED'), 'license_expiry': str(license_info.get('time_remaining', 0)), 'pendo_tracking': settings.PENDO_TRACKING_STATE, 'external_logger_enabled': str(settings.LOG_AGGREGATOR_ENABLED), 'external_logger_type': getattr(settings, 'LOG_AGGREGATOR_TYPE', 'None') }) LICENSE_INSTANCE_TOTAL.set(str(license_info.get('available_instances', 0))) LICENSE_INSTANCE_FREE.set(str(license_info.get('free_instances', 0))) current_counts = counts(None) ORG_COUNT.set(current_counts['organization']) USER_COUNT.set(current_counts['user']) TEAM_COUNT.set(current_counts['team']) INV_COUNT.set(current_counts['inventory']) PROJ_COUNT.set(current_counts['project']) JT_COUNT.set(current_counts['job_template']) WFJT_COUNT.set(current_counts['workflow_job_template']) HOST_COUNT.labels(type='all').set(current_counts['host']) HOST_COUNT.labels(type='active').set(current_counts['active_host_count']) SCHEDULE_COUNT.set(current_counts['schedule']) INV_SCRIPT_COUNT.set(current_counts['custom_inventory_script']) CUSTOM_VENVS.set(current_counts['custom_virtualenvs']) USER_SESSIONS.labels(type='all').set(current_counts['active_sessions']) USER_SESSIONS.labels(type='user').set( current_counts['active_user_sessions']) USER_SESSIONS.labels(type='anonymous').set( current_counts['active_anonymous_sessions']) RUNNING_JOBS.set(current_counts['running_jobs']) instance_data = instance_info(None) for uuid in instance_data: INSTANCE_CAPACITY.labels(instance_uuid=uuid).set( instance_data[uuid]['capacity']) INSTANCE_CPU.labels(instance_uuid=uuid).set(instance_data[uuid]['cpu']) INSTANCE_MEMORY.labels(instance_uuid=uuid).set( instance_data[uuid]['memory']) INSTANCE_INFO.labels(instance_uuid=uuid).info({ 'enabled': str(instance_data[uuid]['enabled']), 'last_isolated_check': getattr(instance_data[uuid], 'last_isolated_check', 'None'), 'managed_by_policy': str(instance_data[uuid]['managed_by_policy']), 'version': instance_data[uuid]['version'] }) instance_data = job_instance_counts(None) for node in instance_data: # skipping internal execution node (for system jobs) if node == '': continue types = instance_data[node].get('launch_type', {}) for launch_type, value in types.items(): INSTANCE_LAUNCH_TYPE.labels(node=node, launch_type=launch_type).set(value) statuses = instance_data[node].get('status', {}) for status, value in statuses.items(): INSTANCE_STATUS.labels(node=node, status=status).set(value) return generate_latest()
def metrics(): registry = CollectorRegistry() multiprocess.MultiProcessCollector(registry) data = generate_latest(registry) return Response(data, mimetype=CONTENT_TYPE_LATEST)
def handler(): result = get_health(url) generate_metrics(result) return Response(prometheus_client.generate_latest(reg), mimetype="text/plain")
def test_escaping(self): c = Counter('cc', 'A\ncount\\er', ['a'], registry=self.registry) c.labels('\\x\n"').inc(1) self.assertEqual( b'# HELP cc A\\ncount\\\\er\n# TYPE cc counter\ncc{a="\\\\x\\n\\""} 1.0\n', generate_latest(self.registry))
async def metrics(request): body = prometheus_client.generate_latest() resp = web.Response(body=body) resp.content_type = prometheus_client.CONTENT_TYPE_LATEST return resp
def test_unicode(self): c = Counter('cc', '\u4500', ['l'], registry=self.registry) c.labels('\u4500').inc() self.assertEqual( b'# HELP cc \xe4\x94\x80\n# TYPE cc counter\ncc{l="\xe4\x94\x80"} 1.0\n', generate_latest(self.registry))
def metrics(): bottle.response.content_type = prom.CONTENT_TYPE_LATEST return prom.generate_latest(prom.REGISTRY)
def test_summary(self): s = Summary('ss', 'A summary', ['a', 'b'], registry=self.registry) s.labels('c', 'd').observe(17) self.assertEqual( b'# HELP ss A summary\n# TYPE ss summary\nss_count{a="c",b="d"} 1.0\nss_sum{a="c",b="d"} 17.0\n', generate_latest(self.registry))
async def requests_count(request): try: count = generate_latest(redirect_counter) return text(count.decode()) except Exception as error: return json({'message': error}, status=500)
def get(self): self.set_header('Content-Type', prometheus_client.CONTENT_TYPE_LATEST) self.write(prometheus_client.generate_latest(prometheus_client.REGISTRY))
def get(self): self.write(prometheus_client.generate_latest()) self.set_header("Content-Type", prometheus_client.CONTENT_TYPE_LATEST)
def generate_latest(self): return generate_latest(self.registry)
def Status(): STATUS().filter() return Response(prometheus_client.generate_latest(registry=REGISTRY), mimetype="text/plain")