kinto 19.2.0__py3-none-any.whl → 19.3.0__py3-none-any.whl

kinto/__init__.py

@@ -38,6 +38,7 @@ DEFAULT_SETTINGS = {
     "record_id_generator": "kinto.views.RelaxedUUID",
     "project_name": "kinto",
     "admin_assets_path": None,
+    "metrics_matchdict_fields": ["bucket_id", "collection_id", "group_id", "record_id"],
 }
 
 

kinto/core/__init__.py

@@ -96,6 +96,7 @@ DEFAULT_SETTINGS = {
     "statsd_backend": "kinto.core.statsd",
     "statsd_prefix": "kinto.core",
     "statsd_url": None,
+    "metrics_matchdict_fields": [],
     "storage_backend": "",
     "storage_url": "",
     "storage_max_fetch_size": 10000,

kinto/core/initialization.py

@@ -431,6 +431,9 @@ def setup_logging(config):
 def setup_metrics(config):
     settings = config.get_settings()
 
+    # Register a no-op metrics service by default.
+    config.registry.registerUtility(metrics.NoOpMetricsService(), metrics.IMetricsService)
+
     # This does not fully respect the Pyramid/ZCA patterns, but the rest of Kinto uses
     # `registry.storage`, `registry.cache`, etc. Consistency seems more important.
     config.registry.__class__.metrics = property(
@@ -449,9 +452,6 @@ def setup_metrics(config):
     def on_app_created(event):
         config = event.app
         metrics_service = config.registry.metrics
-        if not metrics_service:
-            logger.warning("No metrics service registered.")
-            return
 
         metrics.watch_execution_time(metrics_service, config.registry.cache, prefix="backend")
         metrics.watch_execution_time(metrics_service, config.registry.storage, prefix="backend")
@@ -471,15 +471,65 @@ def setup_metrics(config):
     def on_new_response(event):
         request = event.request
         metrics_service = config.registry.metrics
-        if not metrics_service:
-            return
+
+        try:
+            endpoint = utils.strip_uri_prefix(request.path)
+        except UnicodeDecodeError as e:
+            # This `on_new_response` callback is also called when a HTTP 400
+            # is returned because of an invalid UTF-8 path. We still want metrics.
+            endpoint = str(e)
 
         # Count unique users.
         user_id = request.prefixed_userid
         if user_id:
             # Get rid of colons in metric packet (see #1282).
-            user_id = user_id.replace(":", ".")
-            metrics_service.count("users", unique=user_id)
+            auth, user_id = user_id.split(":")
+            metrics_service.count("users", unique=[("auth", auth), ("userid", user_id)])
+
+        # Add extra labels to metrics, based on fields extracted from the request matchdict.
+        metrics_matchdict_fields = aslist(settings["metrics_matchdict_fields"])
+        # Turn the `id` field of object endpoints into `{resource}_id` (eg. `mushroom_id`, `bucket_id`)
+        enhanced_matchdict = dict(request.matchdict or {})
+        try:
+            enhanced_matchdict[request.current_resource_name + "_id"] = enhanced_matchdict.get(
+                "id", ""
+            )
+        except AttributeError:
+            # Not on a resource.
+            pass
+        metrics_matchdict_labels = [
+            (field, enhanced_matchdict.get(field, "")) for field in metrics_matchdict_fields
+        ]
+
+        # Count served requests.
+        metrics_service.count(
+            "request_summary",
+            unique=[
+                ("method", request.method.lower()),
+                ("endpoint", endpoint),
+                ("status", str(request.response.status_code)),
+            ]
+            + metrics_matchdict_labels,
+        )
+
+        try:
+            current = utils.msec_time()
+            duration = current - request._received_at
+            metrics_service.observe(
+                "request_duration",
+                duration,
+                labels=[("endpoint", endpoint)] + metrics_matchdict_labels,
+            )
+        except AttributeError:  # pragma: no cover
+            # Logging was not setup in this Kinto app (unlikely but possible)
+            pass
+
+        # Observe response size.
+        metrics_service.observe(
+            "request_size",
+            len(request.response.body or b""),
+            labels=[("endpoint", endpoint)] + metrics_matchdict_labels,
+        )
 
         # Count authentication verifications.
         if hasattr(request, "authn_type"):

kinto/core/metrics.py

@@ -1,6 +1,6 @@
 import types
 
-from zope.interface import Interface
+from zope.interface import Interface, implementer
 
 from kinto.core import utils
 
@@ -16,13 +16,47 @@ class IMetricsService(Interface):
         Watch execution time.
         """
 
+    def observe(self, key, value, labels=[]):
+        """
+        Observe a give `value` for the specified `key`.
+        """
+
     def count(key, count=1, unique=None):
         """
         Count occurrences. If `unique` is set, overwrites the counter value
         on each call.
+
+        `unique` should be of type ``list[tuple[str,str]]``.
         """
 
 
+class NoOpTimer:
+    def __call__(self, f):
+        @utils.safe_wraps(f)
+        def _wrapped(*args, **kwargs):
+            return f(*args, **kwargs)
+
+        return _wrapped
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, *args, **kwargs):
+        pass
+
+
+@implementer(IMetricsService)
+class NoOpMetricsService:
+    def timer(self, key):
+        return NoOpTimer()
+
+    def observe(self, key, value, labels=[]):
+        pass
+
+    def count(self, key, count=1, unique=None):
+        pass
+
+
 def watch_execution_time(metrics_service, obj, prefix="", classname=None):
     """
     Decorate all methods of an object in order to watch their execution time.
@@ -49,6 +83,8 @@ def listener_with_timer(config, key, func):
     def wrapped(*args, **kwargs):
         metrics_service = config.registry.metrics
         if not metrics_service:
+            # This only happens if `kinto.core.initialization.setup_metrics` is
+            # not listed in the `initialization_sequence` setting.
             return func(*args, **kwargs)
         # If metrics are enabled, monitor execution time of listeners.
         with metrics_service.timer(key):

kinto/core/utils.py

@@ -1,4 +1,5 @@
 import collections.abc as collections_abc
+import functools
 import hashlib
 import hmac
 import os
@@ -541,3 +542,10 @@ def apply_json_patch(obj, ops):
         raise ValueError(e)
 
     return result
+
+
+def safe_wraps(wrapper, *args, **kwargs):
+    """Safely wraps partial functions."""
+    while isinstance(wrapper, functools.partial):
+        wrapper = wrapper.func
+    return functools.wraps(wrapper, *args, **kwargs)

kinto/plugins/admin/VERSION

@@ -1 +1 @@
-3.0.3
+3.4.1

kinto/plugins/admin/build/VERSION

@@ -1 +1 @@
-3.0.3
+3.4.1