kinto 22.0.0__tar.gz → 23.0.1__tar.gz

{kinto-22.0.0 → kinto-23.0.1}/.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-22.0.0 → kinto-23.0.1}/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-22.0.0 → kinto-23.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinto
-Version: 22.0.0
+Version: 23.0.1
 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-22.0.0 → kinto-23.0.1}/constraints.txt

@@ -149,7 +149,7 @@ rpds-py==0.17.1
     # via
     #   jsonschema
     #   referencing
-ruff==0.11.8
+ruff==0.11.9
     # via -r constraints.in
 sentry-sdk==2.8.0
     # via -r constraints.in

{kinto-22.0.0 → kinto-23.0.1}/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-22.0.0 → kinto-23.0.1}/docs/configuration/settings.rst

@@ -519,6 +519,15 @@ Prometheus metrics can be enabled with (disabled by default):
     # 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-22.0.0 → kinto-23.0.1}/docs/requirements.txt

@@ -2,7 +2,7 @@ Sphinx==8.2.3
 sphinx_rtd_theme==3.0.2
 docutils==0.20.1
 sphinxcontrib-httpdomain==1.8.1
-sphinx-github-changelog==1.4.0
+sphinx-github-changelog==1.7.1
 kinto
 mock==5.2.0
 webtest==3.0.4

{kinto-22.0.0 → kinto-23.0.1}/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
+            duration = (current - request._received_at) / 1000
             metrics_service.timer(
-                "request_duration",
+                "request_duration_seconds",
                 value=duration,
                 labels=request_labels,
             )

{kinto-22.0.0 → kinto-23.0.1}/kinto/plugins/prometheus.py

@@ -6,7 +6,7 @@ from time import perf_counter as time_now
 
 from pyramid.exceptions import ConfigurationError
 from pyramid.response import Response
-from pyramid.settings import asbool
+from pyramid.settings import asbool, aslist
 from zope.interface import implementer
 
 from kinto.core import metrics
@@ -101,9 +101,17 @@ class Timer:
         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=""):
+    def __init__(self, prefix="", disabled_metrics=[], histogram_buckets=None):
         prefix_clean = ""
         if prefix:
             # In GCP Console, the metrics are grouped by the first
@@ -112,17 +120,23 @@ class PrometheusService:
             # (eg. `remote-settings` -> `remotesettings_`, `kinto_` -> `kinto_`)
             prefix_clean = _fix_metric_name(prefix).replace("_", "") + "_"
         self.prefix = prefix_clean.lower()
+        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
 
+        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):
@@ -130,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:
@@ -144,14 +158,17 @@ class PrometheusService:
 
     def observe(self, key, value, labels=[]):
         global _METRICS
-        key = self.prefix + key
 
+        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):
@@ -167,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(
@@ -189,12 +208,12 @@ class PrometheusService:
                 (_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):
@@ -223,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 = (
@@ -235,27 +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"])
-
-    config.registry.registerUtility(PrometheusService(prefix=prefix), metrics.IMetricsService)
+    config.registry.registerUtility(metrics_impl, metrics.IMetricsService)

{kinto-22.0.0 → kinto-23.0.1}/kinto.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinto
-Version: 22.0.0
+Version: 23.0.1
 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-22.0.0 → kinto-23.0.1}/kinto.egg-info/requires.txt

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

{kinto-22.0.0 → kinto-23.0.1}/pyproject.toml

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

{kinto-22.0.0 → kinto-23.0.1}/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-22.0.0 → kinto-23.0.1}/tests/functional.ini

@@ -69,3 +69,10 @@ formatter = color
 
 [formatter_color]
 class = logging_color_formatter.ColorFormatter
+
+[uwsgi]
+wsgi-file = app.wsgi
+master = true
+module = kinto
+static-map = /attachments=/tmp/attachments
+processes = 4

{kinto-22.0.0 → kinto-23.0.1}/tests/functional.py

@@ -65,6 +65,17 @@ class FunctionalTest(unittest.TestCase):
         resp.raise_for_status()
         self.assertEqual(resp.json()["http_api_version"], HTTP_API_VERSION)
 
