kinto 21.1.1__tar.gz → 23.0.0__tar.gz

{kinto-21.1.1 → kinto-23.0.0}/.github/workflows/test.yml

@@ -190,6 +190,8 @@ jobs:
           context: .
 
       - name: Run container
+        env:
+          PROMETHEUS_MULTIPROC_DIR: /tmp/metrics
         run: |
           docker run --net=host --detach --rm \
             -p 8888:8888 \

{kinto-21.1.1 → kinto-23.0.0}/Makefile

@@ -1,43 +1,30 @@
+VENV ?= .venv
+PYTHON := $(VENV)/bin/python3
+SPHINX_BUILDDIR ?= docs/_build
+
 SERVER_CONFIG = config/kinto.ini
+NAME := kinto
+SOURCE := $(shell git config remote.origin.url | sed -e 's|git@|https://|g' | sed -e 's|github.com:|github.com/|g')
+VERSION := $(shell git describe --always --tag)
+COMMIT := $(shell git log --pretty=format:'%H' -n 1)
+
+.IGNORE: clean
 
-SPHINX_BUILDDIR := $(shell echo $${SPHINX_BUILDDIR-docs/_build})
-VENV := $(shell echo $${VIRTUAL_ENV-.venv})
-PYTHON = $(VENV)/bin/python3
 DEV_STAMP = $(VENV)/.dev_env_installed.stamp
 DOC_STAMP = $(VENV)/.doc_env_installed.stamp
 INSTALL_STAMP = $(VENV)/.install.stamp
-TEMPDIR := $(shell mktemp -du)
-
-.IGNORE: clean distclean maintainer-clean
-.PHONY: all install tests
-
-OBJECTS = .venv .coverage
+OBJECTS = .venv .coverage .pytest_cache/ .ruff_cache/ $(INSTALL_STAMP) $(DEV_STAMP) $(DOC_STAMP)
+.DEFAULT_GOAL := help
 
 help:
-	@echo "Please use 'make <target>' where <target> is one of"
-	@echo "  format                      reformat code"
-	@echo "  install                     install dependencies and prepare environment"
-	@echo "  install-monitoring          enable monitoring features like StatsD and Newrelic"
-	@echo "  install-postgres            install postgresql support"
-	@echo "  install-dev                 install dependencies and everything needed to run tests"
-	@echo "  pull-kinto-admin            pull the Kinto admin UI plugin (requires npm)"
-	@echo "  serve                       start the kinto server on default port"
-	@echo "  migrate                     run the kinto migrations"
-	@echo "  lint                        run the code linters"
-	@echo "  tests                       run all the tests with all the supported python interpreters (same as CI)"
-	@echo "  test-deps                   pulls and runs docker postgres and memcached containers for tests"
-	@echo "  tdd                         run pytest-watch to rerun tests automatically on changes for tdd"
-	@echo "  tests-once  	               only run the tests once with the default python interpreter"
-	@echo "  functional                  run functional test against a real kinto"
-	@echo "  browser-test                run browser test against a real kinto"
-	@echo "  clean                       remove *.pyc files and __pycache__ directory"
-	@echo "  distclean                   remove *.egg-info files and *.egg, build and dist directories"
-	@echo "  maintainer-clean            remove the .venv directory"
-	@echo "  docs                        build the docs"
-	@echo "Check the Makefile to know exactly what each target is doing."
+	@echo "Please use 'make <target>' where <target> is one of the following commands.\n"
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' Makefile | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+	@echo "\nCheck the Makefile to know exactly what each target is doing."
 
+.PHONY: all
 all: install
-install: $(INSTALL_STAMP)
+
+install: $(INSTALL_STAMP) ## install dependencies and prepare environment
 $(INSTALL_STAMP): $(PYTHON) constraints.txt pyproject.toml
 	$(VENV)/bin/pip install -U pip
 	$(VENV)/bin/pip install -Ue . -c constraints.txt
@@ -46,21 +33,21 @@ $(INSTALL_STAMP): $(PYTHON) constraints.txt pyproject.toml
 $(PYTHON):
 	python3 -m venv $(VENV)
 
