def test_uwsgi_collector(): registry = BaseRegistry() uwsgi_collector = UWSGICollector(namespace="uwsgi_namespace", labels={"env_role": "test"}) registry.register(uwsgi_collector) collectors = {x.name: x for x in registry.collect()} metrics_count = sorted( map( lambda x: x.split(" ")[2], filter(lambda x: x.startswith("# HELP"), [x for x in registry_to_text(registry).split("\n")]))) assert len(metrics_count) == len(set(metrics_count)) assert len(registry_to_text(registry).split("\n")) == 60 assert collectors["uwsgi_namespace:buffer_size_bytes"].get_samples( )[0].value == uwsgi.buffer_size assert collectors["uwsgi_namespace:processes_total"].get_samples( )[0].value == uwsgi.numproc assert collectors["uwsgi_namespace:requests_total"].get_samples( )[0].value == uwsgi.total_requests() for name in [ "requests", "respawn_count", "running_time", "exceptions", "delta_requests" ]: assert collectors["uwsgi_namespace:process:{0}".format( name)].get_samples()[0].value == uwsgi.workers()[0][name] assert uwsgi_collector.metric_name("test") == "uwsgi_namespace:test"
def test_base_metric(storage_cls): storage = storage_cls() registry = BaseRegistry(storage=storage) metric_name = "test_base_metric\x00\\" metric = BaseMetric(metric_name, "test_base_metric doc \u4500", ("label1", "label2"), registry=registry) assert registry.is_registered(metric) assert repr(metric) == "<BaseMetric[test_base_metric\x00\\]: 0 samples>" with pytest.raises(RuntimeError) as exc_info: registry.register(metric) assert str(exc_info.value) == u"Collector {0} already registered.".format(metric.uid) with pytest.raises(RuntimeError) as exc_info: metric.add_to_registry(registry) assert str(exc_info.value) == u"Collector {0} already registered.".format(metric.uid) labels = metric.labels({"label1\\x\n\"": "label1_value\\x\n\"", "label2": "label2_value\\x\n\""}) assert isinstance(labels, MetricValue) labels.inc(1) assert labels.get() == 1 assert metric.text_export_header == "\n".join(["# HELP test_base_metric\x00\\\\ test_base_metric doc \\\\u4500", "# TYPE test_base_metric\x00\\\\ untyped"]) assert labels.export_str.split(" ")[:2] == 'test_base_metric\x00\\\\{label1\\\\x\\n\\"="label1_value\\\\x\\n\\"", label2="label2_value\\\\x\\n\\""} 1.0'.split(" ")[:2] # noqa
def test_uwsgi_storage_metrics(iterations): registry = BaseRegistry() storage = UWSGIStorage(0, namespace="namespace", stats=True) registry.register(storage) for x in xrange(iterations): for k, v in DATA: storage.inc_value(k, v) collectors = {x.name: x for x in registry.collect()} metric = collectors["namespace:memory_size"] assert metric.get_samples()[0].value == storage.get_area_size() metric = collectors["namespace:num_keys"] assert metric.get_samples()[0].value == 20
def test_counter_metric(storage_cls): storage = storage_cls() registry = BaseRegistry(storage=storage) metric_name = "counter_metric_name" metric = Counter(metric_name, "counter_metric_name doc", ("label1", "label2"), registry=registry) with pytest.raises(RuntimeError) as exc_info: metric.inc() assert exc_info.value == "You need to use labels" assert registry.is_registered(metric) assert repr(metric) == u"<Counter[counter_metric_name]: 0 samples>" with pytest.raises(RuntimeError) as exc_info: registry.register(metric) assert str(exc_info.value) == u"Collector {0} already registered.".format(metric.uid) with pytest.raises(RuntimeError) as exc_info: metric.add_to_registry(registry) assert str(exc_info.value) == u"Collector {0} already registered.".format(metric.uid) labels = metric.labels({"label1": "label1_value", "label2": "label2_value"}) assert labels.get() == 0 labels.inc(10) assert labels.get() == 10 assert repr(labels) == str(labels) assert str(labels) == "<CounterValue[counter_metric_name]: ((\"label1\", \"label1_value\"), (\"label2\", \"label2_value\")) -> 10.0>" assert labels.key == (labels.TYPE, metric_name, labels.POSTFIX, (("label1", "label1_value"), ("label2", "label2_value"))) assert metric.text_export_header == "\n".join(["# HELP counter_metric_name counter_metric_name doc", "# TYPE counter_metric_name counter"])
def test_metric_methods(storage_cls): storage = storage_cls() registry = BaseRegistry(storage=storage) metric = Gauge("gauge_metric_name", "gauge_metric_name doc", registry=registry) metric.inc(2) assert metric.value == 2 metric.dec(1) assert metric.value == 1 assert metric.set(10) == 10 assert metric.get() == 10 with metric.time(): time.sleep(10) assert metric.value > 10 assert metric.set_to_current_time() == metric.value metric = Counter("counter_metric_name", "counter_metric_name doc", registry=registry) metric.inc(11) assert metric.value == 11 assert metric.get() == 11 metric = Summary("summary_metric_name", "summary_metric_name doc", registry=registry) for x in range(3): with metric.time(): time.sleep(1) assert metric.value["sum"].value > 3 assert metric.value["count"].value == 3 metric = Histogram("histogram_metric_name", "histogram_metric_name doc", registry=registry) for x in range(3): with metric.time(): time.sleep(1) assert metric.value["sum"].value > 3 assert metric.value["count"].value == 3
def unregisterMetrics(self): self.registry = BaseRegistry(storage=LocalMemoryStorage()) self.status["running"][1].add_to_registry(self.registry) self.status["locked"][1].add_to_registry(self.registry) self.status["lastStatus"][1].add_to_registry(self.registry) self.status["timeRunning"][1].add_to_registry(self.registry) self.setProccessState(locked=self.proccessIsLocked()) self.setProccessState(lastStatus=self.getLastStatus()) for metricKey in list(self.metrics): for collectorKey in list(self.metrics[metricKey]): self.metrics[metricKey][collectorKey].add_to_registry( self.registry) if isinstance(self.metrics[metricKey][collectorKey], Gauge): self.metrics[metricKey][collectorKey].set(0)
def __init__(self, config): self.config = config self.metrics = {"Gauge": {}, "Counter": {}} self.registry = BaseRegistry(storage=LocalMemoryStorage()) self.status = { "running": [ 0, Gauge( "process_is_running", "Process (running/not running) status.If 0 not running, if 1 running", registry=self.registry) ], "timeRunning": [ 0, Gauge("time_the_process_is_running", "time the process is running in ms", registry=self.registry) ], "locked": [ 0, Gauge( "process_is_locked", "Process (locked/unlocked) status.If 0 not locked, if 1 locked", registry=self.registry) ], "lastStatus": [ 0, Gauge( "process_last_exec_with_error", "If 0 Last execution was successful, if 1 Last exection terminate wiht Error", registry=self.registry) ] } self.lastCapture = datetime.now() self.HEADERS = { "Accept": "application/json", "Authorization": "Bearer {}".format(self.config["token"]) } logging.getLogger(__name__)
def test_gauge_metric(): storage = LocalMemoryStorage() registry = BaseRegistry(storage=storage) metric_name = "gauge_metric_name" metric = Gauge(metric_name, metric_name + " doc", ("label1", "label2"), registry=registry) assert registry.is_registered(metric) with pytest.raises(RuntimeError) as exc_info: metric.inc(10) assert exc_info.value == "You need to use labels" assert repr(metric) == "<Gauge[gauge_metric_name]: 0 samples>" with pytest.raises(RuntimeError) as exc_info: registry.register(metric) assert str(exc_info.value) == u"Collector {0} already registered.".format(metric.uid) with pytest.raises(RuntimeError) as exc_info: metric.add_to_registry(registry) assert str(exc_info.value) == u"Collector {0} already registered.".format(metric.uid) labels = metric.labels({"label1": "label1_value", "label2": "label2_value"}) assert labels.get() == 0 labels.inc(10) assert labels.get() == 10 assert repr(labels) == str(labels) assert str(labels) == "<GaugeValue[gauge_metric_name]: ((\"label1\", \"label1_value\"), (\"label2\", \"label2_value\")) -> 10.0>" assert labels.key == (labels.TYPE, metric_name, labels.POSTFIX, (("label1", "label1_value"), ("label2", "label2_value"))) assert metric.text_export_header == "\n".join(["# HELP gauge_metric_name gauge_metric_name doc", "# TYPE gauge_metric_name gauge"]) with metric.labels({"label1": "1", "label2": "1"}).time(): time.sleep(1) assert metric.labels(label1="1", label2="1").value > 1 labels = metric.labels({"label1": "inprogress", "label2": "inprogress"}) with labels.track_in_progress(): assert labels.value == 1 assert labels.value == 0 assert labels.set_to_current_time() == labels.value labels = metric.labels({"label1": "time2", "label2": "time2"}) @labels.time() def f(*args, **kwargs): time.sleep(1) f() assert labels.value > 1
def test_histogram(storage_cls): storage = storage_cls() registry = BaseRegistry(storage=storage) metric_name = "histogram_metric_name" metric = Histogram(metric_name, "histogram_metric_name doc", ("label1", "label2"), registry=registry) with pytest.raises(RuntimeError) as exc_info: metric.observe(10) assert exc_info.value == "You need to use labels" assert repr(metric) == u"<Histogram[histogram_metric_name]: 0 samples>" with pytest.raises(RuntimeError) as exc_info: registry.register(metric) assert str(exc_info.value) == u"Collector {0} already registered.".format(metric.uid) with pytest.raises(RuntimeError) as exc_info: metric.add_to_registry(registry) assert str(exc_info.value) == u"Collector {0} already registered.".format(metric.uid) labels = metric.labels({"label1": "label1_value", "label2": "label2_value"}) labels.observe(2.4) value = labels.value assert value["sum"].value == 2.4 assert value["count"].value == 1 assert str(value["sum"]) == "<HistogramSumValue[histogram_metric_name]: ((\"label1\", \"label1_value\"), (\"label2\", \"label2_value\")) -> 2.4>" assert str(value["count"]) == "<HistogramCountValue[histogram_metric_name]: ((\"label1\", \"label1_value\"), (\"label2\", \"label2_value\")) -> 1.0>" labels.observe(0.06) assert str(value["sum"]) == "<HistogramSumValue[histogram_metric_name]: ((\"label1\", \"label1_value\"), (\"label2\", \"label2_value\")) -> 2.46>" assert str(value["count"]) == "<HistogramCountValue[histogram_metric_name]: ((\"label1\", \"label1_value\"), (\"label2\", \"label2_value\")) -> 2.0>" buckets = {x.bucket_threshold: x for x in value["buckets"]} assert buckets[0.025].value == 0 assert buckets[0.075].value == 1 assert buckets[2.5].value == 2 assert buckets[float("inf")].value == 2 assert value["sum"].key == (value["sum"].TYPE, "histogram_metric_name", value["sum"].POSTFIX, (("label1", "label1_value"), ("label2", "label2_value"))) assert value["count"].key == (value["count"].TYPE, "histogram_metric_name", value["count"].POSTFIX, (("label1", "label1_value"), ("label2", "label2_value"))) assert metric.text_export_header == "\n".join(["# HELP histogram_metric_name histogram_metric_name doc", "# TYPE histogram_metric_name histogram"]) for x in range(3): with metric.labels({"label1": "1", "label2": "1"}).time(): time.sleep(1) value = metric.labels(label1="1", label2="1").value assert value["sum"].value > 3 assert value["count"].value == 3 labels = metric.labels({"label1": "time2", "label2": "time2"}) @labels.time() def f(*args, **kwargs): time.sleep(1) for x in range(3): f() value = labels.value assert value["sum"].value > 3 assert value["count"].value == 3
def test_summary(storage_cls): storage = storage_cls() registry = BaseRegistry(storage=storage) metric_name = "summary_metric_name" metric = Summary(metric_name, "summary_metric_name doc", ("label1", "label2"), registry=registry) assert registry.is_registered(metric) with pytest.raises(RuntimeError) as exc_info: metric.observe(10) assert exc_info.value == "You need to use labels" assert repr(metric) == u"<Summary[summary_metric_name]: 0 samples>" with pytest.raises(RuntimeError) as exc_info: registry.register(metric) assert str(exc_info.value) == u"Collector {0} already registered.".format(metric.uid) with pytest.raises(RuntimeError) as exc_info: metric.add_to_registry(registry) assert str(exc_info.value) == u"Collector {0} already registered.".format(metric.uid) labels = metric.labels({"label1": "label1_value", "label2": "label2_value"}) labels.observe(10) value = labels.value assert value["sum"].value == 10 assert value["count"].value == 1 labels.observe(14) assert value["sum"].value == 24 assert value["count"].value == 2 assert value["quantiles"] == [] assert str(value["sum"]) == "<SummarySumValue[summary_metric_name]: ((\"label1\", \"label1_value\"), (\"label2\", \"label2_value\")) -> 24.0>" assert str(value["count"]) == "<SummaryCountValue[summary_metric_name]: ((\"label1\", \"label1_value\"), (\"label2\", \"label2_value\")) -> 2.0>" assert value["sum"].key == (value["sum"].TYPE, "summary_metric_name", value["sum"].POSTFIX, (("label1", "label1_value"), ("label2", "label2_value"))) assert value["count"].key == (value["count"].TYPE, "summary_metric_name", value["count"].POSTFIX, (("label1", "label1_value"), ("label2", "label2_value"))) assert metric.text_export_header == "\n".join(["# HELP summary_metric_name summary_metric_name doc", "# TYPE summary_metric_name summary"]) for x in range(3): with metric.labels({"label1": "1", "label2": "1"}).time(): time.sleep(1) value = metric.labels(label1="1", label2="1").value assert value["sum"].value > 3 assert value["count"].value == 3 labels = metric.labels({"label1": "time2", "label2": "time2"}) @labels.time() def f(*args, **kwargs): time.sleep(1) for x in range(3): f() value = labels.value assert value["sum"].value > 3 assert value["count"].value == 3
#!/usr/bin/env python # -*- coding: utf-8 -*- from pyprometheus.registry import BaseRegistry registry = BaseRegistry() total_requests = registry.gauge("app:total_requests", "Documentation string", ["env_name"]).add_to_registry(register) total_request.labels(env_name="test").inc() response_time = registry.Histogram('name', 'Doc', ['label1'], buckets=(.005, .01, .025, .05, .075, .1, .25, .5, .75, 1.0, 2.5, 5.0, 7.5, 10.0, float('inf')))
#!/usr/bin/env python # -*- coding: utf-8 -*- import os from flask import request, Response, Flask from string import ascii_letters from random import choice from pyprometheus.contrib.uwsgi_features import UWSGIStorage, UWSGICollector from pyprometheus.registry import BaseRegistry from pyprometheus.utils.exposition import registry_to_text from pyprometheus.metrics import BaseMetric, Gauge, Counter, Histogram, Summary storage = UWSGIStorage(0) registry = BaseRegistry(storage=storage) requests_total = Counter("app:requests_total", "Total count of requests", ["method", "url_rule", "rnd"], registry=registry) request_time_histogram = Histogram("app:request_time_histogram", "Request time", ["method", "url_rule", "rnd"], registry=registry) request_time_summary = Histogram("app:request_time_summary", "Request time", ["method", "url_rule", "rnd"], registry=registry) requests_in_progress = Gauge("app:requests_in_progress", "Current requests in progress", ["method", "url_rule", "rnd"], registry=registry)
def test_base_registry(storage_cls, measure_time): storage = storage_cls() registry = BaseRegistry(storage=storage) assert registry.storage == storage name_template = "metric_{0}_name" doc_template = "doc_{0}" metrics = {} labels = ("label1", "label2") labelnames = ("value1", "value2") for metric_class in [BaseMetric, Counter, Gauge, Summary]: metrics[metric_class.TYPE] = metric_class( name_template.format(metric_class.TYPE), doc_template.format(metric_class.TYPE), labels, registry=registry) metrics[Histogram.TYPE] = Histogram(name_template.format(Histogram.TYPE), doc_template.format(Histogram.TYPE), labels, buckets=(0.005, 0.01, 7.5, float("inf")), registry=registry) for k, v in metrics.items(): assert registry.is_registered(v) registry.unregister(v) assert not registry.is_registered(v) for k, v in metrics.items(): assert not registry.is_registered(v) registry.register(v) assert registry.is_registered(v) assert len(registry) == 5 assert len(registry.collectors()) == 5 labels_dict = dict(zip(labels, labelnames)) metrics["gauge"].labels(**labels_dict).inc(5) metrics["counter"].labels(**labels_dict).inc(7) metrics["summary"].labels(**labels_dict).observe(4) metrics["histogram"].labels(**labels_dict).observe(6) labelnames2 = ("value3", "value4") labels_dict2 = dict(zip(labels, labelnames2)) metrics["gauge"].labels(**labels_dict2).inc(5) metrics["counter"].labels(**labels_dict2).inc(7) metrics["summary"].labels(**labels_dict2).observe(4) metrics["histogram"].labels(**labels_dict2).observe(6) assert len(list(registry.get_samples())) == 5 write_to_textfile(registry, "/tmp/metrics.prom") lines = [] with open("/tmp/metrics.prom") as f: for x in f: if x: lines.append(x.strip()) with measure_time("registry to text"): for test1, test2 in zip( registry_to_text(registry).split("\n")[4:], lines[4:]): if test1.startswith("#"): assert test1 == test2 else: assert test1.split()[:-1] == test2.split()[:-1] metrics_count = map( lambda x: x.split(" ")[2], filter(lambda x: x.startswith("# HELP"), [x for x in registry_to_text(registry).split("\n")])) assert len(metrics_count) == len(set(metrics_count))