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

kinto/core/__init__.py

@@ -66,8 +66,8 @@ DEFAULT_SETTINGS = {
         "kinto.core.initialization.setup_authentication",
         "kinto.core.initialization.setup_backoff",
         "kinto.core.initialization.setup_sentry",
-        "kinto.core.initialization.setup_statsd",
         "kinto.core.initialization.setup_listeners",
+        "kinto.core.initialization.setup_metrics",
         "kinto.core.events.setup_transaction_hook",
     ),
     "event_listeners": "",

kinto/core/initialization.py

@@ -21,7 +21,7 @@ from pyramid.security import NO_PERMISSION_REQUIRED
 from pyramid.settings import asbool, aslist
 from pyramid_multiauth import MultiAuthenticationPolicy, MultiAuthPolicySelected
 
-from kinto.core import cache, errors, permission, storage, utils
+from kinto.core import cache, errors, metrics, permission, storage, utils
 from kinto.core.events import ACTIONS, ResourceChanged, ResourceRead
 
 
@@ -334,51 +334,13 @@ def setup_sentry(config):
 
 
 def setup_statsd(config):
-    settings = config.get_settings()
-    config.registry.statsd = None
-
-    if settings["statsd_url"]:
-        statsd_mod = settings["statsd_backend"]
-        statsd_mod = config.maybe_dotted(statsd_mod)
-        client = statsd_mod.load_from_config(config)
-
-        config.registry.statsd = client
-
-        client.watch_execution_time(config.registry.cache, prefix="backend")
-        client.watch_execution_time(config.registry.storage, prefix="backend")
-        client.watch_execution_time(config.registry.permission, prefix="backend")
-
-        # Commit so that configured policy can be queried.
-        config.commit()
-        policy = config.registry.queryUtility(IAuthenticationPolicy)
-        if isinstance(policy, MultiAuthenticationPolicy):
-            for name, subpolicy in policy.get_policies():
-                client.watch_execution_time(subpolicy, prefix="authentication", classname=name)
-        else:
-            client.watch_execution_time(policy, prefix="authentication")
-
-        def on_new_response(event):
-            request = event.request
-
-            # 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(":", ".")
-                client.count("users", unique=user_id)
-
-            # Count authentication verifications.
-            if hasattr(request, "authn_type"):
-                client.count(f"authn_type.{request.authn_type}")
-
-            # Count view calls.
-            service = request.current_service
-            if service:
-                client.count(f"view.{service.name}.{request.method}")
-
-        config.add_subscriber(on_new_response, NewResponse)
-
-        return client
+    # It would be pretty rare to find users that have a custom ``kinto.initialization_sequence`` setting.
+    # But just in case, warn that it will be removed in next major.
+    warnings.warn(
+        "``setup_statsd()`` is now deprecated. Use ``kinto.core.initialization.setup_metrics()`` instead.",
+        DeprecationWarning,
+    )
+    setup_metrics(config)
 
 
 def install_middlewares(app, settings):
@@ -466,6 +428,75 @@ def setup_logging(config):
     config.add_subscriber(on_new_response, NewResponse)
 
 