+    def test_prometheus_metrics_are_unique(self):
+        self.session.post(self.server_url, "{collection_url}")
+
+        resp = self.session.get(
+            urljoin(self.server_url, "/__metrics__"), headers={"Accept": "text/plain"}
+        )
+        resp.raise_for_status()
+
+        metrics = resp.text.splitlines()
+        self.assertEqual(len(metrics), len(set(metrics)))
+
     def test_user_default_bucket_tutorial(self):
         collection_id = "tasks-%s" % uuid.uuid4()
         collection_url = urljoin(

{kinto-22.0.0 → kinto-23.0.1}/tests/plugins/test_prometheus.py

@@ -27,6 +27,10 @@ class PrometheusMissing(unittest.TestCase):
 
 
 class PrometheusWebTest(support.BaseWebTest, unittest.TestCase):
+    def setUp(self):
+        super().setUp()
+        prometheus.reset_registry()
+
     @classmethod
     def get_app_settings(cls, extras=None):
         settings = super().get_app_settings(extras)
@@ -174,3 +178,46 @@ class PrometheusNoCreatedTest(PrometheusWebTest):
 
         self.assertIn("TYPE kintoprod_price summary", resp.text)
         self.assertNotIn("TYPE kintoprod_price_created summary", resp.text)
+
+
+@skip_if_no_prometheus
+class PrometheusDisabledMetricsTest(PrometheusWebTest):
+    @classmethod
+    def get_app_settings(cls, extras=None):
+        settings = super().get_app_settings(extras)
+        settings["prometheus_disabled_metrics"] = "kintoprod_price kintoprod_key func_latency"
+        return settings
+
+    def test_disabled_etrics_not_in_response(self):
+        self.app.app.registry.metrics.observe("price", 111)
+        self.app.app.registry.metrics.count("key")
+        self.app.app.registry.metrics.observe("size", 3.14, labels=[("endpoint", "/buckets")])
+        decorated = self.app.app.registry.metrics.timer("func.latency")(my_func)
+        decorated(1, 34)  # Call the function to trigger the timer and NoOpHistogram
+
+        resp = self.app.get("/__metrics__")
+
+        self.assertIn("TYPE kintoprod_size summary", resp.text)
+        self.assertNotIn("TYPE kintoprod_key counter", resp.text)
+        self.assertNotIn("TYPE kintoprod_price summary", resp.text)
+        self.assertNotIn("TYPE kintoprod_func_latency histogram", resp.text)
+
+
+@skip_if_no_prometheus
+class PrometheusCustomTest(PrometheusWebTest):
+    @classmethod
+    def get_app_settings(cls, extras=None):
+        settings = super().get_app_settings(extras)
+        settings["prometheus_histogram_buckets"] = "0.1 1 Inf"
+        return settings
+
+    def test_duration_metrics_only_contain_specified_buckets(self):
+        self.app.app.registry.metrics.timer("func")(my_func)
+        my_func(1, 34)
+
+        resp = self.app.get("/__metrics__")
+
+        self.assertEqual(resp.text.count("kintoprod_func_bucket"), 3)
+        self.assertIn('kintoprod_func_bucket{le="0.1"}', resp.text)
+        self.assertIn('kintoprod_func_bucket{le="1.0"}', resp.text)
+        self.assertIn('kintoprod_func_bucket{le="+Inf"}', resp.text)

{kinto-22.0.0 → kinto-23.0.1}/tests/test_views_metrics.py

@@ -33,22 +33,21 @@ class ViewsMetricsTest(BaseWebTest, unittest.TestCase):
         resp = self.app.get("/__metrics__")
 
         self.assertIn(
-            'request_size_sum{bucket_id="beers",collection_id="",endpoint="bucket-object",group_id="",method="put",record_id="",status="201"}',
+            'request_size_sum{bucket_id="beers",collection_id="",endpoint="bucket-object",group_id="",method="put",record_id=""}',
             resp.text,
         )
         self.assertIn(
-            'request_size_sum{bucket_id="beers",collection_id="",endpoint="group-object",group_id="amateurs",method="put",record_id="",status="201"}',
+            'request_size_sum{bucket_id="beers",collection_id="",endpoint="group-object",group_id="amateurs",method="put",record_id=""}',
             resp.text,
         )
         self.assertIn(
-            'request_summary_total{bucket_id="beers",collection_id="barley",endpoint="collection-object",group_id="",method="put",record_id="",status="201"}',
+            'request_duration_seconds_sum{bucket_id="beers",collection_id="barley",endpoint="record-object",group_id="",method="put",record_id="abc"}',
             resp.text,
         )
         self.assertIn(
-            'request_duration_sum{bucket_id="beers",collection_id="barley",endpoint="record-object",group_id="",method="put",record_id="abc",status="201"}',
+            'request_summary_total{bucket_id="beers",collection_id="barley",endpoint="collection-object",group_id="",method="put",record_id="",status="201"}',
             resp.text,
         )
-
         self.assertIn(
             'request_summary_total{bucket_id="",collection_id="",endpoint="bucket-plural",group_id="",method="get",record_id="",status="200"}',
             resp.text,