django-health-check 3.23.2__py3-none-any.whl → 4.0rc1__py3-none-any.whl

health_check/views.py

@@ -1,23 +1,25 @@
+import asyncio
 import re
-import warnings
-from functools import cached_property
+import typing
 
 from django.db import transaction
 from django.http import HttpResponse, JsonResponse
+from django.utils import timezone
+from django.utils.cache import patch_vary_headers
 from django.utils.decorators import method_decorator
+from django.utils.feedgenerator import Atom1Feed, Rss201rev2Feed
 from django.utils.module_loading import import_string
 from django.views.decorators.cache import never_cache
 from django.views.generic import TemplateView
 
-from health_check.deprecation import deprecated
-from health_check.mixins import CheckMixin
+from health_check.base import HealthCheck
 
 
 class MediaType:
     """
     Sortable object representing HTTP's accept header.
 
-    .. seealso:: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept
+    See also: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept
     """
 
     pattern = re.compile(
@@ -54,20 +56,21 @@ class MediaType:
 
     @classmethod
     def from_string(cls, value):
-        """Return single instance parsed from given accept header string."""
+        """Return single instance parsed from the given Accept-header string."""
         match = cls.pattern.search(value)
         if match is None:
             raise ValueError(f'"{value}" is not a valid media type')
-        try:
-            return cls(match.group("mime_type"), float(match.group("weight") or 1))
-        except ValueError:
-            return cls(value)
+        return cls(match.group("mime_type"), float(match.group("weight") or 1))
 
     @classmethod
     def parse_header(cls, value="*/*"):
         """Parse HTTP accept header and return instances sorted by weight."""
         yield from sorted(
-            (cls.from_string(token.strip()) for token in value.split(",") if token.strip()),
+            (
+                cls.from_string(token.strip())
+                for token in value.split(",")
+                if token.strip()
+            ),
             reverse=True,
         )
 
@@ -84,103 +87,201 @@ class MediaType:
         return self.weight.__lt__(other.weight)
 
 
-@method_decorator(transaction.non_atomic_requests, name="dispatch")
-class _MainView(CheckMixin, TemplateView):
-    """Deprecated: Use HealthCheckView instead."""
+class HealthCheckView(TemplateView):
+    """Perform health checks and return results in various formats."""
 
     template_name = "health_check/index.html"
+    feed_author = "Django Health Check"
+
+    checks: typing.Iterable[
+        type[HealthCheck] | str | tuple[type[HealthCheck] | str, dict[str, typing.Any]]
+    ] = (
+        "health_check.checks.Cache",
+        "health_check.checks.Database",
+        "health_check.checks.Disk",
+        "health_check.checks.DNS",
+        "health_check.checks.Mail",
+        "health_check.checks.Memory",
+        "health_check.checks.Storage",
+    )
+
+    @method_decorator(transaction.non_atomic_requests)
+    async def dispatch(self, request, *args, **kwargs):
+        response = await super().dispatch(request, *args, **kwargs)
+        patch_vary_headers(response, ["Accept"])
+        return response
 
     @method_decorator(never_cache)
-    def get(self, request, *args, **kwargs):
-        subset = kwargs.get("subset")
-        health_check_has_error = self.check(subset)
-        status_code = 500 if health_check_has_error else 200
+    async def get(self, request, *args, **kwargs):
+        self.results = await asyncio.gather(
+            *(check.get_result() for check in self.get_checks())
+        )
+        has_errors = any(result.error for result in self.results)
+        status_code = 500 if has_errors else 200
         format_override = request.GET.get("format")
 
-        if format_override == "json":
-            return self.render_to_response_json(self.filter_plugins(subset=subset), status_code)
+        match format_override:
+            case "json":
+                return self.render_to_response_json(status_code)
+            case "text":
+                return self.render_to_response_text(status_code)
+            case "atom":
+                return self.render_to_response_atom()
+            case "rss":
+                return self.render_to_response_rss()
+            case "openmetrics":
+                return self.render_to_response_openmetrics()
 
         accept_header = request.headers.get("accept", "*/*")
         for media in MediaType.parse_header(accept_header):
-            if media.mime_type in (
-                "text/html",
-                "application/xhtml+xml",
-                "text/*",
-                "*/*",
-            ):
-                context = self.get_context_data(**kwargs)
-                return self.render_to_response(context, status=status_code)
-            elif media.mime_type in ("application/json", "application/*"):
-                return self.render_to_response_json(self.filter_plugins(subset=subset), status_code)
+            match media.mime_type:
+                case "text/plain":
+                    return self.render_to_response_text(status_code)
+                case "text/html" | "application/xhtml+xml" | "text/*" | "*/*":
+                    context = self.get_context_data(**kwargs)
+                    return self.render_to_response(context, status=status_code)
+                case "application/json" | "application/*":
+                    return self.render_to_response_json(status_code)
+                case "application/atom+xml":
+                    return self.render_to_response_atom()
+                case "application/rss+xml":
+                    return self.render_to_response_rss()
+                case "application/openmetrics-text":
+                    return self.render_to_response_openmetrics()
         return HttpResponse(
-            "Not Acceptable: Supported content types: text/html, application/json",
+            "Not Acceptable: Supported content types: text/plain, text/html, application/json, application/atom+xml, application/rss+xml, application/openmetrics-text",
             status=406,
             content_type="text/plain",
         )
 
     def get_context_data(self, **kwargs):
-        subset = kwargs.get("subset")
         return {
             **super().get_context_data(**kwargs),
-            "plugins": self.filter_plugins(subset=subset).values(),
-            "errors": any(p.errors for p in self.filter_plugins(subset=subset).values()),
+            "results": self.results,
+            "errors": any(result.error for result in self.results),
         }
 
-    def render_to_response_json(self, plugins, status):
+    def render_to_response_json(self, status):
+        """Return JSON response with health check results."""
         return JsonResponse(
-            {label: str(p.pretty_status()) for label, p in plugins.items()},
+            {
+                repr(result.check): "OK" if not result.error else str(result.error)
+                for result in self.results
+            },
             status=status,
         )
 
+    def render_to_response_text(self, status):
+        """Return plain text response with health check results."""
+        lines = (
+            f"{repr(result.check)}: {'OK' if not result.error else str(result.error)}"
+            for result in self.results
+        )
+        return HttpResponse(
+            "\n".join(lines) + "\n",
+            content_type="text/plain; charset=utf-8",
+            status=status,
+        )
 
-@deprecated(
-    "MainView is deprecated: use `HealthCheckView` instead (view-based API). Action: replace `MainView` usage with `HealthCheckView.as_view(checks=...)`. See migration guide: https://codingjoe.dev/django-health-check/migrate-to-v4/ (docs/migrate-to-v4.md)."
-)
-class MainView(_MainView):
-    """Deprecated: Use HealthCheckView instead."""
+    def render_to_response_atom(self):
+        """Return Atom feed response with health check results."""
+        return self._render_feed(Atom1Feed)
 
-    pass
+    def render_to_response_rss(self):
+        """Return RSS 2.0 feed response with health check results."""
+        return self._render_feed(Rss201rev2Feed)
 
+    def _escape_openmetrics_label_value(self, value):
+        r"""
+        Escape label value according to OpenMetrics specification.
 
-class HealthCheckView(_MainView):
-    """Perform health checks and return results in various formats."""
+        Escapes backslashes, double quotes, and newlines as required by the spec:
+        - Backslash (\) -> \\
+        - Double quote (") -> \"
+        - Line feed (\n) -> \n
+        """
+        return value.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
 
-    checks: list[str | tuple[str, dict]] | None = None
+    def render_to_response_openmetrics(self):
+        """Return OpenMetrics response with health check results."""
+        lines = [
+            "# HELP django_health_check_status Health check status (1 = healthy, 0 = unhealthy)",
+            "# TYPE django_health_check_status gauge",
+        ]
+        has_errors: bool = False
 
-    @classmethod
-    def as_view(cls, **initkwargs):
-        if "warnings_as_errors" in initkwargs:
-            warnings.warn(
-                "`warnings_as_errors` argument is deprecated and will be removed the next major version.",
-                DeprecationWarning,
-                stacklevel=2,
+        # Add status metrics for each check
+        for result in self.results:
+            safe_label = self._escape_openmetrics_label_value(repr(result.check))
+            has_errors |= bool(result.error)
+            lines.append(
+                f'django_health_check_status{{check="{safe_label}"}} {not result.error:d}'
+            )
+
+        # Add response time metrics
+        lines += [
+            "",
+            "# HELP django_health_check_response_time_seconds Health check response time in seconds",
+            "# TYPE django_health_check_response_time_seconds gauge",
+        ]
+
+        for result in self.results:
+            safe_label = self._escape_openmetrics_label_value(repr(result.check))
+            lines.append(
+                f'django_health_check_response_time_seconds{{check="{safe_label}"}} {result.time_taken:.6f}'
             )
-        if "use_threading" in initkwargs:
-            warnings.warn(
-                "`use_threading` argument is deprecated and will be removed the next major version.",
-                DeprecationWarning,
-                stacklevel=2,
+
+        # Add overall health status
+        lines += [
+            "",
+            "# HELP django_health_check_overall_status Overall health check status (1 = all healthy, 0 = at least one unhealthy)",
+            "# TYPE django_health_check_overall_status gauge",
+            f"django_health_check_overall_status {not has_errors:d}",
+            "# EOF",
+        ]
+
+        return HttpResponse(
+            "\n".join(lines) + "\n",
+            content_type="application/openmetrics-text; version=1.0.0; charset=utf-8",
+            status=200,  # Prometheus expects 200 even if checks fail
+        )
+
+    def _render_feed(self, feed_class):
+        """Generate RSS or Atom feed with health check results."""
+        feed = feed_class(
+            title="Health Check Status",
+            link=self.request.build_absolute_uri(),
+            description="Current status of system health checks",
+            feed_url=self.request.build_absolute_uri(),
+        )
+
+        for result in self.results:
+            feed.add_item(
+                title=repr(result.check),
+                link=self.request.build_absolute_uri(),
+                description=f"{result.check!r}\nResponse time: {result.time_taken:.3f}s",
+                pubdate=timezone.now(),
+                updateddate=timezone.now(),
+                author_name=self.feed_author,
+                categories=["error", "unhealthy"] if result.error else ["healthy"],
             )
-        return super().as_view(**initkwargs)
-
-    def get_plugins(self):
-        for check in self.checks or [
-            "health_check.Cache",
-            "health_check.Database",
-            "health_check.Disk",
-            "health_check.Mail",
-            "health_check.Memory",
-            "health_check.Storage",
-        ]:
+
+        response = HttpResponse(
+            feed.writeString("utf-8"),
+            content_type=feed.content_type,
+            status=200,  # Feed readers expect 200 even if checks fail
+        )
+        return response
+
+    def get_checks(
+        self,
+    ) -> typing.Generator[HealthCheck, None, None]:
+        """Yield instantiated health check callables."""
+        for check in self.checks:
             try:
                 check, options = check
-            except ValueError:
+            except (ValueError, TypeError):
                 options = {}
             if isinstance(check, str):
                 check = import_string(check)
-            plugin_instance = check(**options)
-            yield repr(plugin_instance), plugin_instance
-
-    @cached_property
-    def plugins(self):
-        return dict(self.get_plugins())
+            yield check(**options)

django_health_check-3.23.2.dist-info/RECORD

@@ -1,63 +0,0 @@
-health_check/__init__.py,sha256=vLH1k9cjhuLe_swu-qMxrz1_7fFJA179-UWNcsdA8QA,868
-health_check/_version.py,sha256=mxLf1sW9K0QQHtOQxElIqSODHiT_z1DtMeutHlOPwAs,714
-health_check/backends.py,sha256=Q4B8yRusBZz8mOz8jNZmqJWQ1Fu6YawYiLNFkw5sUmA,3414
-health_check/conf.py,sha256=l3Utl8zLLT42TKUnBFNLnD_i-wYNKmxPXVVyIucGUXc,319
-health_check/deprecation.py,sha256=uYGwPFW8lX1xQ33x0VRkoPFoyoLcrMt6DmpX3RHLxj4,1127
-health_check/exceptions.py,sha256=L9QiCWYpuz3H05an3wDhz_coKeulHvTYotIT4gjKMXA,743
-health_check/mixins.py,sha256=pm1JB1qwU5oBklpR8czPIdPru0JrqDDEnmsiYJGWtms,2924
-health_check/plugins.py,sha256=Y7TaRm5ILhvLUKmoF33KrIYz6ubA0Vd5Mjf7IOmvwO8,623
-health_check/urls.py,sha256=2AYTZzWO-BBILcsSBD2gTuRCstf9YTp0NZ3k8FfY1RM,627
-health_check/views.py,sha256=LJPanE4wZctDiwuqSn6zMTH_JsMqYPSVbLag1yBFbVQ,6543
-health_check/cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-health_check/cache/apps.py,sha256=aJKPag3O1oLTdRDlpxqI8l4vE_c-iA8AReROsnlckio,349
-health_check/cache/backends.py,sha256=a2nhNOE_wFmZNMBi1G_y8ByS_J1dm_R2X-8JdknB-kQ,1994
-health_check/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-health_check/contrib/celery/__init__.py,sha256=xdK73-N2QJ6N9iom2s4Zqhl7nc4_MQrhojjHdD7p7Y8,85
-health_check/contrib/celery/apps.py,sha256=0hV0CAUeZMnjHmu0QpmDhQnS48NI95iD1lssly4sAa0,1409
-health_check/contrib/celery/backends.py,sha256=iGtaNQq6ZDcXC6UUB8knvNaZS3IE5LkcwPJHnG7lfoc,2221
-health_check/contrib/celery/tasks.py,sha256=UWmgZa4oGsXuo_udRVRBoCAOVFibGHjqevw3s8rOnfQ,99
-health_check/contrib/celery_ping/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-health_check/contrib/celery_ping/apps.py,sha256=NOg01PnKYOCBSUCqSW62VbLwmeO99h7X_Mf8zjBmkbc,754
-health_check/contrib/celery_ping/backends.py,sha256=T8EC3EpfsuzT1HNvyk8ZFJAIMgvVlIwB7TGOsXvcCpQ,2522
-health_check/contrib/db_heartbeat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-health_check/contrib/db_heartbeat/apps.py,sha256=_zc7ZYis4U6JpObmQBoFrEZHgC1UFcvO415l0c0cUXw,752
-health_check/contrib/db_heartbeat/backends.py,sha256=vfdGzdtCW2wUWwcXS4VNFdm4LopLi4UpylMhUpApA0s,1336
-health_check/contrib/mail/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-health_check/contrib/mail/apps.py,sha256=UGwk9BM6oIVingQmr--Joe4ujNPtVsxe6nzQ-fDu9c0,683
-health_check/contrib/mail/backends.py,sha256=UdbRPyy-1mZSgSkjMopnvpMDZrJT1xybvSJI9Br3lS4,1940
-health_check/contrib/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-health_check/contrib/migrations/apps.py,sha256=oSvxHRPVU6JT48gdbASSI8G-zUUclAQZZVSdJKM_2oM,707
-health_check/contrib/migrations/backends.py,sha256=-qx9C4oxqv5ITAnoeQ-8bGxmxZYtbF7RE9y4IMoFIGM,1432
-health_check/contrib/psutil/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-health_check/contrib/psutil/apps.py,sha256=VjR4sw6kY4y1GmWohZSRxl8Em1JrdL3ApgPcZ8hGnE0,1350
-health_check/contrib/psutil/backends.py,sha256=-5yv3pM8UvrfQgr9PT4dyVmSRSg6j322-ZW-nm3FHho,2383
-health_check/contrib/rabbitmq/__init__.py,sha256=PlctAhXwp9DjxPo7DGpWvD1DBTfvWf807t-mhfMoNFU,78
-health_check/contrib/rabbitmq/apps.py,sha256=i-1Uo3W6Ofc0_StFABfrxysh_anWVP-mcNKUHqZ6_c8,721
-health_check/contrib/rabbitmq/backends.py,sha256=22zNDsX-Ie-a5Rwk4naIpGB3184SV2OaGTXzwBzWbU0,1836
-health_check/contrib/redis/__init__.py,sha256=TzSbuXNst7itI8mbrtsCNJXJP40ZpX-r2x6mxMNTgYE,69
-health_check/contrib/redis/apps.py,sha256=1bhVAy5iKZer8IwG4WXZYeYUSl7AMTtNPRRhR5ugrLs,700
-health_check/contrib/redis/backends.py,sha256=xQ73bnGlOGtvnaNiEOz4bhqxXsD-Qn2y6aVwoiQkWCg,2788
-health_check/contrib/s3boto3_storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-health_check/contrib/s3boto3_storage/apps.py,sha256=1-7X_v7d6HeKD5MBxyDvrh5vdopsvmnJNjToiFjeDx4,732
-health_check/contrib/s3boto3_storage/backends.py,sha256=0WrNNNJiqDVn5_GHQZm6hlEBvSxhWTqWSWUtmVHkzzo,1331
-health_check/contrib/s3boto_storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-health_check/contrib/s3boto_storage/apps.py,sha256=5pQWKqhBgb_IYpJEJ5pej8bYRcermiGecZUq2aZeRvk,569
-health_check/contrib/s3boto_storage/backends.py,sha256=jfvlK2GhJBGEtdqFzNnxsp9W11KPpoRlYzQVBweoncQ,1074
-health_check/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-health_check/db/apps.py,sha256=Xmh9FbjROw1qYQbMutb3o4c0XG64KHxHLpaWzq4W31s,708
-health_check/db/backends.py,sha256=c-rNcEoqq3X8r08sqJTHqdXZpxba-wloHAeKlI82Bxc,1028
-health_check/db/models.py,sha256=kMA0uoAQBwqHLpfVt4gMG8-h3BZIGcFRSAwD9oATBWU,204
-health_check/db/migrations/0001_initial.py,sha256=a5sN_dfDXju_Kr32uBqzPvd8B9Ysl1bV8WL5fQwsRZI,826
-health_check/db/migrations/0002_alter_testmodel_options.py,sha256=yLcp1aAdJ_2Q-F7MfCVVf2nTojIijnztdulOK1QmpUQ,984
-health_check/db/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-health_check/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-health_check/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-health_check/management/commands/health_check.py,sha256=EWBAhMOq9clravsDwHqCiSt4JQJIRejcg5f2SvIsSeI,3864
-health_check/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-health_check/storage/apps.py,sha256=f6958Deq62DXoe8myL57rnKSkKkPQf2FLM9iJkUdx-U,293
-health_check/storage/backends.py,sha256=pkj64HcVnvm9pvgWFhL81IDejTOH8-pLSFwJQ_90jbs,2636
-health_check/templates/health_check/index.html,sha256=pOC7GW_r0gDQ5Qz5aJacNFI22N52kbiOzh4aZb9_V-Q,4045
-django_health_check-3.23.2.dist-info/licenses/LICENSE,sha256=19Rs8FInCokFQuq03cab_KHwpeyF5pt-lTp7pfJX1iE,1101
-django_health_check-3.23.2.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-django_health_check-3.23.2.dist-info/METADATA,sha256=BjOQs1iaWA_kROQ0sJeZuItjeBeWrRX3yX_xWaQn0lM,3554
-django_health_check-3.23.2.dist-info/RECORD,,

health_check/backends.py

@@ -1,101 +0,0 @@
-import dataclasses
-import logging
-import warnings
-from timeit import default_timer as timer
-
-from health_check.exceptions import HealthCheckException
-
-logger = logging.getLogger("health-check")
-
-
-@dataclasses.dataclass()
-class HealthCheck:
-    """
-    Base class for all health check backends.
-
-    To create your own health check backend, subclass this class
-    and implement the ``check_status`` method.
-    """
-
-    critical_service: bool = dataclasses.field(init=False, default=True, repr=False)
-    errors: list[HealthCheckException] = dataclasses.field(init=False, default_factory=list, repr=False)
-
-    def check_status(self):
-        """
-        Execute the health check logic.
-
-        This method should be overridden by subclasses to implement
-        specific health check logic. If the check fails, it should
-        call `self.add_error` with an appropriate error message or
-        raise a `HealthCheckException`.
-
-        Raises:
-            HealthCheckException: If the health check fails.
-            ServiceWarning: If the health check encounters a warning condition.
-
-        """
-        raise NotImplementedError
-
-    def run_check(self):
-        start = timer()
-        self.errors = []
-        try:
-            self.check_status()
-        except HealthCheckException as e:
-            self.add_error(e, e)
-        except BaseException:
-            logger.exception("Unexpected Error!")
-            raise
-        finally:
-            self.time_taken = timer() - start
-
-    def add_error(self, error, cause=None):
-        if isinstance(error, HealthCheckException):
-            pass
-        elif isinstance(error, str):
-            msg = error
-            error = HealthCheckException(msg)
-        else:
-            msg = "unknown error"
-            error = HealthCheckException(msg)
-        if isinstance(cause, BaseException):
-            logger.exception(str(error))
-        else:
-            logger.error(str(error))
-        self.errors.append(error)
-
-    def pretty_status(self):
-        if self.errors:
-            return "\n".join(str(e) for e in self.errors)
-        return "OK"
-
-    @property
-    def status(self):
-        return int(not self.errors)
-
-    def __repr__(self):
-        if hasattr(self, "identifier"):
-            warnings.warn(
-                "`identifier()` method is deprecated: implement `__repr__()` instead to return a stable identifier. Action: update your backend class to implement `__repr__` and remove `identifier()`. See migration guide: https://codingjoe.dev/django-health-check/migrate-to-v4/ (docs/migrate-to-v4.md).",
-                DeprecationWarning,
-            )
-            return self.identifier()
-
-        return self.__class__.__name__
-
-
-class BaseHealthCheck(HealthCheck):
-    """
-    Deprecated base class for health check backends.
-
-    This class is maintained for backward compatibility.
-    New health check backends should inherit from `HealthCheck` instead.
-    """
-
-    def __init_subclass__(cls, **kwargs):
-        warnings.warn(
-            f"{cls.__name__} inherits from deprecated `BaseHealthCheck`: inherit from `HealthCheck` instead. Action: update subclass to inherit from `health_check.backends.HealthCheck`. See migration guide: https://codingjoe.dev/django-health-check/migrate-to-v4/ (docs/migrate-to-v4.md).",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        super().__init_subclass__(**kwargs)

health_check/cache/apps.py

@@ -1,14 +0,0 @@
-from django.apps import AppConfig
-from django.conf import settings
-
-from health_check.plugins import plugin_dir
-
-
-class HealthCheckConfig(AppConfig):
-    name = "health_check.cache"
-
-    def ready(self):
-        from .backends import CacheBackend
-
-        for backend in settings.CACHES:
-            plugin_dir.register(CacheBackend, alias=backend)

health_check/cache/backends.py

@@ -1,50 +0,0 @@
-import dataclasses
-import datetime
-
-from django.conf import settings
-from django.core.cache import CacheKeyWarning, caches
-
-from health_check.backends import HealthCheck
-from health_check.exceptions import ServiceReturnedUnexpectedResult, ServiceUnavailable
-
-try:
-    # Exceptions thrown by Redis do not subclass builtin exceptions like ConnectionError.
-    # Additionally, not only connection errors (ConnectionError -> RedisError) can be raised,
-    # but also errors for time-outs (TimeoutError -> RedisError)
-    # and if the backend is read-only (ReadOnlyError -> ResponseError -> RedisError).
-    # Since we know what we are trying to do here, we are not picky and catch the global exception RedisError.
-    from redis.exceptions import RedisError
-except ModuleNotFoundError:
-    # In case Redis is not installed and another cache backend is used.
-    class RedisError(Exception):
-        pass
-
-
-@dataclasses.dataclass
-class CacheBackend(HealthCheck):
-    """
-    Check that the cache backend is able to set and get a value.
-
-    Args:
-        alias: The cache alias to test against.
-
-    """
-
-    alias: str = dataclasses.field(default="default")
-    cache_key: str = dataclasses.field(
-        default=getattr(settings, "HEALTHCHECK_CACHE_KEY", "djangohealthcheck_test"), repr=False
-    )
-
-    def check_status(self):
-        cache = caches[self.alias]
-        ts = datetime.datetime.now().timestamp()
-        try:
-            cache.set(self.cache_key, f"itworks-{ts}")
-            if not cache.get(self.cache_key) == f"itworks-{ts}":
-                raise ServiceUnavailable(f"Cache key {self.cache_key} does not match")
-        except CacheKeyWarning as e:
-            self.add_error(ServiceReturnedUnexpectedResult("Cache key warning"), e)
-        except ValueError as e:
-            self.add_error(ServiceReturnedUnexpectedResult("ValueError"), e)
-        except (ConnectionError, RedisError) as e:
-            self.add_error(ServiceReturnedUnexpectedResult("Connection Error"), e)

health_check/conf.py

@@ -1,8 +0,0 @@
-from django.conf import settings
-
-HEALTH_CHECK = getattr(settings, "HEALTH_CHECK", {})
-HEALTH_CHECK.setdefault("DISK_USAGE_MAX", 90)
-HEALTH_CHECK.setdefault("MEMORY_MIN", 100)
-HEALTH_CHECK.setdefault("WARNINGS_AS_ERRORS", True)
-HEALTH_CHECK.setdefault("SUBSETS", {})
-HEALTH_CHECK.setdefault("DISABLE_THREADING", False)

health_check/contrib/celery/__init__.py

@@ -1,3 +0,0 @@
-from ..celery_ping.backends import CeleryPingHealthCheck as Ping
-
-__all__ = ["Ping"]

health_check/contrib/celery/apps.py

@@ -1,31 +0,0 @@
-import warnings
-
-from celery import current_app
-from django.apps import AppConfig
-from django.conf import settings
-
-from health_check.plugins import plugin_dir
-
-
-class HealthCheckConfig(AppConfig):
-    name = "health_check.contrib.celery"
-
-    def ready(self):
-        from .backends import CeleryHealthCheck
-
-        warnings.warn(
-            "The `health_check.contrib.celery` app is deprecated: checks are now configured via `HealthCheckView`. Action: remove this sub-app from `INSTALLED_APPS` and add the Celery check(s) to your `HealthCheckView.checks`. See migration guide: https://codingjoe.dev/django-health-check/migrate-to-v4/ (docs/migrate-to-v4.md).",
-            DeprecationWarning,
-        )
-
-        if hasattr(settings, "HEALTHCHECK_CELERY_TIMEOUT"):
-            warnings.warn(
-                "`HEALTHCHECK_CELERY_TIMEOUT` setting is deprecated: it was split into separate timeouts. Action: replace it with `HEALTHCHECK_CELERY_RESULT_TIMEOUT` and `HEALTHCHECK_CELERY_QUEUE_TIMEOUT`. See migration guide: https://codingjoe.dev/django-health-check/migrate-to-v4/ (docs/migrate-to-v4.md).",
-                DeprecationWarning,
-            )
-
-        for queue in current_app.amqp.queues:
-            celery_class_name = "CeleryHealthCheck" + queue.title()
-
-            celery_class = type(celery_class_name, (CeleryHealthCheck,), {"queue": queue})
-            plugin_dir.register(celery_class)

health_check/contrib/celery/backends.py

@@ -1,46 +0,0 @@
-from celery.exceptions import TaskRevokedError, TimeoutError
-from django.conf import settings
-
-from health_check.backends import HealthCheck
-from health_check.deprecation import deprecated
-from health_check.exceptions import ServiceReturnedUnexpectedResult, ServiceUnavailable
-
-from .tasks import add
-
-
-@deprecated(
-    "`CeleryHealthCheck` is deprecated: use `health_check.contrib.celery.Ping` (or the new view-based Celery ping check) instead. Action: remove legacy CeleryHealthCheck subclasses and configure `HealthCheckView` with the new Celery ping check in your `checks` list. See migration guide: https://codingjoe.dev/django-health-check/migrate-to-v4/ (docs/migrate-to-v4.md)."
-)
-class CeleryHealthCheck(HealthCheck):
-    def check_status(self):
-        timeout = getattr(settings, "HEALTHCHECK_CELERY_TIMEOUT", 3)
-        result_timeout = getattr(settings, "HEALTHCHECK_CELERY_RESULT_TIMEOUT", timeout)
-        queue_timeout = getattr(settings, "HEALTHCHECK_CELERY_QUEUE_TIMEOUT", timeout)
-        priority = getattr(settings, "HEALTHCHECK_CELERY_PRIORITY", None)
-
-        try:
-            result = add.apply_async(args=[4, 4], expires=queue_timeout, queue=self.queue, priority=priority)
-            result.get(timeout=result_timeout)
-            if result.result != 8:
-                self.add_error(ServiceReturnedUnexpectedResult("Celery returned wrong result"))
-        except OSError as e:
-            self.add_error(ServiceUnavailable("IOError"), e)
-        except NotImplementedError as e:
-            self.add_error(
-                ServiceUnavailable("NotImplementedError: Make sure CELERY_RESULT_BACKEND is set"),
-                e,
-            )
-        except TaskRevokedError as e:
-            self.add_error(
-                ServiceUnavailable(
-                    "TaskRevokedError: The task was revoked, likely because it spent too long in the queue"
-                ),
-                e,
-            )
-        except TimeoutError as e:
-            self.add_error(
-                ServiceUnavailable("TimeoutError: The task took too long to return a result"),
-                e,
-            )
-        except BaseException as e:
-            self.add_error(ServiceUnavailable("Unknown error"), e)

health_check/contrib/celery/tasks.py

@@ -1,6 +0,0 @@
-from celery import shared_task
-
-
-@shared_task(ignore_result=False)
-def add(x, y):
-    return x + y