+def setup_metrics(config):
+    settings = config.get_settings()
+
+    # 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(
+        lambda reg: reg.queryUtility(metrics.IMetricsService)
+    )
+
+    def deprecated_registry(self):
+        warnings.warn(
+            "``config.registry.statsd`` is now deprecated. Use ``config.registry.metrics`` instead.",
+            DeprecationWarning,
+        )
+        return self.metrics
+
+    config.registry.__class__.statsd = property(deprecated_registry)
+
+    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")
+        metrics.watch_execution_time(metrics_service, config.registry.permission, prefix="backend")
+
+        policy = config.registry.queryUtility(IAuthenticationPolicy)
+        if isinstance(policy, MultiAuthenticationPolicy):
+            for name, subpolicy in policy.get_policies():
+                metrics.watch_execution_time(
+                    metrics_service, subpolicy, prefix="authentication", classname=name
+                )
+        else:
+            metrics.watch_execution_time(metrics_service, policy, prefix="authentication")
+
+    config.add_subscriber(on_app_created, ApplicationCreated)
+
+    def on_new_response(event):
+        request = event.request
+        metrics_service = config.registry.metrics
+        if not metrics_service:
+            return
+
+        # 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)
+
+        # Count authentication verifications.
+        if hasattr(request, "authn_type"):
+            metrics_service.count(f"authn_type.{request.authn_type}")
+
+        # Count view calls.
+        service = request.current_service
+        if service:
+            metrics_service.count(f"view.{service.name}.{request.method}")
+
+    config.add_subscriber(on_new_response, NewResponse)
+
+    # While statsd is deprecated, we include its plugin by default for retro-compability.
+    if settings["statsd_url"]:
+        config.include("kinto.plugins.statsd")
+
+
 class EventActionFilter:
     def __init__(self, actions, config):
         actions = ACTIONS.from_string_list(actions)
@@ -518,11 +549,9 @@ def setup_listeners(config):
             listener_mod = config.maybe_dotted(module_value)
             listener = listener_mod.load_from_config(config, prefix)
 
-        # If StatsD is enabled, monitor execution time of listeners.
-        if getattr(config.registry, "statsd", None):
-            statsd_client = config.registry.statsd
-            key = f"listeners.{name}"
-            listener = statsd_client.timer(key)(listener.__call__)
+        wrapped_listener = metrics.listener_with_timer(
+            config, f"listeners.{name}", listener.__call__
+        )
 
         # Optional filter by event action.
         actions_setting = prefix + "actions"
@@ -548,11 +577,11 @@ def setup_listeners(config):
         options = dict(for_actions=actions, for_resources=resource_names)
 
         if ACTIONS.READ in actions:
-            config.add_subscriber(listener, ResourceRead, **options)
+            config.add_subscriber(wrapped_listener, ResourceRead, **options)
             actions = [a for a in actions if a != ACTIONS.READ]
 
         if len(actions) > 0:
-            config.add_subscriber(listener, ResourceChanged, **options)
+            config.add_subscriber(wrapped_listener, ResourceChanged, **options)
 
 
 def load_default_settings(config, default_settings):

kinto/core/metrics.py

@@ -0,0 +1,57 @@
+import types
+
+from zope.interface import Interface
+
+from kinto.core import utils
+
+
+class IMetricsService(Interface):
+    """
+    An interface that defines the metrics service contract.
+    Any class implementing this must provide all its methods.
+    """
+
+    def timer(key):
+        """
+        Watch execution time.
+        """
+
+    def count(key, count=1, unique=None):
+        """
+        Count occurrences. If `unique` is set, overwrites the counter value
+        on each call.
+        """
+
+
+def watch_execution_time(metrics_service, obj, prefix="", classname=None):
+    """
+    Decorate all methods of an object in order to watch their execution time.
+    Metrics will be named `{prefix}.{classname}.{method}`.
+    """
+    classname = classname or utils.classname(obj)
+    members = dir(obj)
+    for name in members:
+        value = getattr(obj, name)
+        is_method = isinstance(value, types.MethodType)
+        if not name.startswith("_") and is_method:
+            statsd_key = f"{prefix}.{classname}.{name}"
+            decorated_method = metrics_service.timer(statsd_key)(value)
+            setattr(obj, name, decorated_method)
+
+
+def listener_with_timer(config, key, func):
+    """
+    Add a timer with the specified `key` on the specified `func`.
+    This is used to avoid evaluating `config.registry.metrics` during setup time
+    to avoid having to deal with initialization order and configuration committing.
+    """
+
+    def wrapped(*args, **kwargs):
+        metrics_service = config.registry.metrics
+        if not metrics_service:
+            return func(*args, **kwargs)
+        # If metrics are enabled, monitor execution time of listeners.
+        with metrics_service.timer(key):
+            return func(*args, **kwargs)
+
+    return wrapped

