def test_choose_encoder():
assert choose_encoder(None) == (generate_latest, CONTENT_TYPE_LATEST)
assert choose_encoder(CONTENT_TYPE_LATEST) == (generate_latest,
CONTENT_TYPE_LATEST)
assert choose_encoder(
openmetrics.CONTENT_TYPE_LATEST) == (openmetrics.generate_latest,
openmetrics.CONTENT_TYPE_LATEST)
def do_GET(self):
if urlparse(self.path).path != '/metrics':
self.send_response(200)
self.send_header('Content-Type',
"Content-Type: text/html; charset=utf-8")
self.end_headers()
self.wfile.write("""<html>
<head><title>Node Exporter</title></head>
<body>
<h1>Node Exporter</h1>
<p><a href="/metrics">Metrics</a></p>
</body>
</html>""".encode('utf-8'))
return
params = parse_qs(urlparse(self.path).query)
encoder, content_type = exposition.choose_encoder(
self.headers.get('Accept'))
if 'collect[]' in params:
names = params['collect[]']
CController.collect(names)
# self.cc.collect(names)
# registry = registry.restricted_registry(params['name[]'])
try:
output = encoder(self.registry)
except:
self.send_error(500, 'error generating metric output')
raise
self.send_response(200)
self.send_header('Content-Type', content_type)
self.end_headers()
self.wfile.write(output)
def handle(self, accept_header: str = None) -> str:
"""
Handler for the metrics endpoint. Generates a string
containing all the metrics in the registry.
:param accept_header: the HTTP Accept header for the output metrics,
should be set to application/openmetrics-text to generate
openmetrics-compatible output. Defaults to None.
"""
for fn, mfunc, metric in self.deferred_metrics:
try:
start = timer()
resp = fn()
if not isinstance(resp, Number):
resp = float(resp)
except BaseException:
raise
if isinstance(metric, (Histogram, Summary)):
end = max(timer() - start, 0)
mfunc(metric, end)
else:
mfunc(metric, resp)
encoder, _ = choose_encoder(accept_header)
return encoder(self.registry)
def app(self, environ: Dict, start_response: Any) -> Iterable[ByteString]:
"""
Create a WSGI app which serves the metrics from a registry.
:param environ:
:param start_response:
:return:
"""
url = urlparse(request_uri(environ))
if url.path == '/health':
start_response(self.collector.status,
[('Content-Type', 'application/json')])
return [b'{}']
if url.path.startswith('/metric'):
params = parse_qs(environ.get('QUERY_STRING', ''))
r = REGISTRY
encoder, content_type = choose_encoder(environ.get('HTTP_ACCEPT'))
if 'name[]' in params:
r = r.restricted_registry(params['name[]'])
output = encoder(r)
status = str('200 OK')
headers = [(str('Content-type'), content_type)]
start_response(status, headers)
return [output]
start_response('404 Not Found', [('Content-Type', 'application/json')])
return [b'{}']
def prometheus_exporter():
registry = REGISTRY
encoder, content_type = exposition.choose_encoder(request.headers.get('Accept'))
if 'name[]' in request.args:
registry = REGISTRY.restricted_registry(request.args.get('name[]'))
body = encoder(registry)
return Response(body, content_type=content_type)
def expose_metrics(request):
metrics_names = request.args.getlist('name', [])
registry = REGISTRY.restricted_registry(
metrics_names) if metrics_names else REGISTRY
encoder, content_type = choose_encoder(request.headers['Accept'])
results = encoder(registry)
return Response(results, content_type=content_type)
async def get(self) -> None:
accept_header = self.request.headers.get("accept")
encoder, content_type = exposition.choose_encoder(accept_header)
application = cast(PrometheusMixin, self.application)
output = encoder(application.prometheus_registry)
self.set_header("Content-Type", content_type)
self.write(output)
def metrics():
borgmatic_config = current_app.config["borgmatic_config"]
registry = current_app.config["registry"]
collect(borgmatic_config, registry)
encoder, content_type = choose_encoder(request.headers.get("accept"))
output = encoder(current_app.config["registry"])
return output, 200, {"Content-Type": content_type}
async def get(self):
user_token = get_user_token(self.args.username)
text_stream = io.StringIO()
with redirect_stdout(text_stream):
hubtraf_check_status = await check_user(
self.args.hub_url, self.args.username, user_token, json=True
)
if hubtraf_check_status == "completed":
CHECK_COMPLETED.set(1)
hubtraf_output = text_stream.getvalue()
# Collect metrics from hubtraf
for line in hubtraf_output.splitlines():
hubtraf_metric = json.loads(line)
status = hubtraf_metric["status"]
if status in ["Success", "Failure"]:
prometheus_metrics_aliases[hubtraf_metric["action"]].labels(
status=status
).observe(float(hubtraf_metric["duration"]))
encoder, content_type = exposition.choose_encoder(
self.request.headers.get("Accept")
)
self.set_header("Content-Type", content_type)
self.write(encoder(self.registry))
async def prometheus_metrics_handler(request):
encoder, content_type = choose_encoder(request.headers.get("Accept"))
registry = REGISTRY
if "name[]" in request.path_qs:
registry = registry.restricted_registry(request.path_qs["name[]"])
output = encoder(registry)
return web.Response(body=output,
status=200,
headers={"Content-Type": content_type})
def django_metrics_view(request: HttpRequest) -> HttpResponse:
registry = REGISTRY
accept = request.headers.get('Accept')
encoder, content_type = choose_encoder(accept)
if 'name[]' in request.GET:
name = request.GET['name[]']
registry = registry.restricted_registry(name)
output = encoder(registry)
return HttpResponse(content=output, content_type=content_type)
async def aiohttp_metrics_handler(request: Request):
registry = REGISTRY
accept = request.headers.get('Accept')
encoder, content_type = choose_encoder(accept)
if 'name[]' in request.query:
name = request.query['name[]']
registry = registry.restricted_registry(name)
output = encoder(registry)
return Response(body=output, headers={'Content-Type': content_type})
async def metrics(request):
"""
Metrics gathering route
"""
req_counter.inc()
accept_header = request.headers.get('Accept', '')
encoder, content_type = choose_encoder(accept_header)
output = encoder(registry)
return web.Response(text=output.decode('utf-8'))
def get(self, *args, **kwargs):
encoder, content_type = choose_encoder(
self.request.headers.get('accept'))
self.set_header("Content-Type", content_type)
self.write("# HELP qps the number of requests\n")
self.write("# TYPE qps counter\n")
self.write("qps " + str(self.application.qps) + "\n")
self.write("# EOF\n")
self.flush()
self.finish()
def get(self) -> None:
registry = self.registry
accept = self.request.headers.get("Accept")
encoder, content_type = choose_encoder(accept)
name = self.get_argument("name", None)
if name:
registry = registry.restricted_registry(name)
output = encoder(registry)
self.set_header("Content-Type", content_type)
self.write(output)
async def metrics_handler(request):
registry = REGISTRY
encoder, content_type = choose_encoder(request.headers.get("Accept"))
if "name[]" in request.query:
registry = registry.restricted_registry(request.query["name[]"])
try:
return web.Response(content_type=_parse_content_type(content_type),
body=encoder(registry))
except Exception:
raise web.HTTPInternalServerError("error generating metric output")
async def get(self):
args = self.args
out = subprocess.check_output(
["hubtraf-check", args.hub_url, args.username])
encoder, content_type = exposition.choose_encoder(
self.request.headers.get("Accept"))
self.set_header("Content-Type", content_type)
self.write(encoder(self.registry))
def metrics():
encoder, content_type = choose_encoder(request.headers.get('Accept'))
logger.info(f"Got encoder")
try:
output = tsa.metrics(encoder)
except:
logger.info(f"Failed to get encoded output. Aborting")
abort(500, 'error generating metric output')
logger.info(f"Returning output")
return (Response(output, mimetype=content_type))
def metrics():
auth = request.authorization
if not auth or auth.username != settings.METRICS_USER or auth.password != settings.METRICS_PASS:
return Response('Auth required', 401,
{'WWW-Authenticate': 'Basic realm="Login Required"'})
encoder, content_type = exposition.choose_encoder(
request.headers.get('Accept'))
return no_cache(
Response(
encoder(metric_registry),
content_type=content_type,
))
def do_GET(self):
c.inc()
e.state(random.choice(['starting', 'running', 'stopped']))
h.observe(random.randint(1, 11))
registry = CollectorRegistry(auto_describe=True)
for i in collectors:
registry.register(i)
encoder, content_type = choose_encoder(self.headers.get('Accept'))
output = encoder(registry)
output2 = encoder(global_registry)
self.send_response(200)
self.send_header('Content-Type', content_type)
self.end_headers()
self.wfile.write(output)
self.wfile.write(output2)
async def metrics(self, request):
"""
---
description: Запрос для получения метрик сервиса
tags:
- Metrics
produces:
- text/plain
responses:
"200":
description: успех. Возвращает метрики
"""
encoder, content_type = exposition.choose_encoder(request.headers.get('Accept'))
scrape = encoder(self.registry)
return web.Response(headers=dict([('Content-Type', content_type)]), body=scrape)
def do_GET(self):
"""Respond to request for metrics."""
for cb in self.callbacks:
cb()
registry = self.registry
encoder, content_type = choose_encoder(self.headers.get("Accept"))
try:
output = encoder(registry)
except Exception as err:
logger.debug(f"Error generating metric output: {err}")
self.send_error(500, "error generating metric output")
raise
self.send_response(200)
self.send_header("Content-Type", content_type)
self.end_headers()
self.wfile.write(output)
def prometheus_metrics():
# import these here so they don't clash with our own multiprocess module
from prometheus_client import multiprocess, CollectorRegistry
if 'prometheus_multiproc_dir' in os.environ:
registry = CollectorRegistry()
else:
registry = self.registry
if 'name[]' in request.args:
registry = registry.restricted_registry(request.args.getlist('name[]'))
if 'prometheus_multiproc_dir' in os.environ:
multiprocess.MultiProcessCollector(registry)
generate_latest, content_type = choose_encoder(request.headers.get("Accept"))
headers = {'Content-Type': content_type}
return generate_latest(registry), 200, headers
def get(self):
if not gpu_data:
self.write("error")
return
base_list = gpu_data["base_list"]
processes = gpu_data["processes"]
nvidia_gpu_num_devices.set(len(base_list))
self.clear_metrics()
for data in base_list:
nvidia_gpu_duty_cycle.labels(minor_number=data["index"],
name=data["name"],
uuid=data["uuid"]).set(
data["utilization.gpu"])
nvidia_gpu_memory_total_bytes.labels(
minor_number=data["index"],
name=data["name"],
uuid=data["uuid"]).set(data["memory.total"] * 1024 * 1024)
nvidia_gpu_memory_used_bytes.labels(
minor_number=data["index"],
name=data["name"],
uuid=data["uuid"]).set(data["memory.used"] * 1024 * 1024)
nvidia_gpu_temperature_celsius.labels(minor_number=data["index"],
name=data["name"],
uuid=data["uuid"]).set(
data["temperature.gpu"])
for pid, data in processes.items():
ps = data["processes"] # list
for p in ps:
container_nvidia_gpu_memory_used_bytes.labels(
minor_number=p["index"],
container_name=data["container_name"],
container_id=data["container_id"],
pid=pid,
cmd=p["command"],
since_time=data["since_time"]).set(p["gpu_memory_usage"] *
1024 * 1024)
encoder, content_type = exposition.choose_encoder(
self.request.headers.get('Accept'))
self.set_header('Content-Type', content_type)
self.write(encoder(self.registry))
async def handle_metrics(self, request: Request) -> Response:
"""
Endpoint for fetching metrics from Prometheus.
Request can specify a custom encoding type `application/openmetrics-text` to
fetch data in a different format.
:param request:
:return response:
"""
try:
self.authenticate_request(request)
# pyre-fixme[16]: Callable `headers` has no attribute `get`.
encoder, content_type = prometheus_client.choose_encoder(
request.headers.get("Accept"))
output = encoder(REGISTRY)
response = Response(body=output,
headers={"Content-Type": content_type})
return response
except HTTPClientError as e:
return self._format_http_error(e)
def expose_metrics(self, request: Request) -> Response:
"""
Returns metrics as a HTTP response in Prometheus text format.
"""
if "name" not in request.args:
logger.debug(
"Registry name(s) not found in query string, using global registry"
)
registry = REGISTRY
else:
names = request.args.getlist("name")
registry = REGISTRY.restricted_registry(names)
encoder, content_type = choose_encoder(request.headers["Accept"])
try:
output = encoder(registry)
return Response(output, status=200, content_type=content_type)
except Exception:
message = "Failed to generate metrics"
logger.exception(message)
return Response(message, status=500)
def as_http(
self,
params: Optional[Mapping[str, List[str]]] = None,
headers: Optional[Mapping[str, str]] = None,
) -> Tuple[bytes, str]:
"""Encodes all metrics in the registry as a HTTP response.
The metric selection and encoding are extracted from the query param and accept header
respectively. Reference implementation: `prometheus_client.exposition.MetricsHandler`
:param params: The request query params, defaults to None
:type params: Optional[Mapping[str, List[str]]], optional
:param headers: The HTTP request headers, defaults to None
:type headers: Optional[Mapping[str, str]], optional
:return: A tuple of response body and content type
:rtype: Tuple[bytes, str]
"""
params = params or {}
headers = headers or {}
encoder, content_type = choose_encoder(headers.get("Accept"))
body = self.as_text(names=params.get("name[]"), encoder=encoder)
return body, content_type
def expose_metrics(self, request: Request) -> Response:
"""
Returns metrics as a HTTP response in Prometheus text format.
"""
registry: Union[CollectorRegistry, RestrictedRegistry]
if "name" not in request.args:
logger.debug(
"Registry name(s) not found in query string, using global registry"
)
registry = REGISTRY
else:
names = request.args.getlist("name")
registry = REGISTRY.restricted_registry(names)
encoder, content_type = choose_encoder(request.headers["Accept"])
try:
# note: registry may be an instance of RestrictedRegistry , but
# the only thing encoder does, is call registry.collect(); perhaps
# a Protocol-based type would be more suitable here?
output = encoder(registry) # type: ignore
return Response(output, status=200, content_type=content_type)
except Exception:
message = "Failed to generate metrics"
logger.exception(message)
return Response(message, status=500)
def get(self):
encoder, content_type = choose_encoder(
self.request.headers.get("accept"))
self.set_header("Content-Type", content_type)
self.write(encoder(REGISTRY))
def get(self):
encoder, content_type = choose_encoder(
self.request.headers.get('accept'))
self.set_header("Content-Type", content_type)
self.write(encoder(self.registry))
