django-prometheus 1.2.0.dev101__py3-none-any.whl → 2.6.0.dev22__py3-none-any.whl

django_prometheus/__init__.py

@@ -10,13 +10,12 @@ from django_prometheus import middleware, models
 
 __all__ = ["middleware", "models", "pip_prometheus"]
 
-__version__ = '1.2.0.dev.101'
+__version__ = "2.6.0.dev22"
+
 
 # Import pip_prometheus to export the pip metrics automatically.
 try:
     import pip_prometheus
 except ImportError:
     # If people don't have pip, don't export anything.
-    pass
-
-default_app_config = "django_prometheus.apps.DjangoPrometheusConfig"
+    pass

django_prometheus/apps.py

@@ -1,6 +1,7 @@
-import django_prometheus
 from django.apps import AppConfig
 from django.conf import settings
+
+import django_prometheus
 from django_prometheus.exports import SetupPrometheusExportsFromConfig
 from django_prometheus.migrations import ExportMigrations
 
@@ -19,5 +20,5 @@ class DjangoPrometheusConfig(AppConfig):
         are usually short-lived), but can be useful for debugging.
         """
         SetupPrometheusExportsFromConfig()
-        if getattr(settings, "PROMETHEUS_EXPORT_MIGRATIONS", True):
+        if getattr(settings, "PROMETHEUS_EXPORT_MIGRATIONS", False):
             ExportMigrations()

django_prometheus/cache/backends/django_memcached_consul.py

@@ -1,6 +1,5 @@
-from __future__ import absolute_import
-
 from django_memcached_consul import memcached
+
 from django_prometheus.cache.metrics import (
     django_cache_get_total,
     django_cache_hits_total,
@@ -13,7 +12,7 @@ class MemcachedCache(memcached.MemcachedCache):
 
     def get(self, key, default=None, version=None):
         django_cache_get_total.labels(backend="django_memcached_consul").inc()
-        cached = super(MemcachedCache, self).get(key, default=None, version=version)
+        cached = super().get(key, default=None, version=version)
         if cached is not None:
             django_cache_hits_total.labels(backend="django_memcached_consul").inc()
         else:

django_prometheus/cache/backends/filebased.py

@@ -1,4 +1,5 @@
 from django.core.cache.backends import filebased
+
 from django_prometheus.cache.metrics import (
     django_cache_get_total,
     django_cache_hits_total,
@@ -11,7 +12,7 @@ class FileBasedCache(filebased.FileBasedCache):
 
     def get(self, key, default=None, version=None):
         django_cache_get_total.labels(backend="filebased").inc()
-        cached = super(FileBasedCache, self).get(key, default=None, version=version)
+        cached = super().get(key, default=None, version=version)
         if cached is not None:
             django_cache_hits_total.labels(backend="filebased").inc()
         else:

django_prometheus/cache/backends/locmem.py

@@ -1,4 +1,5 @@
 from django.core.cache.backends import locmem
+
 from django_prometheus.cache.metrics import (
     django_cache_get_total,
     django_cache_hits_total,
@@ -11,7 +12,7 @@ class LocMemCache(locmem.LocMemCache):
 
     def get(self, key, default=None, version=None):
         django_cache_get_total.labels(backend="locmem").inc()
-        cached = super(LocMemCache, self).get(key, default=None, version=version)
+        cached = super().get(key, default=None, version=version)
         if cached is not None:
             django_cache_hits_total.labels(backend="locmem").inc()
         else:

django_prometheus/cache/backends/memcached.py

@@ -1,4 +1,5 @@
 from django.core.cache.backends import memcached
+
 from django_prometheus.cache.metrics import (
     django_cache_get_total,
     django_cache_hits_total,
@@ -6,14 +7,21 @@ from django_prometheus.cache.metrics import (
 )
 
 
-class MemcachedCache(memcached.MemcachedCache):
-    """Inherit memcached to add metrics about hit/miss ratio"""
-
+class MemcachedPrometheusCacheMixin:
     def get(self, key, default=None, version=None):
         django_cache_get_total.labels(backend="memcached").inc()
-        cached = super(MemcachedCache, self).get(key, default=None, version=version)
+        cached = super().get(key, default=None, version=version)
         if cached is not None:
             django_cache_hits_total.labels(backend="memcached").inc()
-        else:
-            django_cache_misses_total.labels(backend="memcached").inc()
-        return cached or default
+            return cached
+
+        django_cache_misses_total.labels(backend="memcached").inc()
+        return default
+
+
+class PyLibMCCache(MemcachedPrometheusCacheMixin, memcached.PyLibMCCache):
+    """Inherit memcached to add metrics about hit/miss ratio"""
+
+
+class PyMemcacheCache(MemcachedPrometheusCacheMixin, memcached.PyMemcacheCache):
+    """Inherit memcached to add metrics about hit/miss ratio"""

django_prometheus/cache/backends/redis.py

@@ -1,10 +1,12 @@
+from django.core.cache.backends.redis import RedisCache as DjangoRedisCache
+from django_redis import cache, exceptions
+
 from django_prometheus.cache.metrics import (
     django_cache_get_fail_total,
     django_cache_get_total,
     django_cache_hits_total,
     django_cache_misses_total,
 )
-from django_redis import cache, exceptions
 
 
 class RedisCache(cache.RedisCache):
@@ -17,14 +19,29 @@ class RedisCache(cache.RedisCache):
             cached = self.client.get(key, default=None, version=version, client=client)
         except exceptions.ConnectionInterrupted as e:
             django_cache_get_fail_total.labels(backend="redis").inc()
-            if cache.DJANGO_REDIS_IGNORE_EXCEPTIONS or self._ignore_exceptions:
-                if cache.DJANGO_REDIS_LOG_IGNORED_EXCEPTIONS:
-                    cache.logger.error(str(e))
+            if self._ignore_exceptions:
+                if self._log_ignored_exceptions:
+                    self.logger.error(str(e))
                 return default
             raise
         else:
             if cached is not None:
                 django_cache_hits_total.labels(backend="redis").inc()
-            else:
-                django_cache_misses_total.labels(backend="redis").inc()
-            return cached or default
+                return cached
+            django_cache_misses_total.labels(backend="redis").inc()
+            return default
+
+
+class NativeRedisCache(DjangoRedisCache):
+    def get(self, key, default=None, version=None):
+        django_cache_get_total.labels(backend="native_redis").inc()
+        try:
+            result = super().get(key, default=None, version=version)
+        except Exception:
+            django_cache_get_fail_total.labels(backend="native_redis").inc()
+            raise
+        if result is not None:
+            django_cache_hits_total.labels(backend="native_redis").inc()
+            return result
+        django_cache_misses_total.labels(backend="native_redis").inc()
+        return default

django_prometheus/cache/metrics.py

@@ -1,14 +1,28 @@
 from prometheus_client import Counter
 
+from django_prometheus.conf import NAMESPACE
+
 django_cache_get_total = Counter(
-    "django_cache_get_total", "Total get requests on cache", ["backend"]
+    "django_cache_get_total",
+    "Total get requests on cache",
+    ["backend"],
+    namespace=NAMESPACE,
 )
 django_cache_hits_total = Counter(
-    "django_cache_get_hits_total", "Total hits on cache", ["backend"]
+    "django_cache_get_hits_total",
+    "Total hits on cache",
+    ["backend"],
+    namespace=NAMESPACE,
 )
 django_cache_misses_total = Counter(
-    "django_cache_get_misses_total", "Total misses on cache", ["backend"]
+    "django_cache_get_misses_total",
+    "Total misses on cache",
+    ["backend"],
+    namespace=NAMESPACE,
 )
 django_cache_get_fail_total = Counter(
-    "django_cache_get_fail_total", "Total get request failures by cache", ["backend"]
+    "django_cache_get_fail_total",
+    "Total get request failures by cache",
+    ["backend"],
+    namespace=NAMESPACE,
 )

django_prometheus/conf/__init__.py

@@ -0,0 +1,27 @@
+from django.conf import settings
+
+NAMESPACE = ""
+
+PROMETHEUS_LATENCY_BUCKETS = (
+    0.01,
+    0.025,
+    0.05,
+    0.075,
+    0.1,
+    0.25,
+    0.5,
+    0.75,
+    1.0,
+    2.5,
+    5.0,
+    7.5,
+    10.0,
+    25.0,
+    50.0,
+    75.0,
+    float("inf"),
+)
+
+if settings.configured:
+    NAMESPACE = getattr(settings, "PROMETHEUS_METRIC_NAMESPACE", NAMESPACE)
+    PROMETHEUS_LATENCY_BUCKETS = getattr(settings, "PROMETHEUS_LATENCY_BUCKETS", PROMETHEUS_LATENCY_BUCKETS)

django_prometheus/db/__init__.py

@@ -6,6 +6,7 @@ from django_prometheus.db.metrics import (
     errors_total,
     execute_many_total,
     execute_total,
+    query_duration_seconds,
 )
 
 __all__ = [
@@ -15,4 +16,5 @@ __all__ = [
     "errors_total",
     "execute_many_total",
     "execute_total",
+    "query_duration_seconds",
 ]

django_prometheus/db/backends/mysql/base.py

@@ -1,19 +1,16 @@
 from django.db.backends.mysql import base
+
 from django_prometheus.db.common import DatabaseWrapperMixin, ExportingCursorWrapper
 
 
 class DatabaseFeatures(base.DatabaseFeatures):
     """Our database has the exact same features as the base one."""
 
-    pass
-
 
 class DatabaseWrapper(DatabaseWrapperMixin, base.DatabaseWrapper):
     CURSOR_CLASS = base.CursorWrapper
 
     def create_cursor(self, name=None):
         cursor = self.connection.cursor()
-        CursorWrapper = ExportingCursorWrapper(
-            self.CURSOR_CLASS, self.alias, self.vendor
-        )
+        CursorWrapper = ExportingCursorWrapper(self.CURSOR_CLASS, self.alias, self.vendor)
         return CursorWrapper(cursor)

django_prometheus/db/backends/postgis/base.py

@@ -0,0 +1,16 @@
+from django.contrib.gis.db.backends.postgis import base
+
+from django_prometheus.db.common import DatabaseWrapperMixin, ExportingCursorWrapper
+
+
+class DatabaseWrapper(DatabaseWrapperMixin, base.DatabaseWrapper):
+    def get_connection_params(self):
+        conn_params = super().get_connection_params()
+        conn_params["cursor_factory"] = ExportingCursorWrapper(conn_params["cursor_factory"], self.alias, self.vendor)
+        return conn_params
+
+    def create_cursor(self, name=None):
+        # cursor_factory is set in get_connection_params() so psycopg already
+        # creates instrumented cursors. Delegate to Django's implementation to
+        # avoid the mixin's create_cursor which is incompatible with psycopg3.
+        return base.DatabaseWrapper.create_cursor(self, name=name)

django_prometheus/db/backends/postgresql/base.py

@@ -1,23 +1,16 @@
-import psycopg2.extensions
 from django.db.backends.postgresql import base
-from django_prometheus.db.common import DatabaseWrapperMixin, ExportingCursorWrapper
-
 
-class DatabaseFeatures(base.DatabaseFeatures):
-    """Our database has the exact same features as the base one."""
-
-    pass
+from django_prometheus.db.common import DatabaseWrapperMixin, ExportingCursorWrapper
 
 
 class DatabaseWrapper(DatabaseWrapperMixin, base.DatabaseWrapper):
     def get_connection_params(self):
-        conn_params = super(DatabaseWrapper, self).get_connection_params()
-        conn_params["cursor_factory"] = ExportingCursorWrapper(
-            psycopg2.extensions.cursor, self.alias, self.vendor
-        )
+        conn_params = super().get_connection_params()
+        conn_params["cursor_factory"] = ExportingCursorWrapper(conn_params["cursor_factory"], self.alias, self.vendor)
         return conn_params
 
     def create_cursor(self, name=None):
-        # cursor_factory is a kwarg to connect() so restore create_cursor()'s
-        # default behavior
+        # cursor_factory is set in get_connection_params() so psycopg already
+        # creates instrumented cursors. Delegate to Django's implementation to
+        # avoid the mixin's create_cursor which is incompatible with psycopg3.
         return base.DatabaseWrapper.create_cursor(self, name=name)

django_prometheus/db/backends/spatialite/base.py

@@ -0,0 +1,12 @@
+from django.contrib.gis.db.backends.spatialite import base, features
+from django.db.backends.sqlite3 import base as sqlite_base
+
+from django_prometheus.db.common import DatabaseWrapperMixin
+
+
+class DatabaseFeatures(features.DatabaseFeatures):
+    """Our database has the exact same features as the base one."""
+
+
+class DatabaseWrapper(DatabaseWrapperMixin, base.DatabaseWrapper):
+    CURSOR_CLASS = sqlite_base.SQLiteCursorWrapper

django_prometheus/db/backends/sqlite3/base.py

@@ -1,12 +1,11 @@
 from django.db.backends.sqlite3 import base
+
 from django_prometheus.db.common import DatabaseWrapperMixin
 
 
 class DatabaseFeatures(base.DatabaseFeatures):
     """Our database has the exact same features as the base one."""
 
-    pass
-
 
 class DatabaseWrapper(DatabaseWrapperMixin, base.DatabaseWrapper):
     CURSOR_CLASS = base.SQLiteCursorWrapper

django_prometheus/db/common.py

@@ -4,10 +4,11 @@ from django_prometheus.db import (
     errors_total,
     execute_many_total,
     execute_total,
+    query_duration_seconds,
 )
 
 
-class ExceptionCounterByType(object):
+class ExceptionCounterByType:
     """A context manager that counts exceptions by type.
 
     Exceptions increment the provided counter, whose last label's name