kinto/core/statsd.py

@@ -1,63 +1 @@
-import types
-from urllib.parse import urlparse
-
-from pyramid.exceptions import ConfigurationError
-
-from kinto.core import utils
-
-
-try:
-    import statsd as statsd_module
-except ImportError:  # pragma: no cover
-    statsd_module = None
-
-
-class Client:
-    def __init__(self, host, port, prefix):
-        self._client = statsd_module.StatsClient(host, port, prefix=prefix)
-
-    def watch_execution_time(self, obj, prefix="", classname=None):
-        classname = classname or utils.classname(obj)
-        members = dir(obj)
-        for name in members:
-            value = getattr(obj, name)
-            is_method = isinstance(value, types.MethodType)
-            if not name.startswith("_") and is_method:
-                statsd_key = f"{prefix}.{classname}.{name}"
-                decorated_method = self.timer(statsd_key)(value)
-                setattr(obj, name, decorated_method)
-
-    def timer(self, key):
-        return self._client.timer(key)
-
-    def count(self, key, count=1, unique=None):
-        if unique is None:
-            return self._client.incr(key, count=count)
-        else:
-            return self._client.set(key, unique)
-
-
-def statsd_count(request, count_key):
-    statsd = request.registry.statsd
-    if statsd:
-        statsd.count(count_key)
-
-
-def load_from_config(config):
-    # If this is called, it means that a ``statsd_url`` was specified in settings.
-    # (see ``kinto.core.initialization``)
-    # Raise a proper error if the ``statsd`` module is not installed.
-    if statsd_module is None:
-        error_msg = "Please install Kinto with monitoring dependencies (e.g. statsd package)"
-        raise ConfigurationError(error_msg)
-
-    settings = config.get_settings()
-    uri = settings["statsd_url"]
-    uri = urlparse(uri)
-
-    if settings["project_name"] != "":
-        prefix = settings["project_name"]
-    else:
-        prefix = settings["statsd_prefix"]
-
-    return Client(uri.hostname, uri.port, prefix)
+from kinto.plugins.statsd import load_from_config  # noqa: F401

kinto/core/testing.py

@@ -8,15 +8,19 @@ import webtest
 from cornice import errors as cornice_errors
 from pyramid.url import parse_url_overrides
 
-from kinto.core import DEFAULT_SETTINGS, statsd
+from kinto.core import DEFAULT_SETTINGS
 from kinto.core.storage import generators
 from kinto.core.utils import encode64, follow_subrequest, memcache, sqlalchemy
+from kinto.plugins import prometheus, statsd
 
 
 skip_if_ci = unittest.skipIf("CI" in os.environ, "ci")
 skip_if_no_postgresql = unittest.skipIf(sqlalchemy is None, "postgresql is not installed.")
 skip_if_no_memcached = unittest.skipIf(memcache is None, "memcached is not installed.")
 skip_if_no_statsd = unittest.skipIf(not statsd.statsd_module, "statsd is not installed.")
+skip_if_no_prometheus = unittest.skipIf(
+    not prometheus.prometheus_module, "prometheus is not installed."
+)
 
 
 class DummyRequest(mock.MagicMock):

kinto/plugins/history/__init__.py

@@ -1,4 +1,5 @@
 from kinto.authorization import PERMISSIONS_INHERITANCE_TREE
+from kinto.core import metrics
 from kinto.core.events import ResourceChanged
 
 from .listener import on_resource_changed
@@ -14,15 +15,13 @@ def includeme(config):
     # Activate end-points.
     config.scan("kinto.plugins.history.views")
 
