grpc-server-kit 0.1.0__py3-none-any.whl

grpc_server_kit/aio/dishka/interceptors.py

@@ -0,0 +1,116 @@
+"""Dishka provider assembling the canonical gRPC server interceptor chain (``[dishka]`` extra).
+
+Replaces the per-service hand-written ``create_interceptors`` list. The order is fixed and
+encodes the documented rationale: metrics outermost (measures everything below); the
+exception handler maps raw exceptions to gRPC statuses; Sentry sits INSIDE the exception
+handler so it observes raw handler exceptions BEFORE they are converted into
+``grpc.aio.AbortError`` (outside it would never capture anything); the request-scoped
+Dishka interceptor is innermost. Individual interceptors can be toggled off and extra
+ones slotted at the outer/inner ends.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import grpc
+from dishka import AsyncContainer, Provider, Scope, provide
+from dishka.integrations.grpcio import DishkaAioInterceptor
+
+from grpc_server_kit.aio.interceptors import (
+    GRPC_DEFAULT_ERROR_STATUS_MAP,
+    AsyncContextInterceptor,
+    AsyncExceptionHandlerInterceptor,
+    AsyncMetricsInterceptor,
+    AsyncRequestLoggerInterceptor,
+    AsyncSentryInterceptor,
+    AsyncTracingInterceptor,
+    ErrorDetailFactory,
+    HeaderConfig,
+)
+from grpc_server_kit.aio.interceptors.exception_handler import find_mapped_status
+from grpc_server_kit.aio.interceptors.protocols import (
+    ErrorReporterProtocol,
+    GrpcServerMetricsProtocol,
+    TracerProtocol,
+)
+from grpc_server_kit.interceptors.utils import is_server_error
+from grpc_server_kit.protocols import GrpcServiceName
+
+
+class GrpcServerInterceptorsProvider(Provider):
+    """Provide the ordered ``list[grpc.aio.ServerInterceptor]`` for the server.
+
+    Depends on the metrics/sentry/tracer seams (``... | None``) — register the matching
+    seam providers (or use :func:`grpc_server_kit.aio.dishka.grpc_server_providers`).
+    """
+
+    scope = Scope.APP
+
+    def __init__(
+        self,
+        *,
+        error_status_map: dict[type[Exception], grpc.StatusCode] | None = None,
+        detail_factory: ErrorDetailFactory | None = None,
+        header_configs: Sequence[HeaderConfig] | None = None,
+        include_metrics: bool = True,
+        include_context: bool = True,
+        include_request_logger: bool = True,
+        include_tracing: bool = True,
+        include_sentry: bool = True,
+        include_exception_handler: bool = True,
+        extra_outer: Sequence[grpc.aio.ServerInterceptor] | None = None,
+        extra_inner: Sequence[grpc.aio.ServerInterceptor] | None = None,
+    ) -> None:
+        super().__init__()
+        self._error_status_map = error_status_map
+        self._detail_factory = detail_factory
+        self._header_configs = list(header_configs) if header_configs is not None else []
+        self._include_metrics = include_metrics
+        self._include_context = include_context
+        self._include_request_logger = include_request_logger
+        self._include_tracing = include_tracing
+        self._include_sentry = include_sentry
+        self._include_exception_handler = include_exception_handler
+        self._extra_outer = list(extra_outer or [])
+        self._extra_inner = list(extra_inner or [])
+
+    @provide
+    def interceptors(
+        self,
+        container: AsyncContainer,
+        service_name: GrpcServiceName,
+        metrics: GrpcServerMetricsProtocol | None,
+        sentry: ErrorReporterProtocol | None,
+        tracer: TracerProtocol | None,
+    ) -> list[grpc.aio.ServerInterceptor]:
+        """Build the interceptor chain (outermost first; Dishka request-scope interceptor last)."""
+        chain: list[grpc.aio.ServerInterceptor] = list(self._extra_outer)
+        if self._include_metrics:
+            chain.append(AsyncMetricsInterceptor(metrics=metrics, service_name=service_name))
+        if self._include_context:
+            chain.append(AsyncContextInterceptor(header_configs=self._header_configs))
+        if self._include_request_logger:
+            chain.append(AsyncRequestLoggerInterceptor())
+        if self._include_tracing:
+            chain.append(AsyncTracingInterceptor(service_name=service_name, tracer=tracer))
+        if self._include_exception_handler:
+            chain.append(AsyncExceptionHandlerInterceptor(self._error_status_map, detail_factory=self._detail_factory))
+        if self._include_sentry:
+            # Inside the exception handler: sees raw handler exceptions before
+            # they are mapped into AbortError (which Sentry must not capture).
+            # The capture filter reuses the SAME status map, so client-mapped
+            # errors (e.g. ValueError -> INVALID_ARGUMENT) are not reported.
+            merged_map = dict(GRPC_DEFAULT_ERROR_STATUS_MAP)
+            merged_map.update(self._error_status_map or {})
+
+            def _server_errors_only(exc: Exception, _map: dict = merged_map) -> bool:  # type: ignore[type-arg]
+                return is_server_error(find_mapped_status(type(exc), _map))
+
+            chain.append(AsyncSentryInterceptor(sentry=sentry, capture_filter=_server_errors_only))
+        chain.extend(self._extra_inner)
+        chain.append(DishkaAioInterceptor(container))  # innermost: opens the REQUEST scope per RPC
+        return chain
+
+
+__all__ = ["GrpcServerInterceptorsProvider"]

grpc_server_kit/aio/dishka/metrics.py

@@ -0,0 +1,50 @@
+"""Dishka provider for gRPC server Prometheus metrics (``[metrics]`` extra)."""
+
+from __future__ import annotations
+
+import logging
+
+from dishka import Provider, Scope, provide
+
+from grpc_server_kit.aio.interceptors.protocols import GrpcServerMetricsProtocol
+from grpc_server_kit.observability.metrics import HAS_PROMETHEUS, GrpcServerMetrics, get_grpc_server_metrics
+
+logger = logging.getLogger(__name__)
+
+
+class PrometheusGrpcServerMetricsProvider(Provider):
+    """Provide ``GrpcServerMetrics`` (and its protocol view) for the metrics interceptor.
+
+    Degrades gracefully like the sibling Sentry/tracer seam providers: when
+    ``enabled`` is False OR the ``[metrics]`` extra is absent, provides ``None``
+    (the metrics interceptor then no-ops), so the provider can always be
+    registered.
+    """
+
+    scope = Scope.APP
+
+    def __init__(self, *, enabled: bool = True, prefix: str | None = None) -> None:
+        super().__init__()
+        self._enabled = enabled
+        self._prefix = prefix
+
+    @provide
+    def metrics(self) -> GrpcServerMetrics | None:
+        """Provide the concrete metrics instance (cached by prefix), or None when disabled/absent."""
+        if not self._enabled:
+            return None
+        if not HAS_PROMETHEUS:
+            logger.warning(
+                "gRPC server metrics are enabled but prometheus-client is not installed; "
+                "metrics are disabled (install grpc-server-kit[metrics] to enable them)"
+            )
+            return None
+        return get_grpc_server_metrics(self._prefix)
+
+    @provide
+    def metrics_protocol(self, metrics: GrpcServerMetrics | None) -> GrpcServerMetricsProtocol | None:
+        """Provide the protocol-typed view consumed by ``AsyncMetricsInterceptor``."""
+        return metrics
+
+
+__all__ = ["PrometheusGrpcServerMetricsProvider"]

grpc_server_kit/aio/dishka/observability.py

@@ -0,0 +1,86 @@
+"""Dishka providers for the Sentry / Tracer interceptor seams.
+
+These supply the protocol-typed ``... | None`` objects the Sentry/Tracing interceptors
+accept; they DO NOT initialize the SDKs (``sentry_sdk.init`` / OpenTelemetry provider
+setup are process-wide concerns owned by the application runtime, not DI). Each degrades
+to ``None`` when its extra is absent or disabled (the interceptor then no-ops).
+"""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+try:
+    from opentelemetry import trace
+
+    HAS_OTEL = True
+except ImportError:  # pragma: no cover - exercised only when the [tracing] extra is absent
+    HAS_OTEL = False
+
+from dishka import Provider, Scope, provide
+
+from grpc_server_kit.aio.interceptors.protocols import ErrorReporterProtocol, TracerProtocol
+from grpc_server_kit.observability.sentry import HAS_SENTRY, SentrySdkAdapter
+from grpc_server_kit.protocols import GrpcServiceName
+
+
+class SentryAdapterProvider(Provider):
+    """Provide an ``ErrorReporterProtocol`` seam for ``AsyncSentryInterceptor`` (None when disabled/absent)."""
+
+    scope = Scope.APP
+
+    def __init__(self, *, enabled: bool = True) -> None:
+        super().__init__()
+        self._enabled = enabled
+
+    @provide
+    def sentry(self) -> ErrorReporterProtocol | None:
+        """Provide the Sentry adapter, or None when disabled or ``[sentry]`` is absent."""
+        if not self._enabled or not HAS_SENTRY:
+            return None
+        return SentrySdkAdapter()
+
+
+class _OtelTracerAdapter:
+    """Adapt an OTel tracer to ``TracerProtocol`` with SDK auto-recording disabled.
+
+    OTel's ``start_as_current_span`` defaults to ``record_exception=True`` /
+    ``set_status_on_exception=True``, which would record a junk ``AbortError``
+    event (and force ERROR status) for every deliberate abort passing through
+    the span, and double-record genuine server errors. The kit's tracing
+    interceptor records exceptions selectively, so the SDK automation is off.
+    """
+
+    def __init__(self, tracer: Any) -> None:
+        self._tracer = tracer
+
+    def start_as_current_span(self, name: str) -> Any:
+        return self._tracer.start_as_current_span(
+            name,
+            record_exception=False,
+            set_status_on_exception=False,
+        )
+
+
+class TracerAdapterProvider(Provider):
+    """Provide a ``TracerProtocol`` seam for ``AsyncTracingInterceptor`` (None when disabled/absent).
+
+    When enabled and ``[tracing]`` is installed, supplies the process OpenTelemetry tracer
+    named after the service.
+    """
+
+    scope = Scope.APP
+
+    def __init__(self, *, enabled: bool = True) -> None:
+        super().__init__()
+        self._enabled = enabled
+
+    @provide
+    def tracer(self, service_name: GrpcServiceName) -> TracerProtocol | None:
+        """Provide the OTel tracer, or None when disabled or ``[tracing]`` is absent."""
+        if not self._enabled or not HAS_OTEL:
+            return None
+        return cast("TracerProtocol", _OtelTracerAdapter(trace.get_tracer(service_name)))
+
+
+__all__ = ["SentryAdapterProvider", "TracerAdapterProvider"]

grpc_server_kit/aio/dishka/server.py

@@ -0,0 +1,51 @@
+"""Dishka provider building the configured ``AsyncServer`` (``[dishka]`` extra)."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import grpc
+from dishka import Provider, Scope, provide
+
+from grpc_server_kit.aio.builder import AsyncGrpcServerBuilder
+from grpc_server_kit.aio.server import AsyncServer
+from grpc_server_kit.protocols import GrpcServerSettingsProtocol, GrpcServiceName
+
+
+class AsyncGrpcServerProvider(Provider):
+    """Provide an ``AsyncServer`` wired with interceptors, options, and reflection/channelz.
+
+    The server is returned WITHOUT servicers registered: register your servicers on
+    the resolved server after resolving it (servicer registration is service-specific and
+    usually needs other APP-scoped singletons). Reflection (when ``settings.enable_reflection``)
+    defaults to advertising only the service name — pass ``reflection_service_names``
+    explicitly to advertise more (e.g. the health service, once you register its servicer).
+    """
+
+    scope = Scope.APP
+
+    def __init__(self, *, reflection_service_names: Sequence[str] | None = None) -> None:
+        super().__init__()
+        self._reflection_service_names = list(reflection_service_names) if reflection_service_names else None
+
+    @provide
+    def server(
+        self,
+        settings: GrpcServerSettingsProtocol,
+        interceptors: list[grpc.aio.ServerInterceptor],
+        service_name: GrpcServiceName,
+    ) -> AsyncServer:
+        """Build the server from settings + the injected interceptor chain."""
+        builder = AsyncGrpcServerBuilder(settings).with_interceptors(interceptors)
+        if settings.enable_reflection:
+            # Only names whose servicers this bundle actually registers may be
+            # advertised by default — advertising the health service without a
+            # registered health servicer would reflect an UNIMPLEMENTED service.
+            names = self._reflection_service_names or [str(service_name)]
+            builder.with_reflection(names)
+        if settings.enable_channelz:
+            builder.with_channelz()
+        return builder.build()
+
+
+__all__ = ["AsyncGrpcServerProvider"]

