finish aync update

Signed-off-by: Zen <[email protected]>

Author: desultory

src/prometheus_exporter/cached_exporter.py

@@ -34,19 +34,19 @@ def read_config(self):
             if 'cache_life' in self.config:
                 self.cache_life = self.config['cache_life']
 
-        def _get_metrics(self):
-            return self._cached_metrics if hasattr(self, '_cached_metrics') else super()._get_metrics()
+        async def _get_metrics(self):
+            return self._cached_metrics if hasattr(self, '_cached_metrics') else await super()._get_metrics()
 
-        def get_metrics(self, label_filter={}):
+        async def get_metrics(self, label_filter={}):
             """ Get metrics from the exporter, caching the result. """
             from time import time
             if not hasattr(self, '_cached_metrics') or time() - self._cache_time >= self.cache_life:
                 self._cache_time = time()
-                self._cached_metrics = super().get_metrics(label_filter=label_filter)
+                self._cached_metrics = await super().get_metrics(label_filter=label_filter)
             else:
                 self.logger.info("Returning cached metrics.")
                 self.logger.debug("Cached metrics: %s", self._cached_metrics)
-            return self.filter_metrics(label_filter=label_filter)
+            return await self.filter_metrics(label_filter=label_filter)
 
     CachedExporter.__name__ = f"Cached{cls.__name__}"
     CachedExporter.__module__ = cls.__module__

src/prometheus_exporter/exporter.py

@@ -47,8 +47,10 @@ def start(self):
 
     async def handle_metrics(self, request, *args, **kwargs):
         params = dict([p.split('=') for p in request.query_string.split('&')]) if request.query_string else {}
-        self.logger.debug("Handling metrics request: %s", request)
-        return Response(text=self.export(params))
+        self.logger.info("[%s:%d] Handling metrics request: %s" % (self.host, self.port, request.query_string))
+        response = Response(text=await self.export(params))
+        self.logger.info("[%s] Sending response: <%d> Length: %d" % (request.remote, response.status, response.content_length))
+        return response
 
     def __setattr__(self, name, value):
         if name == 'labels' and not isinstance(value, Labels):
@@ -79,30 +81,30 @@ def add_config_metrics(self):
             self.logger.info("Adding metric: %s", name)
             self.metrics.append(Metric(name=name, **kwargs, **values))
 
-    def filter_metrics(self, label_filter={}):
+    async def filter_metrics(self, label_filter={}):
         """ Filters metrics by label. """
-        metrics = self._get_metrics().copy()
+        metrics = await self._get_metrics()
         for metric in metrics:
-            metrics = metric.labels.filter_metrics(metrics, label_filter)
+            metrics = await metric.labels.filter_metrics(metrics, label_filter)
         return metrics
 
     def get_labels(self):
         """ Gets a copy of the labels dict. """
         return self.labels.copy()
 
-    def _get_metrics(self):
+    async def _get_metrics(self):
         """ Gets all defined metrics. """
         return self.metrics
 
-    def get_metrics(self, label_filter={}):
+    async def get_metrics(self, label_filter={}):
         """ Gets all defined metrics, filtered by label_filter Can be overridden to use other methods."""
-        return self.filter_metrics(label_filter)
+        return await self.filter_metrics(label_filter)
 
-    def export(self, label_filter={}):
+    async def export(self, label_filter={}):
         """
         Gets metrics using self.get_metrics(), passing the label_filter.
         Turns them into a metric string for prometheus.
         """
-        metrics = self.get_metrics(label_filter)
+        metrics = await self.get_metrics(label_filter)
         self.logger.debug("Exporting metrics: %s", metrics)
         return "\n".join([str(metric) for metric in metrics])

src/prometheus_exporter/labels.py

@@ -18,7 +18,7 @@ def __init__(self, dict_items={}, **kwargs):
         """ Create a new Labels object from a dictionary """
         self.update(dict_items)
 
-    def filter_metrics(self, metrics, input_filter_dict={}):
+    async def filter_metrics(self, metrics, input_filter_dict={}):
         """ Filter the metrics based on the labels in the filter_dict """
         filter_dict = input_filter_dict.copy()
         # First filter the filter, to remove any labels that are not defined