-    # If StatsD is enabled, monitor execution time of listener.
-    listener = on_resource_changed
-    if config.registry.statsd:
-        key = "plugins.history"
-        listener = config.registry.statsd.timer(key)(on_resource_changed)
+    wrapped_listener = metrics.listener_with_timer(config, "plugins.history", on_resource_changed)
 
     # Listen to every resources (except history)
     config.add_subscriber(
-        listener, ResourceChanged, for_resources=("bucket", "group", "collection", "record")
+        wrapped_listener,
+        ResourceChanged,
+        for_resources=("bucket", "group", "collection", "record"),
     )
 
     # Register the permission inheritance for history entries.

kinto/plugins/prometheus.py

@@ -0,0 +1,150 @@
+import functools
+from time import perf_counter as time_now
+
+from pyramid.exceptions import ConfigurationError
+from pyramid.response import Response
+from zope.interface import implementer
+
+from kinto.core import metrics
+
+
+try:
+    import prometheus_client as prometheus_module
+except ImportError:  # pragma: no cover
+    prometheus_module = None
+
+
+_METRICS = {}
+_REGISTRY = None
+
+
+def get_registry():
+    global _REGISTRY
+
+    if _REGISTRY is None:
+        _REGISTRY = prometheus_module.CollectorRegistry()
+    return _REGISTRY
+
+
+def _fix_metric_name(s):
+    return s.replace("-", "_").replace(".", "_")
+
+
+def safe_wraps(wrapper, *args, **kwargs):
+    """Safely wraps partial functions."""
+    while isinstance(wrapper, functools.partial):
+        wrapper = wrapper.func
+    return functools.wraps(wrapper, *args, **kwargs)
+
+
+class Timer:
+    def __init__(self, summary):
+        self.summary = summary
+        self._start_time = None
+
+    def __call__(self, f):
+        @safe_wraps(f)
+        def _wrapped(*args, **kwargs):
+            start_time = time_now()
+            try:
+                return f(*args, **kwargs)
+            finally:
+                dt_ms = 1000.0 * (time_now() - start_time)
+                self.summary.observe(dt_ms)
+
+        return _wrapped
+
+    def __enter__(self):
+        return self.start()
+
+    def __exit__(self, typ, value, tb):
+        self.stop()
+
+    def start(self):
+        self._start_time = time_now()
+        return self
+
+    def stop(self):
+        if self._start_time is None:  # pragma: nocover
+            raise RuntimeError("Timer has not started.")
+        dt_ms = 1000.0 * (time_now() - self._start_time)
+        self.summary.observe(dt_ms)
+        return self
+
+
+@implementer(metrics.IMetricsService)
+class PrometheusService:
+    def timer(self, key):
+        global _METRICS
+        if key not in _METRICS:
+            _METRICS[key] = prometheus_module.Summary(
+                _fix_metric_name(key), f"Summary of {key}", registry=get_registry()
+            )
+
+        if not isinstance(_METRICS[key], prometheus_module.Summary):
+            raise RuntimeError(
+                f"Metric {key} already exists with different type ({_METRICS[key]})"
+            )
+
+        return Timer(_METRICS[key])
+
+    def count(self, key, count=1, unique=None):
+        global _METRICS
+
+        # Turn `unique` into a group and a value:
+        # eg. `method.basicauth.mat` -> `method_basicauth="mat"`
+        label_value = None
+        if unique:
+            if "." not in unique:
+                unique = f"group.{unique}"
+            label_name, label_value = unique.rsplit(".", 1)
+            label_names = (_fix_metric_name(label_name),)
+        else:
+            label_names = tuple()
+
+        if key not in _METRICS:
+            _METRICS[key] = prometheus_module.Counter(
+                _fix_metric_name(key),
+                f"Counter of {key}",
+                labelnames=label_names,
+                registry=get_registry(),
+            )
+
+        if not isinstance(_METRICS[key], prometheus_module.Counter):
+            raise RuntimeError(
+                f"Metric {key} already exists with different type ({_METRICS[key]})"
+            )
+
+        m = _METRICS[key]
+        if label_value is not None:
+            m = m.labels(label_value)
+
+        m.inc(count)
+
+
+def metrics_view(request):
+    registry = get_registry()
+    data = prometheus_module.generate_latest(registry)
+    resp = Response(body=data)
+    resp.headers["Content-Type"] = prometheus_module.CONTENT_TYPE_LATEST
+    resp.headers["Content-Length"] = str(len(data))
+    return resp
+
+
+def includeme(config):
+    if prometheus_module is None:
+        error_msg = (
+            "Please install Kinto with monitoring dependencies (e.g. prometheus-client package)"
+        )
+        raise ConfigurationError(error_msg)
+
+    config.add_api_capability(
+        "prometheus",
+        description="Prometheus metrics.",
+        url="https://github.com/Kinto/kinto/",
+    )
+
+    config.add_route("prometheus_metrics", "/__metrics__")
+    config.add_view(metrics_view, route_name="prometheus_metrics")
+
+    config.registry.registerUtility(PrometheusService(), metrics.IMetricsService)