grpc_server_kit/aio/health/__init__.py

@@ -0,0 +1,36 @@
+"""gRPC Health Checking Protocol v1 implementation (async).
+
+Gated behind the ``[health]`` extra (``grpcio-health-checking``). The Postgres and
+Redis checkers additionally require the ``[postgres]`` / ``[redis]`` extras.
+"""
+
+from .cache import HealthCache
+from .checkers import (
+    DatabaseHealthChecker,
+    FunctionalHealthChecker,
+    RedisClientProtocol,
+    RedisHealthChecker,
+    SessionMakerProtocol,
+    check_async_database_health,
+    check_async_redis_health,
+    handle_check_exceptions,
+)
+from .orchestrator import check_async_overall_health
+from .protocols import AsyncHealthCacheProtocol, AsyncHealthChecker
+from .servicer import AsyncDynamicHealthServicer
+
+__all__ = [
+    "AsyncDynamicHealthServicer",
+    "AsyncHealthCacheProtocol",
+    "AsyncHealthChecker",
+    "DatabaseHealthChecker",
+    "FunctionalHealthChecker",
+    "HealthCache",
+    "RedisClientProtocol",
+    "RedisHealthChecker",
+    "SessionMakerProtocol",
+    "check_async_database_health",
+    "check_async_overall_health",
+    "check_async_redis_health",
+    "handle_check_exceptions",
+]