@@ -24,7 +25,7 @@ class ExceptionCounterByType(object):
     def __init__(self, counter, type_label="type", extra_labels=None):
         self._counter = counter
         self._type_label = type_label
-        self._labels = extra_labels
+        self._labels = dict(extra_labels)  # Copy labels since we modify them.
 
     def __enter__(self):
         pass
@@ -35,46 +36,45 @@ class ExceptionCounterByType(object):
             self._counter.labels(**self._labels).inc()
 
 
-class DatabaseWrapperMixin(object):
+class DatabaseWrapperMixin:
     """Extends the DatabaseWrapper to count connections and cursors."""
 
     def get_new_connection(self, *args, **kwargs):
         connections_total.labels(self.alias, self.vendor).inc()
         try:
-            return super(DatabaseWrapperMixin, self).get_new_connection(*args, **kwargs)
+            return super().get_new_connection(*args, **kwargs)
         except Exception:
             connection_errors_total.labels(self.alias, self.vendor).inc()
             raise
 
     def create_cursor(self, name=None):
-        return self.connection.cursor(
-            factory=ExportingCursorWrapper(self.CURSOR_CLASS, self.alias, self.vendor)
-        )
+        return self.connection.cursor(factory=ExportingCursorWrapper(self.CURSOR_CLASS, self.alias, self.vendor))
 
 
 def ExportingCursorWrapper(cursor_class, alias, vendor):
     """Returns a CursorWrapper class that knows its database's alias and
     vendor name.
     """