kinto/plugins/quotas/__init__.py

@@ -1,3 +1,4 @@
+from kinto.core import metrics
 from kinto.core.events import ResourceChanged
 
 from .listener import on_resource_changed
@@ -10,13 +11,11 @@ def includeme(config):
         url="https://kinto.readthedocs.io",
     )
 
-    # If StatsD is enabled, monitor execution time of listener.
-    listener = on_resource_changed
-    if config.registry.statsd:
-        key = "plugins.quotas"
-        listener = config.registry.statsd.timer(key)(on_resource_changed)
+    wrapped_listener = metrics.listener_with_timer(config, "plugins.quotas", on_resource_changed)
 
     # Listen to every resources (except history)
     config.add_subscriber(
-        listener, ResourceChanged, for_resources=("bucket", "group", "collection", "record")
+        wrapped_listener,
+        ResourceChanged,
+        for_resources=("bucket", "group", "collection", "record"),
     )

kinto/plugins/statsd.py

@@ -0,0 +1,58 @@
+from urllib.parse import urlparse
+
+from pyramid.exceptions import ConfigurationError
+from zope.interface import implementer
+
+from kinto.core import metrics
+
+
+try:
+    import statsd as statsd_module
+except ImportError:  # pragma: no cover
+    statsd_module = None
+
+
+@implementer(metrics.IMetricsService)
+class StatsDService:
+    def __init__(self, host, port, prefix):
+        self._client = statsd_module.StatsClient(host, port, prefix=prefix)
+
+    def timer(self, key):
+        return self._client.timer(key)
+
+    def count(self, key, count=1, unique=None):
+        if unique is None:
+            return self._client.incr(key, count=count)
+        else:
+            return self._client.set(key, unique)
+
+
+def load_from_config(config):
+    # If this is called, it means that a ``statsd_url`` was specified in settings.
+    # (see ``kinto.core.initialization``)
+    # Raise a proper error if the ``statsd`` module is not installed.
+    if statsd_module is None:
+        error_msg = "Please install Kinto with monitoring dependencies (e.g. statsd package)"
+        raise ConfigurationError(error_msg)
+
+    settings = config.get_settings()
+    uri = settings["statsd_url"]
+    uri = urlparse(uri)
+
+    if settings["project_name"] != "":
+        prefix = settings["project_name"]
+    else:
+        prefix = settings["statsd_prefix"]
+
+    return StatsDService(uri.hostname, uri.port, prefix)
+
+
+def includeme(config):
+    settings = config.get_settings()
+
+    # TODO: this backend abstraction may not be required anymore.
+    statsd_mod = settings["statsd_backend"]
+    statsd_mod = config.maybe_dotted(statsd_mod)
+    client = statsd_mod.load_from_config(config)
+
+    config.registry.registerUtility(client, metrics.IMetricsService)