grpc_server_kit/aio/health/cache.py

@@ -0,0 +1,89 @@
+"""Health status cache (async)."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from grpc_health.v1 import health_pb2
+
+from grpc_server_kit.constants import DEFAULT_HEALTH_CACHE_TTL
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+
+class HealthCache:
+    """TTL cache for health status with single-flight semantics.
+
+    :meth:`get_or_set` returns the cached status while it is fresh; on a cache
+    miss it runs ``check_func`` under a lock (double-checked locking), so only
+    one concurrent task performs the actual health check.
+
+    Note: This cache is designed for single event loop usage. Do not share
+    instances across different event loops.
+    """
+
+    def __init__(self, ttl: float = DEFAULT_HEALTH_CACHE_TTL) -> None:
+        """Initialize health cache.
+
+        Args:
+            ttl: Time-to-live for cached status in seconds. Must be positive.
+
+        Raises:
+            ValueError: If ttl is not positive.
+        """
+        if ttl <= 0:
+            raise ValueError(f"TTL must be positive, got {ttl}")
+        self._ttl = ttl
+        self._status: health_pb2.HealthCheckResponse.ServingStatus | None = None
+        self._last_check: float = 0.0
+        self._lock: asyncio.Lock | None = None
+
+    def _get_lock(self) -> asyncio.Lock:
+        # Created lazily so the cache can be constructed outside the event loop.
+        if self._lock is None:
+            self._lock = asyncio.Lock()
+        return self._lock
+
+    @staticmethod
+    def _now(now: float | None) -> float:
+        return now if now is not None else asyncio.get_running_loop().time()
+
+    def _get_fresh(self, now: float) -> health_pb2.HealthCheckResponse.ServingStatus | None:
+        if self._status is None:
+            return None
+        if (now - self._last_check) < self._ttl:
+            return self._status
+        return None
+
+    async def get_or_set(
+        self,
+        check_func: Callable[[], Awaitable[health_pb2.HealthCheckResponse.ServingStatus]],
+        now: float | None = None,
+    ) -> health_pb2.HealthCheckResponse.ServingStatus:
+        """Get the cached status or perform the check and cache the result.
+
+        The clock is re-read after waiting on the lock and again after the
+        check completes: waiters queued behind a slow check must validate
+        freshness against the check's COMPLETION time, otherwise a check
+        slower than the TTL produces entries that are expired at birth and the
+        cache degenerates into serialized re-checks.
+
+        Args:
+            check_func: Coroutine function performing the actual health check.
+            now: Optional fixed time (event-loop clock) — intended for tests.
+                When omitted, the clock is re-read at each step.
+        """
+        if (cached := self._get_fresh(self._now(now))) is not None:
+            return cached
+
+        async with self._get_lock():
+            if (cached := self._get_fresh(self._now(now))) is not None:
+                return cached
+
+            status = await check_func()
+            self._status = status
+            # Stamp AFTER the check so the entry's age starts at completion.
+            self._last_check = self._now(now)
+            return status

grpc_server_kit/aio/health/checkers/__init__.py

@@ -0,0 +1,16 @@
+"""Health checkers (async)."""
+
+from .postgres import DatabaseHealthChecker, SessionMakerProtocol, check_async_database_health
+from .redis import RedisClientProtocol, RedisHealthChecker, check_async_redis_health
+from .utils import FunctionalHealthChecker, handle_check_exceptions
+
+__all__ = [
+    "DatabaseHealthChecker",
+    "FunctionalHealthChecker",
+    "RedisClientProtocol",
+    "RedisHealthChecker",
+    "SessionMakerProtocol",
+    "check_async_database_health",
+    "check_async_redis_health",
+    "handle_check_exceptions",
+]

grpc_server_kit/aio/health/checkers/postgres.py

@@ -0,0 +1,115 @@
+"""Database health checker (async).
+
+Depends only on raw SQLAlchemy (the ``[postgres]`` extra). Compatible with any
+async session maker following the ``async_sessionmaker`` pattern.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+from typing import TYPE_CHECKING, Protocol
+
+from grpc_server_kit.constants import DEFAULT_CHECKER_TIMEOUT
+
+from .utils import FunctionalHealthChecker, handle_check_exceptions
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+try:
+    from sqlalchemy import text
+
+    SQLALCHEMY_AVAILABLE = True
+except ImportError:  # pragma: no cover - exercised only when the [postgres] extra is absent
+    SQLALCHEMY_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_DB_CHECK_TIMEOUT = DEFAULT_CHECKER_TIMEOUT
+
+# Session cleanup (rollback/close) gets its own short deadline: a dead
+# connection must not hold the health check past its budget, and a slow pool
+# return must not convert a successful probe into a timeout.
+_CLEANUP_TIMEOUT = 1.0
+
+
+class SessionMakerProtocol(Protocol):
+    """Protocol for SQLAlchemy async session makers.
+
+    Follows the standard async_sessionmaker pattern from SQLAlchemy. Compatible
+    with any callable that returns an async context manager providing an AsyncSession.
+    """
+
+    def __call__(self) -> contextlib.AbstractAsyncContextManager[AsyncSession]:
+        """Create a new async database session."""
+        ...
+
+
+class DatabaseHealthChecker(FunctionalHealthChecker):
+    """Health checker for SQLAlchemy async databases.
+
+    Performs a connectivity check by executing a simple ``SELECT 1`` query with a
+    configurable timeout.
+    """
+
+    def __init__(self, session_maker: SessionMakerProtocol, timeout: float = DEFAULT_DB_CHECK_TIMEOUT) -> None:
+        """Initialize database health checker.
+
+        Args:
+            session_maker: SQLAlchemy async session maker.
+            timeout: Maximum time to wait for database response in seconds.
+
+        Raises:
+            ValueError: If timeout is not positive.
+        """
+        super().__init__(check_async_database_health, session_maker, timeout)
+
+
+@handle_check_exceptions("Database")
+async def check_async_database_health(
+    session_maker: SessionMakerProtocol | None,
+    timeout: float = DEFAULT_DB_CHECK_TIMEOUT,
+) -> bool:
+    """Check async database connectivity with timeout.
+
+    Executes a simple ``SELECT 1`` query to verify the database is reachable and
+    responsive. The timeout covers session acquisition and the query; session
+    cleanup runs under its own short deadline so a dead connection cannot hang
+    the check and a slow cleanup cannot fail a successful probe.
+
+    Args:
+        session_maker: SQLAlchemy session maker to check. If None, returns True (no database configured).
+        timeout: Maximum time to wait for database response in seconds.
+
+    Returns:
+        True if database is healthy or session_maker is None, False otherwise.
+
+    Note:
+        If SQLAlchemy is not installed, this function logs a debug message and returns True,
+        allowing the service to run without database health checks.
+    """
+    if session_maker is None:
+        return True
+
+    if not SQLALCHEMY_AVAILABLE:
+        logger.debug("SQLAlchemy not installed, skipping database health check")
+        return True
+
+    session_cm = session_maker()
+    async with asyncio.timeout(timeout):
+        session = await session_cm.__aenter__()
+
+    try:
+        async with asyncio.timeout(timeout):
+            await session.execute(text("SELECT 1"))
+        return True
+    finally:
+        try:
+            async with asyncio.timeout(_CLEANUP_TIMEOUT):
+                await session_cm.__aexit__(None, None, None)
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.debug("Database health-check session cleanup failed", exc_info=True)