-install-monitoring: $(INSTALL_STAMP) $(DEV_STAMP)
+install-monitoring: $(INSTALL_STAMP) $(DEV_STAMP)  ## enable monitoring features like Prometheus and Newrelic
 	$(VENV)/bin/pip install -Ue ".[monitoring]" -c constraints.txt
 
-install-postgres: $(INSTALL_STAMP) $(DEV_STAMP)
+install-postgres: $(INSTALL_STAMP) $(DEV_STAMP) ## install postgresql support
 	$(VENV)/bin/pip install -Ue ".[postgresql]" -c constraints.txt
 
-install-memcached: $(INSTALL_STAMP) $(DEV_STAMP)
+install-memcached: $(INSTALL_STAMP) $(DEV_STAMP) ## install memcached support
 	$(VENV)/bin/pip install -Ue ".[memcached]" -c constraints.txt
 
-install-dev: $(INSTALL_STAMP) $(DEV_STAMP)
+install-dev: $(INSTALL_STAMP) $(DEV_STAMP) ## install dependencies and everything needed to run tests
 $(DEV_STAMP): $(PYTHON) constraints.txt
-	$(VENV)/bin/pip install -Ue ".[dev,test]" -c constraints.txt
+	$(VENV)/bin/pip install -Ue ".[dev,test,monitoring,postgresql,memcached]" -c constraints.txt
 	touch $(DEV_STAMP)
 
-install-docs: $(DOC_STAMP)
+install-docs: $(DOC_STAMP) ## install dependencies to build the docs
 $(DOC_STAMP): $(PYTHON) docs/requirements.txt
 	$(VENV)/bin/pip install -r docs/requirements.txt
 	touch $(DOC_STAMP)
@@ -68,33 +55,36 @@ $(DOC_STAMP): $(PYTHON) docs/requirements.txt
 constraints.txt: constraints.in
 	pip-compile -o constraints.txt constraints.in
 
-pull-kinto-admin:
+pull-kinto-admin: kinto/plugins/admin/build ## pull the Kinto admin UI plugin
+kinto/plugins/admin/build:
 	scripts/pull-kinto-admin.sh
 
 $(SERVER_CONFIG):
 	$(VENV)/bin/kinto init --ini $(SERVER_CONFIG)
 
-NAME := kinto
-SOURCE := $(shell git config remote.origin.url | sed -e 's|git@|https://|g' | sed -e 's|github.com:|github.com/|g')
-VERSION := $(shell git describe --always --tag)
-COMMIT := $(shell git log --pretty=format:'%H' -n 1)
-version-file:
+version-file: version.json
+version.json:
 	echo '{"name":"$(NAME)","version":"$(VERSION)","source":"$(SOURCE)","commit":"$(COMMIT)"}' > version.json
 
-serve: install-dev $(SERVER_CONFIG) migrate version-file
+.PHONY: serve
+serve: install-dev $(SERVER_CONFIG) migrate version-file  ## start the kinto server on default port
 	$(VENV)/bin/kinto start --ini $(SERVER_CONFIG) --reload
 
+.PHONY: migrate
 migrate: install $(SERVER_CONFIG)
 	$(VENV)/bin/kinto migrate --ini $(SERVER_CONFIG)
 
-test: tests
+.PHONY: test
+test: tests ## run all the tests with all the supported python interpreters (same as CI)
+.PHONY: test-once
 tests-once: tests
-tests: install-postgres install-monitoring install-memcached version-file install-dev
+.PHONY: tests
+tests: version-file install-dev
 	$(VENV)/bin/py.test --cov-config pyproject.toml --cov-report term-missing --cov-fail-under 100 --cov kinto
-
+.PHONY: tests-raw
 tests-raw: version-file install-dev
 	$(VENV)/bin/py.test
-
+.PHONY: test-deps
 test-deps:
 	docker pull memcached
 	docker pull postgres
@@ -103,53 +93,55 @@ test-deps:
 	sleep 2
 	PGPASSWORD=postgres psql -c "CREATE DATABASE testdb ENCODING 'UTF8' TEMPLATE template0;" -U postgres -h localhost
 
