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