grpc_server_kit/aio/health/checkers/redis.py

@@ -0,0 +1,88 @@
+"""Redis health checker (async).
+
+The checker is fully duck-typed: it only requires the passed client to expose an
+async ``ping()`` (the redis-py async interface), so this module imports nothing
+Redis-specific. Install the ``[redis]`` extra to get ``redis`` for your client.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+from collections.abc import Awaitable
+from typing import Protocol
+
+from grpc_server_kit.constants import DEFAULT_CHECKER_TIMEOUT
+
+from .utils import FunctionalHealthChecker, handle_check_exceptions
+
+DEFAULT_REDIS_CHECK_TIMEOUT = DEFAULT_CHECKER_TIMEOUT
+
+
+class RedisClientProtocol(Protocol):
+    """Protocol for a Redis client compatible with the redis-py async interface.
+
+    Supports both single instance and clustered Redis clients (any object exposing
+    an async ``ping``).
+    """
+
+    def ping(self, **kwargs: object) -> Awaitable[bool | dict[str, bool]] | bool | dict[str, bool]:
+        """Ping the Redis server to check connectivity.
+
+        Returns:
+            For a single instance: True if ping was successful.
+            For clustered clients: a dict mapping node names to their ping results.
+        """
+        ...
+
+    async def aclose(self) -> None:
+        """Close the Redis client."""
+        ...
+
+
+class RedisHealthChecker(FunctionalHealthChecker):
+    """Health checker for Redis connectivity.
+
+    Performs a connectivity check by pinging Redis with a configurable timeout.
+    Compatible with both single instance and clustered Redis deployments.
+    """
+
+    def __init__(self, redis_client: RedisClientProtocol, timeout: float = DEFAULT_REDIS_CHECK_TIMEOUT) -> None:
+        """Initialize Redis health checker.
+
+        Args:
+            redis_client: Redis client instance implementing RedisClientProtocol.
+            timeout: Maximum time to wait for Redis response in seconds.
+
+        Raises:
+            ValueError: If timeout is not positive.
+        """
+        super().__init__(check_async_redis_health, redis_client, timeout)
+
+
+@handle_check_exceptions("Redis")
+async def check_async_redis_health(
+    redis_client: RedisClientProtocol | None,
+    timeout: float = DEFAULT_REDIS_CHECK_TIMEOUT,
+) -> bool:
+    """Check async Redis connectivity with a timeout via PING.
+
+    Args:
+        redis_client: Redis client to check. If None, returns True (no Redis configured).
+        timeout: Maximum time to wait for Redis response in seconds.
+
+    Returns:
+        True if Redis is healthy or redis_client is None, False otherwise.
+    """
+    if redis_client is None:
+        return True
+
+    async with asyncio.timeout(timeout):
+        result = redis_client.ping()
+        if inspect.isawaitable(result):
+            result = await result
+        if isinstance(result, dict):
+            # Clustered clients return per-node results; every node must be up.
+            # An empty dict means no reachable nodes — unhealthy.
+            return bool(result) and all(result.values())
+        return bool(result)