+    labels = {"alias": alias, "vendor": vendor}
 
     class CursorWrapper(cursor_class):
         """Extends the base CursorWrapper to count events."""
 
         def execute(self, *args, **kwargs):
             execute_total.labels(alias, vendor).inc()
-            with ExceptionCounterByType(
-                errors_total, extra_labels={"alias": alias, "vendor": vendor}
+            with (
+                query_duration_seconds.labels(**labels).time(),
+                ExceptionCounterByType(errors_total, extra_labels=labels),
             ):
-                return super(CursorWrapper, self).execute(*args, **kwargs)
+                return super().execute(*args, **kwargs)
 
         def executemany(self, query, param_list, *args, **kwargs):
             execute_total.labels(alias, vendor).inc(len(param_list))
             execute_many_total.labels(alias, vendor).inc(len(param_list))
-            with ExceptionCounterByType(
-                errors_total, extra_labels={"alias": alias, "vendor": vendor}
+            with (
+                query_duration_seconds.labels(**labels).time(),
+                ExceptionCounterByType(errors_total, extra_labels=labels),
             ):
-                return super(CursorWrapper, self).executemany(
-                    query, param_list, *args, **kwargs
-                )
+                return super().executemany(query, param_list, *args, **kwargs)
 
     return CursorWrapper

django_prometheus/db/metrics.py

@@ -1,31 +1,34 @@
-from prometheus_client import Counter
+from prometheus_client import Counter, Histogram
+
+from django_prometheus.conf import NAMESPACE, PROMETHEUS_LATENCY_BUCKETS
 
 connections_total = Counter(
     "django_db_new_connections_total",
     "Counter of created connections by database and by vendor.",
     ["alias", "vendor"],
+    namespace=NAMESPACE,
 )
 
 connection_errors_total = Counter(
     "django_db_new_connection_errors_total",
     "Counter of connection failures by database and by vendor.",
     ["alias", "vendor"],
+    namespace=NAMESPACE,
 )
 
 execute_total = Counter(
     "django_db_execute_total",
-    (
-        "Counter of executed statements by database and by vendor, including"
-        " bulk executions."
-    ),
+    ("Counter of executed statements by database and by vendor, including bulk executions."),
     ["alias", "vendor"],
+    namespace=NAMESPACE,
 )
 
 
 execute_many_total = Counter(
     "django_db_execute_many_total",
-    ("Counter of executed statements in bulk operations by database and" " by vendor."),
+    ("Counter of executed statements in bulk operations by database and by vendor."),
     ["alias", "vendor"],
+    namespace=NAMESPACE,
 )
 
 
@@ -33,4 +36,13 @@ errors_total = Counter(
     "django_db_errors_total",
     ("Counter of execution errors by database, vendor and exception type."),
     ["alias", "vendor", "type"],
+    namespace=NAMESPACE,
+)
+
+query_duration_seconds = Histogram(
+    "django_db_query_duration_seconds",
+    ("Histogram of query duration by database and vendor."),
+    ["alias", "vendor"],
+    buckets=PROMETHEUS_LATENCY_BUCKETS,
+    namespace=NAMESPACE,
 )

django_prometheus/exports.py

@@ -1,13 +1,11 @@
 import logging
 import os
-import socket
 import threading
 
 import prometheus_client
-from prometheus_client import multiprocess
-
 from django.conf import settings
 from django.http import HttpResponse
+from prometheus_client import multiprocess
 
 try:
     # Python 2
@@ -23,7 +21,7 @@ logger = logging.getLogger(__name__)
 def SetupPrometheusEndpointOnPort(port, addr=""):
     """Exports Prometheus metrics on an HTTPServer running in its own thread.
 
-    The server runs on the given port and is by default listenning on
+    The server runs on the given port and is by default listening on
     all interfaces. This HTTPServer is fully independent of Django and
     its stack. This offers the advantage that even if Django becomes
     unable to respond, the HTTPServer will continue to function and
@@ -52,7 +50,7 @@ class PrometheusEndpointServer(threading.Thread):
 
     def __init__(self, httpd, *args, **kwargs):
         self.httpd = httpd
-        super(PrometheusEndpointServer, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
 
     def run(self):
         self.httpd.serve_forever()
@@ -86,18 +84,16 @@ def SetupPrometheusEndpointOnPortRange(port_range, addr=""):
     for port in port_range:
         try:
             httpd = HTTPServer((addr, port), prometheus_client.MetricsHandler)
-        except (OSError, socket.error):
+        except OSError:
             # Python 2 raises socket.error, in Python 3 socket.error is an
             # alias for OSError
             continue  # Try next port
         thread = PrometheusEndpointServer(httpd)
         thread.daemon = True
         thread.start()
-        logger.info("Exporting Prometheus /metrics/ on port %s" % port)
+        logger.info(f"Exporting Prometheus /metrics/ on port {port}")
         return port  # Stop trying ports at this point
-    logger.warning(
-        "Cannot export Prometheus /metrics/ - " "no available ports in supplied range"
-    )
+    logger.warning("Cannot export Prometheus /metrics/ - no available ports in supplied range")
     return None
 
 
@@ -117,12 +113,10 @@ def ExportToDjangoView(request):
 
     You can use django_prometheus.urls to map /metrics to this view.
     """
-    if "prometheus_multiproc_dir" in os.environ:
+    if "PROMETHEUS_MULTIPROC_DIR" in os.environ or "prometheus_multiproc_dir" in os.environ:
         registry = prometheus_client.CollectorRegistry()
         multiprocess.MultiProcessCollector(registry)
     else:
         registry = prometheus_client.REGISTRY
     metrics_page = prometheus_client.generate_latest(registry)
-    return HttpResponse(
-        metrics_page, content_type=prometheus_client.CONTENT_TYPE_LATEST
-    )
+    return HttpResponse(metrics_page, content_type=prometheus_client.CONTENT_TYPE_LATEST)