-lint: install-dev
+.PHONY: lint
+lint: install-dev ## run the code linters
 	$(VENV)/bin/ruff check kinto tests docs/conf.py
 	$(VENV)/bin/ruff format --check kinto tests docs/conf.py
 
-format: install-dev
+.PHONY: format
+format: install-dev ## reformat code
 	$(VENV)/bin/ruff check --fix kinto tests docs/conf.py
 	$(VENV)/bin/ruff format kinto tests docs/conf.py
 
-tdd: install-dev
+.PHONY: tdd
+tdd: install-dev ## run pytest-watch to rerun tests automatically on changes for tdd
 	$(VENV)/bin/ptw --runner $(VENV)/bin/py.test
 
 need-kinto-running:
 	@curl http://localhost:8888/v0/ 2>/dev/null 1>&2 || (echo "Run 'make runkinto' before starting tests." && exit 1)
 
-runkinto: install-dev
+.PHONY: runkinto
+runkinto: install-dev ## run a kinto server
 	$(VENV)/bin/kinto migrate --ini tests/functional.ini
-	$(VENV)/bin/kinto start --ini tests/functional.ini
+	PROMETHEUS_MULTIPROC_DIR=/tmp/metrics KINTO_INI=tests/functional.ini $(VENV)/bin/uwsgi --http :8888 --ini tests/functional.ini
 
-functional: install-dev need-kinto-running
+.PHONY: functional
+functional: install-dev need-kinto-running ## run functional tests against a real kinto
 	$(VENV)/bin/py.test tests/functional.py
 
-browser-test: need-kinto-running
+.PHONY: browser-test
+browser-test: need-kinto-running ## run browser tests against a real kinto
 	$(VENV)/bin/playwright install firefox
 	$(VENV)/bin/py.test tests/browser.py
 
-clean:
-	find . -name '*.pyc' -delete
+clean: ## remove built files and start fresh
+	rm -fr $(OBJECTS)
 	find . -name '__pycache__' -type d | xargs rm -fr
 	rm -fr docs/_build/
+	rm -fr kinto/plugins/admin/build/ kinto/plugins/admin/node_modules/
 	docker rm -f kinto-memcached || echo ""
 	docker rm -f kinto-postgres || echo ""
 
-distclean: clean
-	rm -fr *.egg *.egg-info/ dist/ build/
-
-maintainer-clean: distclean
-	rm -fr .venv/ kinto/plugins/admin/build/ kinto/plugins/admin/node_modules/
-
-docs: install-docs
+docs: install-docs ## build the docs
 	$(VENV)/bin/sphinx-build -a -W -n -b html -d $(SPHINX_BUILDDIR)/doctrees docs $(SPHINX_BUILDDIR)/html
 	@echo
 	@echo "Build finished. The HTML pages are in $(SPHINX_BUILDDIR)/html/index.html"
 
 .PHONY: build
-build:
+build: ## build the docker image
 	docker build --build-arg="KINTO_VERSION=$(shell git describe --abbrev=0)" --pull -t kinto/kinto-server:latest .
 
