def __init__(self):
self.registry = prometheus_client.CollectorRegistry()
self._video_processed = prometheus_client.Counter(
"video_precessed",
"Video processed count",
labelnames=(),
namespace="youtube",
subsystem="video",
unit="",
registry=self.registry,
labelvalues=None,
)
self._emails_found = prometheus_client.Counter(
"emails_found",
"Emails found",
labelnames=(),
namespace="youtube",
subsystem="video",
unit="",
registry=self.registry,
labelvalues=None,
)
self._unique_emails_found = prometheus_client.Counter(
"unique_emails_found",
"Unique emails found",
labelnames=(),
namespace="youtube",
subsystem="video",
unit="",
registry=self.registry,
labelvalues=None,
)
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)
expected_username = getattr(settings, "DJANGO_PROMETHEUS_AUTHORIZATION_USERNAME", None)
expected_password = getattr(settings, "DJANGO_PROMETHEUS_AUTHORIZATION_PASSWORD", None)
if expected_password is not None and expected_username is not None:
auth_header = request.META.get("HTTP_AUTHORIZATION", "")
token_type, _, credentials = auth_header.partition(" ")
if credentials == '':
return HttpResponse("", status=400)
received_auth_string = base64.b64decode(credentials).decode()
if ':' not in received_auth_string:
return HttpResponse("", status=400)
received_username = received_auth_string.split(':')[0]
received_password = received_auth_string.split(':')[1]
valid_username = received_username == expected_username
valid_password = received_password == expected_password
if token_type != 'Basic' or not valid_username or not valid_password:
return HttpResponse("", status=401)
return HttpResponse(
metrics_page, content_type=prometheus_client.CONTENT_TYPE_LATEST
)
def run(self):
with ExitStack() as es:
self.stopped.clear()
es.callback(self.stopped.set)
self.logger.info("connecting consumer to rabbitmq server at %s:%d as %s.",
self.connection_parameters.host,
self.connection_parameters.port,
self.connection_parameters.credentials.username,
)
self.connection = es.enter_context(pika.BlockingConnection(self.connection_parameters))
self.channel = es.enter_context(self.connection.channel())
self.connected.set()
self.logger.info("setting up queues and exchanges.")
declare_exchange_with_queue(self.channel, self.src_queue)
declare_exchange_with_queue(self.channel, self.dst_exchange_beehive)
self.channel.exchange_declare(self.dst_exchange_node, exchange_type="topic", durable=True)
# register and run fresh set of metrics and metrics server
self.logger.info("starting metric server on %s:%d.", self.metrics_host, self.metrics_port)
registry = prometheus_client.CollectorRegistry()
self.messages_total = Counter("wes_data_service_messages_total", "Total number of messages handled.", registry=registry)
self.messages_rejected_total = Counter("wes_data_service_messages_rejected_total", "Total number of invalid messages.", registry=registry)
self.messages_published_node_total = Counter("wes_data_service_messages_published_node_total", "Total number of messages published to node.", registry=registry)
self.messages_published_beehive_total = Counter("wes_data_service_messages_published_beehive_total", "Total number of messages published to beehive.", registry=registry)
metrics_server = MetricServer(self.metrics_host, self.metrics_port, registry)
threading.Thread(target=metrics_server.run, daemon=True).start()
es.callback(metrics_server.shutdown)
self.logger.info("starting consumer on %s.", self.src_queue)
self.channel.basic_consume(self.src_queue, self.on_message_callback, auto_ack=False)
self.channel.start_consuming()
def app_context(request_settings, init_db=True, clean_db=True, drop_db=False):
try:
os.environ.pop("FLASK_APP_CONFIG_FILE", None)
conn_param = lm_db.db_connection_params(request_settings)
if init_db:
lm_db.create_db(conn_params=conn_param)
logger.debug("DB created (conn params=%r)", conn_param)
flask_app = create_app(env="testing",
settings=request_settings,
init_app=False)
flask_app.before_request(process_auto_login)
with flask_app.app_context() as ctx:
logger.info("Starting application")
initialize_app(flask_app,
ctx,
prom_registry=prometheus_client.CollectorRegistry())
if init_db:
logger.debug("Initializing DB...")
lm_db.db.create_all()
logger.debug("DB initialized!")
yield ctx
# clean the database and
# close all sessions and connections
with flask_app.app_context() as ctx:
if clean_db:
# _clean_db()
logger.debug("DB cleanup")
if drop_db:
lm_db.db.close_all_sessions()
lm_db.db.engine.pool.dispose()
lm_db.drop_db(conn_param)
logger.debug("DB deleted (connection params=%r)", conn_param)
except Exception as e:
logger.exception(e)
raise RuntimeError(e)
def app():
""" create a test app with various endpoints for the test scenarios """
app = web.Application()
routes = web.RouteTableDef()
registry = prometheus_client.CollectorRegistry()
app.middlewares.append(prometheus_middleware_factory(registry=registry))
app.router.add_get("/metrics", metrics(registry=registry))
@routes.get("/200")
async def response_200(_):
return json_response({"message": "Hello World"})
@routes.get("/exception")
async def response_exception(_):
raise ValueError("Error")
@routes.get("/path/{value}")
async def response_detail(request):
return json_response({"message": f"Hello {request.match_info['value']}"})
app.router.add_routes(routes)
#
# @app.route("/500")
# async def error(request):
# raise HTTPException(status_code=500, detail="this is a test error")
#
# @app.route("/unhandled")
# async def unhandled(request):
# test_dict = {"yup": 123}
# return JSONResponse({"message": test_dict["value_error"]})
yield app
def worker_init(**kwargs):
servicer.init(WorkerParams.service_name, ThreadContextHolder())
if WorkerParams.prometheus_port is not None:
registry = prometheus_client.CollectorRegistry()
prometheus_client.multiprocess.MultiProcessCollector(registry)
prometheus_client.start_http_server(WorkerParams.prometheus_port,
registry=registry)
def test_record_call_latency_async(self):
definitions = [
MetricDefinition('Histogram', 'histo', 'An histogram',
['foo', 'bar'])
]
prometheus_metrics = PrometheusMetrics(
definitions=definitions,
registry=prometheus_client.CollectorRegistry())
label_call_args = []
def get_labels(*args, **kwargs):
label_call_args.append((args, kwargs))
return {'foo': 'FOO', 'bar': 'BAR'}
@prometheus_metrics.record_call_latency('histo', get_labels=get_labels)
@inlineCallbacks
def func(param1, param2=None):
yield
returnValue(param1)
obj = object()
result = yield func(obj, param2='baz')
self.assertIs(result, obj)
# the get_labels function is called with the same args as the function
self.assertEqual(label_call_args, [((obj, ), {'param2': 'baz'})])
self.assertIn('histo_count{bar="BAR",foo="FOO"} 1.0',
prometheus_metrics.generate_latest().decode('ascii'))
def test_metrics(self):
prometheus_metrics = create_metrics(
self.metrics_definitions,
registry=prometheus_client.CollectorRegistry())
self.assertIsInstance(prometheus_metrics, PrometheusMetrics)
self.assertCountEqual(prometheus_metrics.available_metrics,
['sample_counter', 'sample_histogram'])
def _write_response(self, writer):
registry = prometheus_client.CollectorRegistry()
status_gauge = prometheus_client.Gauge(
"ldapsync_up",
"Connectivity to LDAP server",
registry=registry,
)
try:
ctr = self.read_counter()
except Exception as exc:
status_gauge.set(0)
else:
status_gauge.set(1)
delay_gauge = prometheus_client.Gauge(
"ldapsync_delay_seconds",
"Delay of LDAP replication in seconds",
registry=registry,
)
now = datetime.utcnow().timestamp()
delay_gauge.set(now - ctr)
writer.write(b"HTTP/1.0 200 OK\r\n")
writer.write("Content-Type: {}\r\n".format(
prometheus_client.exposition.CONTENT_TYPE_LATEST).encode("utf-8"))
writer.write(b"\r\n")
writer.write(prometheus_client.exposition.generate_latest(registry))
def test_record_call_latency_sync(self):
definitions = [
MetricDefinition("Histogram", "histo", "An histogram",
["foo", "bar"])
]
prometheus_metrics = PrometheusMetrics(
definitions=definitions,
registry=prometheus_client.CollectorRegistry(),
)
label_call_args = []
def get_labels(*args, **kwargs):
label_call_args.append((args, kwargs))
return {"foo": "FOO", "bar": "BAR"}
@prometheus_metrics.record_call_latency("histo", get_labels=get_labels)
def func(param1, param2=None):
return param1
obj = object()
result = func(obj, param2="baz")
self.assertIs(result, obj)
# the get_labels function is called with the same args as the function
self.assertEqual(label_call_args, [((obj, ), {"param2": "baz"})])
self.assertIn(
'histo_count{bar="BAR",foo="FOO"} 1.0',
prometheus_metrics.generate_latest().decode("ascii"),
)
def test_track_tftp_latency(self):
class Thing:
did_something = False
def do_something(self):
self.did_something = True
return True
thing = Thing()
start_time = time.time()
prometheus_metrics = create_metrics(
METRICS_DEFINITIONS,
registry=prometheus_client.CollectorRegistry())
thing.do_something = track_tftp_latency(
thing.do_something,
start_time=start_time,
filename='myfile.txt',
prometheus_metrics=prometheus_metrics)
time_mock = self.patch(tftp_module, 'time')
time_mock.return_value = start_time + 0.5
result = thing.do_something()
self.assertTrue(result)
self.assertTrue(thing.did_something)
metrics = prometheus_metrics.generate_latest().decode('ascii')
self.assertIn(
'maas_tftp_file_transfer_latency_count{filename="myfile.txt"} 1.0',
metrics)
self.assertIn(
'maas_tftp_file_transfer_latency_bucket'
'{filename="myfile.txt",le="0.5"} 1.0', metrics)
self.assertIn(
'maas_tftp_file_transfer_latency_bucket'
'{filename="myfile.txt",le="0.25"} 0.0', metrics)
def setup_status(app) -> prometheus_client.CollectorRegistry:
"""Add /status to serve Prometheus-driven runtime metrics."""
registry = prometheus_client.CollectorRegistry(auto_describe=True)
app["request_count"] = prometheus_client.Counter(
"requests_total",
"Total Request Count",
["app_name", "method", "endpoint", "http_status"],
registry=registry,
)
app["request_latency"] = prometheus_client.Histogram(
"request_latency_seconds",
"Request latency",
["app_name", "endpoint"],
registry=registry,
)
app["request_in_progress"] = prometheus_client.Gauge(
"requests_in_progress_total",
"Requests in progress",
["app_name", "endpoint", "method"],
registry=registry,
)
prometheus_client.Info("server", "API server version",
registry=registry).info({
"version":
metadata.__version__,
"commit":
getattr(metadata, "__commit__", "null"),
"build_date":
getattr(metadata, "__date__", "null"),
})
app.middlewares.insert(0, instrument)
# passing StatusRenderer(registry) without __call__ triggers a spurious DeprecationWarning
# FIXME(vmarkovtsev): https://github.com/aio-libs/aiohttp/issues/4519
app.router.add_get("/status", StatusRenderer(registry).__call__)
return registry
def __init__(self, push_gateaway, nodename, jobname="Duty"):
'''
Arguments
---------
push_gateaway: str
Push gateway
nodename : str
Name of node
jobname : str
default of "Duty"
Not important
'''
self.push_gateaway = push_gateaway
self.registry = pc.CollectorRegistry()
self.nodename = nodename
self.jobname = jobname
### Defining metrics
# Are there heimdall|fredda candidates?
self.heimdall_up = pc.Enum('cands_heimdall_up',
'Heimdall candidates present',
states=['yes', 'no'],
labelnames=['node', 'antenna'])
self.fredda_up = pc.Enum('cands_fredda_up',
'Fredda candidates present',
states=['yes', 'no'],
labelnames=['node', 'antenna'])
# How many candidates
self.heimdall_n = pc.Gauge('cands_heimdall_num',
'Heimdall candidates number',
labelnames=['node', 'antenna'])
self.fredda_n = pc.Gauge('cands_fredda_num',
'Fredda candidates number',
labelnames=['node', 'antenna'])
def after_process_boot(self, broker):
os.environ["prometheus_multiproc_dir"] = DB_PATH
# This import MUST happen at runtime, after process boot and
# after the env variable has been set up.
import prometheus_client as prom
self.logger.debug("Setting up metrics...")
registry = prom.CollectorRegistry()
self.total_messages = prom.Counter(
"dramatiq_messages_total",
"The total number of messages processed.",
["queue_name", "actor_name"],
registry=registry,
)
self.total_errored_messages = prom.Counter(
"dramatiq_message_errors_total",
"The total number of errored messages.",
["queue_name", "actor_name"],
registry=registry,
)
self.total_retried_messages = prom.Counter(
"dramatiq_message_retries_total",
"The total number of retried messages.",
["queue_name", "actor_name"],
registry=registry,
)
self.total_rejected_messages = prom.Counter(
"dramatiq_message_rejects_total",
"The total number of dead-lettered messages.",
["queue_name", "actor_name"],
registry=registry,
)
self.total_revived_messages = prom.Counter(
"dramatiq_message_revives_total",
"The total number of messages revived from dead workers.",
["queue_name", "actor_name"],
registry=registry,
)
self.inprogress_messages = prom.Gauge(
"dramatiq_messages_inprogress",
"The number of messages in progress.",
["queue_name", "actor_name"],
registry=registry,
multiprocess_mode="livesum",
)
self.inprogress_delayed_messages = prom.Gauge(
"dramatiq_delayed_messages_inprogress",
"The number of delayed messages in memory.",
["queue_name", "actor_name"],
registry=registry,
)
self.message_durations = prom.Histogram(
"dramatiq_message_duration_milliseconds",
"The time spent processing messages.",
["queue_name", "actor_name"],
buckets=(5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000,
7500, 10000, 30000, 60000, 600000, 900000, float("inf")),
registry=registry,
)
def test_update_metrics(self):
prometheus_metrics = create_metrics(
METRICS_DEFINITIONS,
registry=prometheus_client.CollectorRegistry())
middleware = PrometheusRequestMetricsMiddleware(
self.get_response, prometheus_metrics=prometheus_metrics)
middleware(factory.make_fake_request("/MAAS/accounts/login/"))
middleware(factory.make_fake_request("/MAAS/accounts/login/"))
middleware(factory.make_fake_request("/MAAS/other/path"))
middleware(
factory.make_fake_request("/MAAS/other/path",
data={'op': 'do-foo'}))
middleware(
factory.make_fake_request("/MAAS/other/path",
method='POST',
data={'op': 'do-bar'}))
metrics_text = prometheus_metrics.generate_latest().decode('ascii')
self.assertIn(
'maas_http_request_latency_count{method="GET",op="",'
'path="/MAAS/accounts/login/",status="200"} 2.0', metrics_text)
self.assertIn(
'maas_http_request_latency_count{method="GET",op="do-foo",'
'path="/MAAS/other/path",status="404"} 1.0', metrics_text)
self.assertIn(
'maas_http_request_latency_count{method="POST",op="do-bar",'
'path="/MAAS/other/path",status="404"} 1.0', metrics_text)
def testPrometheusIntegration(self):
registry = prometheus_client.CollectorRegistry(auto_describe=True)
def MakeCollector(metadatas):
return prometheus_stats_collector.PrometheusStatsCollector(
metadatas, registry)
with self.SetUpStatsCollector(MakeCollector):
counter = metrics.Counter("foobars")
counter.Increment(42)
port = portpicker.pick_unused_port()
with mock.patch.object(stats_server.StatsServerHandler, "registry",
registry):
server = stats_server.StatsServer(port)
server.Start()
self.addCleanup(server.Stop)
res = requests.get("http://localhost:{}/metrics".format(port))
text_fd = io.StringIO(res.text)
families = prometheus_parser.text_fd_to_metric_families(text_fd)
families = {family.name: family for family in families}
self.assertIn("foobars", families)
self.assertEqual(families["foobars"].samples[0].value, 42)
def test_metrics_prometheus_not_availble(self):
self.patch(utils, "PROMETHEUS_SUPPORTED", False)
prometheus_metrics = create_metrics(
self.metrics_definitions,
registry=prometheus_client.CollectorRegistry(),
)
self.assertEqual(prometheus_metrics.available_metrics, [])
def test_update_metrics(self):
self.patch(metrics, "GLOBAL_LABELS", {"service_type": "rack"})
tempdir = self.useFixture(TempDirectory())
meminfo = Path(tempdir.path) / "meminfo"
meminfo.write_text(
dedent(
"""\
MemTotal: 123 Kb
SwapCached: 456 Kb
VmallocUsed: 789 Kb
HugePages_Total: 321
"""
)
)
prometheus_metrics = create_metrics(
node_metrics_definitions(),
registry=prometheus_client.CollectorRegistry(),
)
update_memory_metrics(prometheus_metrics, path=meminfo)
output = prometheus_metrics.generate_latest().decode("ascii")
self.assertIn(
'maas_node_mem_MemTotal{service_type="rack"} 123.0', output
)
self.assertIn(
'maas_node_mem_SwapCached{service_type="rack"} 456.0', output
)
self.assertIn(
'maas_node_mem_VmallocUsed{service_type="rack"} 789.0', output
)
self.assertIn(
'maas_node_mem_HugePages_Total{service_type="rack"} 321.0', output
)
def test_metrics_disabled(self):
prometheus_metrics = create_metrics(
None, registry=prometheus_client.CollectorRegistry())
resource = http.PrometheusMetricsResource(prometheus_metrics)
request = Request(DummyChannel(), False)
content = resource.render_GET(request).decode('utf-8')
self.assertEqual(request.code, 404)
self.assertEqual(content, '')
def test_no_register_atexit_custom_registry(self):
mock_register = self.patch(atexit, 'register')
definitions = [
MetricDefinition('Gauge', 'a_gauge', 'A Gauge', ['foo', 'bar'])
]
PrometheusMetrics(definitions=definitions,
registry=prometheus_client.CollectorRegistry())
mock_register.assert_not_called()
def __init__(self, crawler):
"""
:param scrapy.crawler.Crawler crawler:
"""
self.crawler = crawler
self.registries = defaultdict(lambda: prometheus_client.CollectorRegistry())
self.crawler.signals.connect(self.engine_stopped, signal=signals.engine_stopped)
super(PrometheusStatsCollector, self).__init__(crawler)
def setUp(self):
self.app = Flask(__name__)
self.app.testing = True
self.client = self.app.test_client()
# reset the underlying Prometheus registry
prometheus_client.REGISTRY = prometheus_client.CollectorRegistry(
auto_describe=True)
def start_metrics_server():
print("Metrics server started")
if "prometheus_multiproc_dir" in os.environ:
registry = prometheus_client.CollectorRegistry()
multiprocess.MultiProcessCollector(registry)
else:
registry = REGISTRY
start_http_server(9090, addr="0.0.0.0", registry=registry)
def test_update_call_value_class(self):
definitions = [MetricDefinition('Counter', 'a_counter', 'A Counter')]
prometheus_metrics = PrometheusMetrics(
definitions=definitions,
registry=prometheus_client.CollectorRegistry())
prometheus_metrics.update('a_counter', 'set', value=22)
self.assertIn('a_counter 22.0',
prometheus_metrics.generate_latest().decode('ascii'))
def test_update_metrics(self):
self.patch(metrics, "GLOBAL_LABELS", {"service_type": "rack"})
tempdir = self.useFixture(TempDirectory())
stat = Path(tempdir.path) / "stat"
stat.write_text(
dedent("""\
cpu 111 222 333 444 555 666 7 888 9 11
cpu0 222 333 444 555 666 777 8 999 1 22
cpu1 222 333 444 555 666 777 8 999 1 22
other line
other line
"""))
prometheus_metrics = create_metrics(
node_metrics_definitions(),
registry=prometheus_client.CollectorRegistry(),
)
update_cpu_metrics(prometheus_metrics, path=stat)
output = prometheus_metrics.generate_latest().decode("ascii")
self.assertIn(
'maas_node_cpu_time_total{service_type="rack",state="user"} 1.11',
output,
)
self.assertIn(
'maas_node_cpu_time_total{service_type="rack",state="nice"} 2.22',
output,
)
self.assertIn(
'maas_node_cpu_time_total{service_type="rack",state="system"} 3.33',
output,
)
self.assertIn(
'maas_node_cpu_time_total{service_type="rack",state="idle"} 4.44',
output,
)
self.assertIn(
'maas_node_cpu_time_total{service_type="rack",state="iowait"} 5.55',
output,
)
self.assertIn(
'maas_node_cpu_time_total{service_type="rack",state="irq"} 6.66',
output,
)
self.assertIn(
'maas_node_cpu_time_total{service_type="rack",state="softirq"} 0.07',
output,
)
self.assertIn(
'maas_node_cpu_time_total{service_type="rack",state="steal"} 8.88',
output,
)
self.assertIn(
'maas_node_cpu_time_total{service_type="rack",state="guest"} 0.09',
output,
)
self.assertIn(
'maas_node_cpu_time_total{service_type="rack",state="guest_nice"} 0.11',
output,
)
def setup_prom_server():
multiproc_dir = os.environ['prometheus_multiproc_dir']
logging.info("Exposing prometheus metrics in multi-process mode")
logging.info("Cleaning up prometheus multiprocessing dir: {}".format(multiproc_dir))
for f in glob.glob(os.path.join(multiproc_dir, '*.db')):
os.remove(f)
registry = prometheus_client.CollectorRegistry()
prometheus_client.multiprocess.MultiProcessCollector(registry)
prometheus_client.start_http_server(PROM_METRICS_ENDPOINT_PORT, registry=registry)
def __init__(self, project_id: str,
compute_client: googleapiclient.discovery.Resource, http_port,
metrics_mode):
self.project_id = project_id
self.compute_client = compute_client
self.http_port = int(http_port)
self.metrics: typing.Dict[str, prometheus_client.core.Gauge] = {}
self.registry = prometheus_client.CollectorRegistry(auto_describe=True)
self.metrics_mode = metrics_mode
def registry(monkeypatch, tmpdir):
registry = prometheus_client.CollectorRegistry()
def get_metric(name, **labels):
value = registry.get_sample_value(name, labels)
return 0 if value is None else value
registry.get_metric = get_metric
return registry
def metrics(request):
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 do_GET(self):
#self.registry = MetricsHandler.registry
self.registry = prometheus_client.CollectorRegistry()
function = self.path.split('?')[0]
param = self.path.split('?')[1]
input_name = dict(pair.split('=') for pair in param.split('&'))
if function == '/probe':
if input_name.get('module') == 'ping':
# http://localhost:8888/probe?module=ping&target=8.8.8.8
result = ping(input_name.get('target'))
if result[0]:
self.rtt_min = Gauge('ping_rtt_min',
'RTT Min',
registry=self.registry)
self.rtt_min.set(result[0])
if result[1]:
self.rtt_avg = Gauge('ping_rtt_avg',
'RTT Avg',
registry=self.registry)
self.rtt_avg.set(result[1])
if result[2]:
self.rtt_max = Gauge('ping_rtt_max',
'RTT Max',
registry=self.registry)
self.rtt_max.set(result[2])
self.packet_loss = Gauge('ping_packet_loss',
'Packet Loss',
registry=self.registry)
self.packet_loss.set(result[3])
return MetricsHandler.do_GET(self)
elif input_name.get('module') == 'speedtest':
# http://localhost:8888/probe?module=speedtest
# optional: http://localhost:8888/probe?module=speedtest&target=17846
if input_name.get('target'):
result = testspeed(input_name.get('target'))
else:
result = testspeed(0)
if result[0]:
self.rtt_min = Gauge('speedtest_download',
'Speedtest download', ['server'],
registry=self.registry)
self.rtt_min.labels(server=result[3]).set(result[0])
if result[1]:
self.rtt_avg = Gauge('speedtest_upload',
'Speedtest Upload', ['server'],
registry=self.registry)
self.rtt_avg.labels(server=result[3]).set(result[1])
if result[2]:
self.rtt_max = Gauge('speedtest_latency',
'Speedtest Latency', ['server'],
registry=self.registry)
self.rtt_max.labels(server=result[3]).set(result[2])
return MetricsHandler.do_GET(self)
else:
print("module not defined")
else:
print("function not defined")