{kinto-18.1.1.dist-info → kinto-19.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kinto
-Version: 18.1.1
+Version: 19.2.0
 Summary: Kinto Web Service - Store, Sync, Share, and Self-Host.
 Author-email: Mozilla Services <developers@kinto-storage.org>
 License: Copyright 2012 - Mozilla Foundation
@@ -59,6 +59,7 @@ Requires-Dist: newrelic ; extra == 'monitoring'
 Requires-Dist: sentry-sdk[sqlalchemy] ; extra == 'monitoring'
 Requires-Dist: statsd ; extra == 'monitoring'
 Requires-Dist: werkzeug ; extra == 'monitoring'
+Requires-Dist: prometheus-client ; extra == 'monitoring'
 Provides-Extra: postgresql
 Requires-Dist: SQLAlchemy <3 ; extra == 'postgresql'
 Requires-Dist: psycopg2 ; extra == 'postgresql'
@@ -79,7 +80,7 @@ Kinto
 |coc| |gitter| |readthedocs| |pypi| |ci| |main-coverage|
 
 .. |coc| image:: https://img.shields.io/badge/%E2%9D%A4-code%20of%20conduct-blue.svg
-    :target: https://github.com/Kinto/kinto/blob/main/CODE_OF_CONDUCT.md
+    :target: https://github.com/Kinto/kinto/blob/main/.github/CODE_OF_CONDUCT.md
     :alt: Code of conduct
 
 .. |gitter| image:: https://badges.gitter.im/Kinto/kinto.svg

{kinto-18.1.1.dist-info → kinto-19.2.0.dist-info}/RECORD

@@ -6,18 +6,19 @@ kinto/schema_validation.py,sha256=mtAmnl5HwiUsjS2gU8MKH4lkZ1380A5wZht-w9s5X7M,53
 kinto/scripts.py,sha256=oM8ggBofYVoVhxrbdfzwIO0AOwR6Z2NJ2RqH9op1_lg,1370
 kinto/config/__init__.py,sha256=av8W0utmjheueFqrjTYEDk_vbpm3XYdHcqv5lppNR4k,2131
 kinto/config/kinto.tpl,sha256=kdA2RuR8gEpZGJp6VkKqMShQ0CfHDM0gjUttSPeaT7s,8753
-kinto/core/__init__.py,sha256=OpIPeRMatnxWqFUOB_ho4Tar7zfFX-I6URf0T13JP7g,8125
+kinto/core/__init__.py,sha256=vaCYHKF-OjmBsl-Q4jgA_BbnUn_cvfH3p6-UDe03qIM,8126
 kinto/core/authentication.py,sha256=HLA0kREC3GMEsrIsHsQYjVNztYfAF01kb8-pLboByFs,1527
 kinto/core/authorization.py,sha256=GywY25KEzuSSAI709dFHDfdLnKxy3SLEYGwW5FkQ7Qc,13212
 kinto/core/decorators.py,sha256=3SAPWXlyPNUSICZ9mz04bcN-UdbnDuFOtU0bQHHzLis,2178
 kinto/core/errors.py,sha256=fxOLR4lImwHp26hhxxaqk6uW0U7v2Jb6f4sgAcRPRu8,8854
 kinto/core/events.py,sha256=SYpXgKMtVjiD9fwYJA2Omdom9yA3nBqi9btdvU1I_nc,10345
-kinto/core/initialization.py,sha256=0JBlj3DfgVzlaFAEXSYjLqfGhmH_eOIlP1MqtMcq8M8,23442
+kinto/core/initialization.py,sha256=Z4yNDw0qzernxSzMI7t_KkONblh9oe_01r_8GeS0XNI,24572
+kinto/core/metrics.py,sha256=IWNh1p46sNUWJJu1lJgILoyUTXRw1eM3KRjsvkyOh88,1766
 kinto/core/openapi.py,sha256=bPHRCVmdZsJCsKm8BId02Q2Wz8etF1xL7Z9rU9JDx5k,3855
 kinto/core/schema.py,sha256=d5L5TQynRYJPkZ8Mu2X7F72xEh6SKDbrHK1CNTdOf2E,3646
 kinto/core/scripts.py,sha256=5HSq5QAuin7HuU6icNYkPisny-4JpcdBvjf8X4JImrE,978
-kinto/core/statsd.py,sha256=Z2TDo31gPqIwcyFC3Z_qZM8fPy9PSRmcwEMhAtiZMGM,1942
-kinto/core/testing.py,sha256=K77Lxfp6naMXGqiXlajglO-QA0SrZQ37RUgsi1jLb8k,5748
+kinto/core/statsd.py,sha256=2f4s2opiHVdrA02ZlBa5pxIHaEjPuG8tdVLsmdII27s,64
+kinto/core/testing.py,sha256=6iKT2q5f1suIavYGdM7lkqbqaIG5h38iM5S6jKU4AQI,5897
 kinto/core/utils.py,sha256=jfP6k63xHNAzbhNkDd9V8YlMzblTyh-ENScETfdW-k0,16772
 kinto/core/cache/__init__.py,sha256=NJT_39WFTuUd-OHuVqgoQTQUYv5zS9PIc3W_Kq9tabc,2726
 kinto/core/cache/memcached.py,sha256=WuYyq6-QykRNryLA_bKdeGAY_Hvwq0c1ejS_8G94cY4,2914
@@ -77,6 +78,8 @@ kinto/core/views/openapi.py,sha256=YZ7akBoMqmiu0b4AOxlupHU01_kQEHtmzPxJq_iS79Y,9
 kinto/core/views/version.py,sha256=-m5G_o0oHTpCgrtfFrHFve6Zqw_gs_szT0Bd8jnNmD4,1419
 kinto/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kinto/plugins/flush.py,sha256=HnKJ6-oDo-NMSjdZskqZ09aMnFM-LJHW9vIw4VIyvcI,812
+kinto/plugins/prometheus.py,sha256=ASRMTM_u5oBqHTI4dd5zZUggOCwzcamRAq684BC16TY,4187
+kinto/plugins/statsd.py,sha256=demSOsXdR90T7oDTiYXChlxYICpt4-FVNZHebkH5oo8,1728
 kinto/plugins/accounts/__init__.py,sha256=LUyPfIWIn-HtpmyKO8wAxY9oFsgeYgbMHFmNOcns7rY,4365
 kinto/plugins/accounts/authentication.py,sha256=h7l_KezC8os4sKN1bz3RKEwXwYTYAs21DRzzU9na_U0,3742
 kinto/plugins/accounts/mails.py,sha256=vfb80INjDIJqC1JkPhcwGXlVWjvXhazxA_pnckmOOdo,3481
@@ -104,13 +107,13 @@ kinto/plugins/admin/build/assets/sql-3IaSLchm.js,sha256=V0dNMfaDvdWL9bgdkSTzMjoG
 kinto/plugins/admin/build/assets/ttcn-cfg-9oMIyPXS.js,sha256=8Tr33uTvYVq0BFJHVx62H2FtUMgfuLHjm0GqnqoFjDc,4117
 kinto/plugins/admin/public/help.html,sha256=1hol7z5Sv0Xn3mYyEfPQWFOsrR24htlKhmnGA3rH8fs,958
 kinto/plugins/default_bucket/__init__.py,sha256=Q0frXXJPzFqoPCOjK5OpJZhaz5nCAeR2KwKAP7ltW_U,7287
-kinto/plugins/history/__init__.py,sha256=xlti7gR4NojR8hIb24is0iVf0QJD645PPkVEQpsQl2w,1096
+kinto/plugins/history/__init__.py,sha256=s-RMNWaZlmBNd4sNsgJ-hDvMW4pPKUZ-sdZYubb0Kdo,1015
 kinto/plugins/history/listener.py,sha256=Tq5ZHpIOIzQs9yPXA1exEftPoYCuFQJvgxbaIb6XBrM,5033
 kinto/plugins/history/views.py,sha256=NoBP-S7epeH5TLZZbIqfBmwMA2KaWmxP7lqPAS11BTU,2293
 kinto/plugins/openid/__init__.py,sha256=1Iv5SCa6vwEvoJkmGd45-TYm_mxz2okFj6u2VTNuVrk,4863
 kinto/plugins/openid/utils.py,sha256=n3KGS-ogXR2sg6j4QtdPe_DtEsqD7AGVT2K7vhl8yE8,273
 kinto/plugins/openid/views.py,sha256=RVUlS_Ov26NM8SFlrIlpm7ev9OuaMlJTtPA6pUi6ngk,6508
-kinto/plugins/quotas/__init__.py,sha256=g_ar8oHXnD3pIifgQoHkcTMNepDvCZ65SfpGwXIyTlU,697
+kinto/plugins/quotas/__init__.py,sha256=itmoP8y4puYYC5CPZAPHhnZ2PXT7PlsAKrNVd0zn4EI,616
 kinto/plugins/quotas/listener.py,sha256=WKKaCNRJw8XoIfnJb3S0ogYhzAo28RcfLE-MzP6Cs2U,8564
 kinto/plugins/quotas/scripts.py,sha256=a3KuzUwtCp_yu78yqr3XdbaHvZyBcUy6o_keNtsuU-M,2941
 kinto/plugins/quotas/utils.py,sha256=BE5bBPrG0BV9Qbcv6-r8WsV7KC6aIJlFeOR4O5tS248,232
@@ -122,9 +125,9 @@ kinto/views/contribute.py,sha256=NEDr2g1HhVwcMBg0qHEZDmWVJ1V31WsM8cRs0Vm6hfc,118
 kinto/views/groups.py,sha256=jOq5fX0-4lwZE8k1q5HME2tU7x9052rtBPF7YqcJ-Qg,3181
 kinto/views/permissions.py,sha256=F0_eKx201WyLonXJ5vLdGKa9RcFKjvAihrEEhU1JuLw,9069
 kinto/views/records.py,sha256=lYfACW2L8qcQoyYBD5IX-fTPjFWmGp7GjHq_U4InlyE,5037
-kinto-18.1.1.dist-info/LICENSE,sha256=oNEIMTuTJzppR5ZEyi86yvvtSagveMYXTYFn56zF0Uk,561
-kinto-18.1.1.dist-info/METADATA,sha256=0XhfmFvg30AjAaNqSkI2hQMLW1TAdSF_Pd5SeT-65aY,8812
-kinto-18.1.1.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-kinto-18.1.1.dist-info/entry_points.txt,sha256=3KlqBWPKY81mrCe_oX0I5s1cRO7Q53nCLbnVr5P9LH4,85
-kinto-18.1.1.dist-info/top_level.txt,sha256=EG_YmbZL6FAug9VwopG7JtF9SvH_r0DEnFp-3twPPys,6
-kinto-18.1.1.dist-info/RECORD,,
+kinto-19.2.0.dist-info/LICENSE,sha256=oNEIMTuTJzppR5ZEyi86yvvtSagveMYXTYFn56zF0Uk,561
+kinto-19.2.0.dist-info/METADATA,sha256=vRqlFZo0PI2sxAdV3dN9iX7XX52OXJRkbTtYcCZuwAQ,8877
+kinto-19.2.0.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+kinto-19.2.0.dist-info/entry_points.txt,sha256=3KlqBWPKY81mrCe_oX0I5s1cRO7Q53nCLbnVr5P9LH4,85
+kinto-19.2.0.dist-info/top_level.txt,sha256=EG_YmbZL6FAug9VwopG7JtF9SvH_r0DEnFp-3twPPys,6
+kinto-19.2.0.dist-info/RECORD,,

{kinto-18.1.1.dist-info → kinto-19.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any