-test-description: install-dev
+.PHONY: test-description
+test-description: install-dev ## test the built wheel metadata
 	$(VENV)/bin/python -m build
 	$(VENV)/bin/twine check dist/*.whl

{kinto-21.1.1 → kinto-23.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinto
-Version: 21.1.1
+Version: 23.0.0
 Summary: Kinto Web Service - Store, Sync, Share, and Self-Host.
 Author-email: Mozilla Services <developers@kinto-storage.org>
 License: Copyright 2012 - Mozilla Foundation
@@ -70,6 +70,7 @@ Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: twine; extra == "dev"
+Requires-Dist: uwsgi; extra == "dev"
 Dynamic: license-file
 
 Kinto

{kinto-21.1.1 → kinto-23.0.0}/constraints.txt

@@ -73,7 +73,7 @@ markupsafe==2.1.4
     # via werkzeug
 msgpack==1.0.7
     # via bravado-core
-newrelic==10.9.0
+newrelic==10.11.0
     # via -r constraints.in
 packaging==23.2
     # via
@@ -88,7 +88,7 @@ plaster==1.1.2
     #   pyramid
 plaster-pastedeploy==1.0.1
     # via pyramid
-playwright==1.51.0
+playwright==1.52.0
     # via -r constraints.in
 pluggy==1.5.0
     # via pytest
@@ -96,7 +96,7 @@ prometheus-client==0.21.1
     # via -r constraints.in
 psycopg2-binary==2.9.10
     # via -r constraints.in
-pyee==12.0.0
+pyee==13.0.0
     # via playwright
 pyproject-hooks==1.0.0
     # via build
@@ -149,7 +149,7 @@ rpds-py==0.17.1
     # via
     #   jsonschema
     #   referencing
-ruff==0.11.6
+ruff==0.11.8
     # via -r constraints.in
 sentry-sdk==2.8.0
     # via -r constraints.in

{kinto-21.1.1 → kinto-23.0.0}/docs/community.rst

@@ -244,13 +244,7 @@ In another terminal, run the end-to-end tests with:
 Cleaning your environment
 -------------------------
 
-There are three levels of cleaning your environment:
-
- - ``make clean`` will remove ``*.pyc`` files and ``__pycache__`` directory.
- - ``make distclean`` will also remove ``*.egg-info`` files and ``*.egg``,
-   ``build`` and ``dist`` directories.
- - ``make maintainer-clean`` will also remove the ``.venv`` directory.
-
+ - ``make clean``
 
 How to release
 ==============

{kinto-21.1.1 → kinto-23.0.0}/docs/configuration/settings.rst

@@ -516,8 +516,17 @@ Prometheus metrics can be enabled with (disabled by default):
     # Expose metrics created time (default: true)
     # kinto.prometheus_created_metrics_enabled = false
 
-    # Exclude certain labels to reduce cardinality (default: none)
-    # kinto.prometheus_exclude_labels = record_id group_id
+    # Control cardinality when URL fields become labels (default: bucket_id collection_id group_id record_id)
+    # kinto.metrics_matchdict_fields = bucket_id collection_id
+
+    # Disable default metrics that are not useful in your use-case
+    # kinto.disabled_metrics = request_duration_seconds
+    #                          authentication_basicauth_seconds
+    #                          backend_permission_seconds
+    #                          backend_cache_seconds
+
+    # Control duration buckets in seconds (global for all histograms)
+    # kinto.prometheus_histogram_buckets = 0.005 0.1 1 Inf
 
 Metrics can then be crawled from the ``/__metrics__`` endpoint.
 

{kinto-21.1.1 → kinto-23.0.0}/kinto/core/initialization.py

@@ -510,17 +510,16 @@ def setup_metrics(config):
         request_labels = [
             ("method", request.method.lower()),
             ("endpoint", endpoint),
-            ("status", str(status)),
         ] + metrics_matchdict_labels
 
         # Count served requests.
-        metrics_service.count("request_summary", unique=request_labels)
+        metrics_service.count("request_summary", unique=request_labels + [("status", str(status))])
 
         try:
             current = utils.msec_time()
             duration = current - request._received_at
             metrics_service.timer(
-                "request_duration",
+                "request_duration_seconds",
                 value=duration,
                 labels=request_labels,
             )

{kinto-21.1.1 → kinto-23.0.0}/kinto/core/metrics.py

@@ -13,7 +13,7 @@ class IMetricsService(Interface):
 
     def timer(key):
         """
-        Watch execution time.
+        Watch execution time in seconds.
         """
 
     def observe(self, key, value, labels=[]):
@@ -68,9 +68,9 @@ def watch_execution_time(metrics_service, obj, prefix="", classname=None):
         method = getattr(obj, name)
         is_method = isinstance(method, types.MethodType)
         if not name.startswith("_") and is_method:
-            statsd_key = f"{prefix}.{classname}"
+            metric_name = f"{prefix}.{classname}.seconds"
             labels = [("method", name)]
-            decorated_method = metrics_service.timer(statsd_key, labels=labels)(method)
+            decorated_method = metrics_service.timer(metric_name, labels=labels)(method)
             setattr(obj, name, decorated_method)
 
 
@@ -88,7 +88,7 @@ def listener_with_timer(config, key, func):
             # 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):
+        with metrics_service.timer(key + ".seconds" if not key.endswith(".seconds") else key):
             return func(*args, **kwargs)
 
     return wrapped

{kinto-21.1.1 → kinto-23.0.0}/kinto/plugins/prometheus.py

@@ -53,7 +53,7 @@ class Timer:
     """
     A decorator to time the execution of a function. It will use the
     `prometheus_client.Histogram` to record the time taken by the function
-    in milliseconds. The histogram is passed as an argument to the
+    in seconds. The histogram is passed as an argument to the
     constructor.
 
     Main limitation: it does not support `labels` on the decorator.
@@ -78,8 +78,8 @@ class Timer:
             try:
                 return f(*args, **kwargs)
             finally:
-                dt_ms = 1000.0 * (time_now() - start_time)
-                self.histogram.observe(dt_ms)
+                dt_sec = time_now() - start_time
+                self.histogram.observe(dt_sec)
 
         return _wrapped
 
@@ -96,14 +96,22 @@ class Timer:
     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.histogram.observe(dt_ms)
+        dt_sec = time_now() - self._start_time
+        self.histogram.observe(dt_sec)
+        return self
+
+
+class NoOpHistogram:  # pragma: no cover
+    def observe(self, value):
+        pass
+
+    def labels(self, *args):
         return self
 
 
 @implementer(metrics.IMetricsService)
 class PrometheusService:
-    def __init__(self, prefix="", exclude_labels=None):
+    def __init__(self, prefix="", disabled_metrics=[], histogram_buckets=None):
         prefix_clean = ""
         if prefix:
             # In GCP Console, the metrics are grouped by the first
@@ -112,26 +120,23 @@ class PrometheusService:
             # (eg. `remote-settings` -> `remotesettings_`, `kinto_` -> `kinto_`)
             prefix_clean = _fix_metric_name(prefix).replace("_", "") + "_"
         self.prefix = prefix_clean.lower()
-        self.exclude_labels = exclude_labels or []
-
-    def _exclude_labels(self, labels):
-        return [
-            (label_name, label_value)
-            for label_name, label_value in labels
-            if label_name not in self.exclude_labels
-        ]
+        self.disabled_metrics = [m.replace(self.prefix, "") for m in disabled_metrics]
+        self.histogram_buckets = histogram_buckets
 
     def timer(self, key, value=None, labels=[]):
         global _METRICS
-        key = self.prefix + key
-        labels = self._exclude_labels(labels)
 
+        key = _fix_metric_name(key)
+        if key in self.disabled_metrics:
+            return Timer(histogram=NoOpHistogram())
+
+        key = self.prefix + key
         if key not in _METRICS:
             _METRICS[key] = prometheus_module.Histogram(
-                _fix_metric_name(key),
+                key,
                 f"Histogram of {key}",
-                registry=get_registry(),
                 labelnames=[label_name for label_name, _ in labels],
+                buckets=self.histogram_buckets,
             )
 
         if not isinstance(_METRICS[key], prometheus_module.Histogram):
@@ -139,7 +144,7 @@ class PrometheusService:
                 f"Metric {key} already exists with different type ({_METRICS[key]})"
             )
 
-        timer = Timer(_METRICS[key])
+        timer = Timer(histogram=_METRICS[key])
         timer.set_labels(labels)
 
         if value is not None:
@@ -153,15 +158,17 @@ class PrometheusService:
 
     def observe(self, key, value, labels=[]):
         global _METRICS
-        key = self.prefix + key
-        labels = self._exclude_labels(labels)
 
+        key = _fix_metric_name(key)
+        if key in self.disabled_metrics:
+            return
+
+        key = self.prefix + key
         if key not in _METRICS:
             _METRICS[key] = prometheus_module.Summary(
-                _fix_metric_name(key),
+                key,
                 f"Summary of {key}",
                 labelnames=[label_name for label_name, _ in labels],
-                registry=get_registry(),
             )
 
         if not isinstance(_METRICS[key], prometheus_module.Summary):
@@ -177,10 +184,12 @@ class PrometheusService:
 
     def count(self, key, count=1, unique=None):
         global _METRICS
-        key = self.prefix + key
 
-        labels = []
+        key = _fix_metric_name(key)
+        if key in self.disabled_metrics:
+            return
 
+        labels = []
         if unique:
             if isinstance(unique, str):
                 warnings.warn(
@@ -195,17 +204,16 @@ class PrometheusService:
                 label_name, label_value = unique.rsplit(".", 1)
                 unique = [(label_name, label_value)]
 
-            unique = self._exclude_labels(unique)
             labels = [
                 (_fix_metric_name(label_name), label_value) for label_name, label_value in unique
             ]
 
+        key = self.prefix + key
         if key not in _METRICS:
             _METRICS[key] = prometheus_module.Counter(
-                _fix_metric_name(key),
+                key,
                 f"Counter of {key}",
                 labelnames=[label_name for label_name, _ in labels],
-                registry=get_registry(),
             )
 
         if not isinstance(_METRICS[key], prometheus_module.Counter):
@@ -234,6 +242,19 @@ def _reset_multiproc_folder_content():  # pragma: no cover
     os.makedirs(PROMETHEUS_MULTIPROC_DIR, exist_ok=True)
 
 
+def reset_registry():
+    # This is mainly useful in tests, where the plugin is included
+    # several times with different settings.
+    registry = get_registry()
+
+    for collector in _METRICS.values():
+        try:
+            registry.unregister(collector)
+        except KeyError:  # pragma: no cover
+            pass
+    _METRICS.clear()
+
+
 def includeme(config):
     if prometheus_module is None:
         error_msg = (
@@ -246,34 +267,34 @@ def includeme(config):
     if not asbool(settings.get("prometheus_created_metrics_enabled", True)):
         prometheus_module.disable_created_metrics()
 
+    prefix = settings.get("prometheus_prefix", settings["project_name"])
+    disabled_metrics = aslist(settings.get("prometheus_disabled_metrics", ""))
+
+    # Default buckets for histogram metrics are (.005, .01, .025, .05, .075, .1, .25, .5, .75, 1.0, 2.5, 5.0, 7.5, 10.0, INF)
+    # we reduce it from 15 to 8 values by default here, and let the user override it if needed.
+    histogram_buckets_values = aslist(
+        settings.get(
+            "prometheus_histogram_buckets", "0.01 0.05 0.1 0.5 1.0 3.0 6.0 Inf"
+        )  # Note: Inf is added by default.
+    )
+    histogram_buckets = [float(x) for x in histogram_buckets_values]
+    # Note: we don't need to check for INF or list size, it's done in the prometheus_client library.
+
+    get_registry()  # Initialize the registry.
+
+    metrics_impl = PrometheusService(
+        prefix=prefix, disabled_metrics=disabled_metrics, histogram_buckets=histogram_buckets
+    )
+
     config.add_api_capability(
         "prometheus",
         description="Prometheus metrics.",
         url="https://github.com/Kinto/kinto/",
+        prefix=metrics_impl.prefix,
+        disabled_metrics=disabled_metrics,
     )
 
     config.add_route("prometheus_metrics", "/__metrics__")
     config.add_view(metrics_view, route_name="prometheus_metrics")
 
-    # Reinitialize the registry on initialization.
-    # This is mainly useful in tests, where the plugin is included
-    # several times with different settings.
-    registry = get_registry()
-
-    for collector in _METRICS.values():
-        try:
-            registry.unregister(collector)
-        except KeyError:  # pragma: no cover
-            pass
-    _METRICS.clear()
-
-    prefix = settings.get("prometheus_prefix", settings["project_name"])
-
-    # If we want to reduce the metrics cardinality, we can exclude certain
-    # labels (eg. records_id). This way all metrics will be grouped by the
-    # remaining labels.
-    exclude_labels = aslist(settings.get("prometheus_exclude_labels", ""))
-
-    config.registry.registerUtility(
-        PrometheusService(prefix=prefix, exclude_labels=exclude_labels), metrics.IMetricsService
-    )
+    config.registry.registerUtility(metrics_impl, metrics.IMetricsService)

{kinto-21.1.1 → kinto-23.0.0}/kinto.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinto
-Version: 21.1.1
+Version: 23.0.0
 Summary: Kinto Web Service - Store, Sync, Share, and Self-Host.
 Author-email: Mozilla Services <developers@kinto-storage.org>
 License: Copyright 2012 - Mozilla Foundation
@@ -70,6 +70,7 @@ Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: twine; extra == "dev"
+Requires-Dist: uwsgi; extra == "dev"
 Dynamic: license-file
 
 Kinto

{kinto-21.1.1 → kinto-23.0.0}/kinto.egg-info/requires.txt

@@ -17,6 +17,7 @@ python-rapidjson
 build
 ruff
 twine
+uwsgi
 
 [memcached]
 python-memcached

{kinto-21.1.1 → kinto-23.0.0}/pyproject.toml

@@ -92,6 +92,7 @@ dev = [
     "build",
     "ruff",
     "twine",
+    "uwsgi",
 ]
 
 [tool.pip-tools]

{kinto-21.1.1 → kinto-23.0.0}/tests/core/resource/test_events.py

@@ -511,7 +511,7 @@ class StatsDTest(BaseWebTest, unittest.TestCase):
         with mock.patch.object(metrics_client, "timing") as mocked:
             self.app.post_json(self.plural_url, {"data": {"name": "pouet"}}, headers=self.headers)
             timers = set(c[0][0] for c in mocked.call_args_list)
-            self.assertIn("listeners.test", timers)
+            self.assertIn("listeners.test.seconds", timers)
 
 
 @skip_if_no_prometheus
@@ -529,4 +529,4 @@ class PrometheusTest(BaseWebTest, unittest.TestCase):
         self.app.post_json(self.plural_url, {"data": {"name": "pouet"}}, headers=self.headers)
 
         resp = self.app.get("/__metrics__")
-        self.assertIn("listeners_test_count 1.0", resp.text)
+        self.assertIn("listeners_test_seconds_count 1.0", resp.text)

{kinto-21.1.1 → kinto-23.0.0}/tests/core/test_initialization.py

@@ -433,7 +433,7 @@ class MetricsConfigurationTest(unittest.TestCase):
         self.mocked().observe.assert_any_call(
             "request_size",
             len("{}"),
-            labels=[("method", "get"), ("endpoint", "heartbeat"), ("status", "200")],
+            labels=[("method", "get"), ("endpoint", "heartbeat")],
         )
 
     def test_statsd_observe_request_duration(self):
@@ -441,9 +441,9 @@ class MetricsConfigurationTest(unittest.TestCase):
         app = webtest.TestApp(self.config.make_wsgi_app())
         app.get("/v0/__heartbeat__")
         self.mocked().timer.assert_any_call(
-            "request_duration",
+            "request_duration_seconds",
             value=mock.ANY,
-            labels=[("method", "get"), ("endpoint", "heartbeat"), ("status", "200")],
+            labels=[("method", "get"), ("endpoint", "heartbeat")],
         )
 
     def test_statsd_counts_unknown_urls(self):

{kinto-21.1.1 → kinto-23.0.0}/tests/core/test_metrics.py

@@ -25,7 +25,7 @@ class WatchExecutionTimeTest(unittest.TestCase):
     def test_public_methods_generates_statsd_calls(self):
         self.test_object.test_method()
         self.mocked.timer.assert_called_with(
-            "test.testedclass", labels=[("method", "test_method")]
+            "test.testedclass.seconds", labels=[("method", "test_method")]
         )
 
     def test_private_methods_does_not_generates_statsd_calls(self):
@@ -48,4 +48,4 @@ class ListenerWithTimerTest(unittest.TestCase):
         wrapped = metrics.listener_with_timer(self.config, "key", self.func)
 
         self.assertEqual(wrapped(42), 42)
-        self.config.registry.metrics.timer.assert_called_with("key")
+        self.config.registry.metrics.timer.assert_called_with("key.seconds")