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