redis-client-kit 0.1.2__tar.gz → 0.1.4__tar.gz

{redis_client_kit-0.1.2 → redis_client_kit-0.1.4}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.1.4](https://github.com/bedrock-python/redis-client-kit/compare/redis-client-kit-v0.1.3...redis-client-kit-v0.1.4) (2026-09-07)
+
+
+### Bug Fixes
+
+* hand redis-py a zero-retry Retry when retries are disabled ([#27](https://github.com/bedrock-python/redis-client-kit/issues/27)) ([02d4f55](https://github.com/bedrock-python/redis-client-kit/commit/02d4f5590b6bcdc26d8d13c81cfc80bfd3551f1a))
+
+## [0.1.3](https://github.com/bedrock-python/redis-client-kit/compare/redis-client-kit-v0.1.2...redis-client-kit-v0.1.3) (2026-09-06)
+
+
+### Bug Fixes
+
+* fail startup on an unreachable Redis, and count translated errors as errors ([#23](https://github.com/bedrock-python/redis-client-kit/issues/23)) ([38187bb](https://github.com/bedrock-python/redis-client-kit/commit/38187bb202f14e8f893e7597926f0cb3cb750b80))
+
 ## [0.1.2](https://github.com/bedrock-python/redis-client-kit/compare/redis-client-kit-v0.1.1...redis-client-kit-v0.1.2) (2026-09-05)
 
 

{redis_client_kit-0.1.2 → redis_client_kit-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: redis-client-kit
-Version: 0.1.2
+Version: 0.1.4
 Summary: Redis client with optional Pydantic, Prometheus, and Dishka support
 Project-URL: Repository, https://github.com/bedrock-python/redis-client-kit
 Project-URL: Documentation, https://bedrock-python.github.io/redis-client-kit/
@@ -249,6 +249,15 @@ Production-ready Redis client with optional Pydantic settings, Prometheus metric
 [![codecov](https://codecov.io/gh/bedrock-python/redis-client-kit/graph/badge.svg)](https://codecov.io/gh/bedrock-python/redis-client-kit)
 [![Docs](https://img.shields.io/badge/docs-online-blue)](https://bedrock-python.github.io/redis-client-kit/)
 
+> [!TIP]
+> **Building this with an AI assistant?** Hand it
+> **[one page](https://bedrock-python.github.io/redis-client-kit/agents/)** instead of the
+> whole site: the public API of both the async and the sync side, what each extra turns on,
+> every setting with the default it actually has, the rules that break code when they are
+> broken, the mistakes models make with this API, and a map of which page to fetch for the
+> rest. Every docs page is also served as raw Markdown at its own URL, and a **Copy page**
+> button at the top of each one hands it straight to a chat window.
+
 ## Features
 
 | Feature | Included | Extra Required |
@@ -530,10 +539,11 @@ settings = BaseRedisSettings(
 
 Full documentation: [bedrock-python.github.io/redis-client-kit](https://bedrock-python.github.io/redis-client-kit/)
 
+- [For AI agents](https://bedrock-python.github.io/redis-client-kit/agents/) — the whole library on one page
 - [Quick Start Guide](https://bedrock-python.github.io/redis-client-kit/guide/quickstart/)
 - [Configuration Guide](https://bedrock-python.github.io/redis-client-kit/guide/configuration/)
 - [Advanced Usage](https://bedrock-python.github.io/redis-client-kit/guide/advanced/)
-- [API Reference](https://bedrock-python.github.io/redis-client-kit/reference/api/)
+- [API Reference](https://bedrock-python.github.io/redis-client-kit/reference/)
 
 ## Contributing
 

{redis_client_kit-0.1.2 → redis_client_kit-0.1.4}/README.md

@@ -9,6 +9,15 @@ Production-ready Redis client with optional Pydantic settings, Prometheus metric
 [![codecov](https://codecov.io/gh/bedrock-python/redis-client-kit/graph/badge.svg)](https://codecov.io/gh/bedrock-python/redis-client-kit)
 [![Docs](https://img.shields.io/badge/docs-online-blue)](https://bedrock-python.github.io/redis-client-kit/)
 
+> [!TIP]
+> **Building this with an AI assistant?** Hand it
+> **[one page](https://bedrock-python.github.io/redis-client-kit/agents/)** instead of the
+> whole site: the public API of both the async and the sync side, what each extra turns on,
+> every setting with the default it actually has, the rules that break code when they are
+> broken, the mistakes models make with this API, and a map of which page to fetch for the
+> rest. Every docs page is also served as raw Markdown at its own URL, and a **Copy page**
+> button at the top of each one hands it straight to a chat window.
+
 ## Features
 
 | Feature | Included | Extra Required |
@@ -290,10 +299,11 @@ settings = BaseRedisSettings(
 
 Full documentation: [bedrock-python.github.io/redis-client-kit](https://bedrock-python.github.io/redis-client-kit/)
 
+- [For AI agents](https://bedrock-python.github.io/redis-client-kit/agents/) — the whole library on one page
 - [Quick Start Guide](https://bedrock-python.github.io/redis-client-kit/guide/quickstart/)
 - [Configuration Guide](https://bedrock-python.github.io/redis-client-kit/guide/configuration/)
 - [Advanced Usage](https://bedrock-python.github.io/redis-client-kit/guide/advanced/)
-- [API Reference](https://bedrock-python.github.io/redis-client-kit/reference/api/)
+- [API Reference](https://bedrock-python.github.io/redis-client-kit/reference/)
 
 ## Contributing
 

{redis_client_kit-0.1.2 → redis_client_kit-0.1.4}/pyproject.toml

@@ -102,6 +102,10 @@ warn_unreachable = true
 [tool.ruff]
 line-length = 120
 target-version = "py310"
+# The Markdown guides hold fragments -- a keyword argument on its own, a body
+# without its def -- that read as code to a formatter and come out as
+# something else. ruff 0.16 formats fenced Python in Markdown by default.
+extend-exclude = ["*.md"]
 
 [tool.ruff.lint]
 select = ["F", "E", "W", "I", "B", "N", "S", "C4", "DTZ", "SIM", "TRY", "PERF", "RUF", "UP", "ANN", "T20", "PTH", "PLC", "PLE", "PLW"]
@@ -136,8 +140,6 @@ omit = [
     "*/test_*.py",
     "*/_deps.py",
     "redis_client_kit/metrics/redis.py",
-    "redis_client_kit/providers/redis.py",
-    "redis_client_kit/providers/utils.py",
 ]
 
 [tool.coverage.report]

{redis_client_kit-0.1.2 → redis_client_kit-0.1.4}/redis_client_kit/__init__.py

@@ -24,7 +24,7 @@ from .utils import build_base_redis_kwargs, build_redis_retry, parse_redis_url_n
 try:
     __version__ = version("redis-client-kit")
 except PackageNotFoundError:  # pragma: no cover
-    __version__ = "0.1.2"
+    __version__ = "0.1.4"
 
 # ruff: noqa: RUF022
 __all__ = [

redis_client_kit-0.1.4/redis_client_kit/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.4"

{redis_client_kit-0.1.2 → redis_client_kit-0.1.4}/redis_client_kit/aio/instrumented.py

@@ -15,6 +15,27 @@ from ..protocols import RedisMetricsProtocol
 logger = logging.getLogger(__name__)
 
 
+def _translate_closed_transport(error: RuntimeError) -> RedisConnectionError | None:
+    """Translate a uvloop closed-transport RuntimeError into a Redis ConnectionError.
+
+    uvloop raises RuntimeError when the transport is closed but still being used.
+    redis-py only handles its own ConnectionError (retry or reconnect), so the error
+    is translated. Returns None for any other RuntimeError.
+    """
+    message = str(error).lower()
+    if "the handler is closed" in message or "transport is closed" in message:
+        return RedisConnectionError(str(error))
+    return None
+
+
+def _record_error(metrics: RedisMetricsProtocol, error: BaseException) -> None:
+    """Record an error without letting the metrics backend break the command."""
+    try:
+        metrics.record_error(error_type=type(error).__name__)
+    except Exception:
+        logger.exception("Failed to record Redis error metrics")
+
+
 class InstrumentedRedis(Redis):
     """Redis client with Prometheus metrics collection."""
 
@@ -32,10 +53,12 @@ class InstrumentedRedis(Redis):
         pool = self.connection_pool
         if pool:
             try:
-                # redis-py async pool has _all_connections and _in_use_connections
+                # redis-py async pool has _available_connections and _in_use_connections
+                available: list[Any] = getattr(pool, "_available_connections", [])
+                in_use: set[Any] = getattr(pool, "_in_use_connections", set())
                 self._metrics.record_pool_stats(
-                    pool_size=len(getattr(pool, "_all_connections", [])),
-                    pool_checked_out=len(getattr(pool, "_in_use_connections", [])),
+                    pool_size=len(available) + len(in_use),
+                    pool_checked_out=len(in_use),
                 )
             except Exception:
                 logger.exception("Failed to record Redis pool metrics")
@@ -43,18 +66,15 @@ class InstrumentedRedis(Redis):
         try:
             return await super().execute_command(*args, **options)
         except RuntimeError as e:
-            # uvloop raises RuntimeError when transport is closed but still being used.
-            # We translate it to ConnectionError so redis-py can handle it (retry or reconnect).
-            if "the handler is closed" in str(e).lower() or "transport is closed" in str(e).lower():
-                raise RedisConnectionError(str(e)) from e
+            status = "error"
+            translated = _translate_closed_transport(e)
+            _record_error(self._metrics, translated or e)
+            if translated is not None:
+                raise translated from e
             raise
         except Exception as e:
             status = "error"
-            error_type = type(e).__name__
-            try:
-                self._metrics.record_error(error_type=error_type)
-            except Exception:
-                logger.exception("Failed to record Redis error metrics")
+            _record_error(self._metrics, e)
             raise
         finally:
             duration = time.perf_counter() - start
@@ -86,18 +106,15 @@ class InstrumentedRedisCluster(RedisCluster):
         try:
             return await super().execute_command(*args, **options)
         except RuntimeError as e:
-            # uvloop raises RuntimeError when transport is closed but still being used.
-            # We translate it to ConnectionError so redis-py can handle it (retry or reconnect).
-            if "the handler is closed" in str(e).lower() or "transport is closed" in str(e).lower():
-                raise RedisConnectionError(str(e)) from e
+            status = "error"
+            translated = _translate_closed_transport(e)
+            _record_error(self._metrics, translated or e)
+            if translated is not None:
+                raise translated from e
             raise
         except Exception as e:
             status = "error"
-            error_type = type(e).__name__
-            try:
-                self._metrics.record_error(error_type=error_type)
-            except Exception:
-                logger.exception("Failed to record Redis error metrics")
+            _record_error(self._metrics, e)
             raise
         finally:
             duration = time.perf_counter() - start

{redis_client_kit-0.1.2 → redis_client_kit-0.1.4}/redis_client_kit/providers/redis.py

@@ -9,7 +9,7 @@ from redis.exceptions import RedisError
 from ..aio import AsyncRedisClient, check_async_redis_health, close_async_redis_client, create_async_redis_client
 from ..config import RedisSettingsProtocol
 from ..protocols import RedisMetricsProtocol
-from ._deps import Provider, Scope, provide
+from ._deps import Provider, Scope
 from .utils import retry_async_connection, safe_async_cleanup
 
 logger = logging.getLogger(__name__)
@@ -18,17 +18,39 @@ logger = logging.getLogger(__name__)
 class AsyncRedisProvider(Provider):  # type: ignore[misc]
     """Dishka provider for Redis dependencies.
 
-    Provides two Redis client options:
-    - get_redis(): Simple client without startup health check
-    - get_redis_with_health_check(): Client with connection verification and retries
+    Provides one ``AsyncRedisClient``, chosen when the provider is constructed:
 
-    Choose get_redis() for faster startup when Redis availability is not critical.
-    Choose get_redis_with_health_check() for guaranteed connection on startup.
+    - ``AsyncRedisProvider()`` verifies the connection on startup with retries and
+      raises when Redis stays unreachable, so startup fails instead of handing out
+      a client that cannot answer.
+    - ``AsyncRedisProvider(check_health_on_startup=False)`` yields the client without
+      contacting Redis, for a faster startup when Redis availability is not critical.
+
+    It also provides ``RedisMetricsProtocol | None`` as ``None`` so a container with no
+    metrics provider still resolves. Dishka lets the last registered provider of a type
+    win, so this default overrides a metrics provider registered before it: either
+    register this provider first, or construct it with ``provide_default_metrics=False``.
     """
 
     scope = Scope.APP  # type: ignore[misc]
 
-    @provide  # type: ignore[misc]
+    def __init__(
+        self,
+        *,
+        check_health_on_startup: bool = True,
+        provide_default_metrics: bool = True,
+    ) -> None:
+        """Register the client factory, and the default metrics factory when asked to.
+
+        Args:
+            check_health_on_startup: Verify the connection before yielding the client
+            provide_default_metrics: Provide ``RedisMetricsProtocol | None`` as ``None``
+        """
+        super().__init__()
+        self.provide(self.get_redis_with_health_check if check_health_on_startup else self.get_redis)
+        if provide_default_metrics:
+            self.provide(self.get_default_metrics)
+
     async def get_redis(
         self,
         redis_settings: RedisSettingsProtocol,
@@ -57,7 +79,6 @@ class AsyncRedisProvider(Provider):  # type: ignore[misc]
                 exception_type=RedisError,
             )
 
-    @provide  # type: ignore[misc]
     async def get_redis_with_health_check(
         self,
         redis_settings: RedisSettingsProtocol,
@@ -76,14 +97,22 @@ class AsyncRedisProvider(Provider):  # type: ignore[misc]
             Configured and verified AsyncRedisClient instance
 
         Raises:
-            Exception: If connection fails after max retry attempts
+            ConnectionError: If Redis is still unreachable after the last attempt
         """
         client = create_async_redis_client(redis_settings, metrics=metrics)
 
-        await retry_async_connection(
-            connect_func=lambda: check_async_redis_health(client),
-            service_name="Redis",
-        )
+        try:
+            await retry_async_connection(
+                connect_func=lambda: check_async_redis_health(client),
+                service_name="Redis",
+            )
+        except BaseException:
+            await safe_async_cleanup(
+                cleanup_func=functools.partial(close_async_redis_client, client),
+                service_name="Redis client",
+                exception_type=RedisError,
+            )
+            raise
 
         try:
             yield client
@@ -94,7 +123,6 @@ class AsyncRedisProvider(Provider):  # type: ignore[misc]
                 exception_type=RedisError,
             )
 
-    @provide  # type: ignore[misc]
     def get_default_metrics(self) -> RedisMetricsProtocol | None:
         """Provide default None for metrics if not provided in container."""
         return None

redis_client_kit-0.1.4/redis_client_kit/providers/utils.py

@@ -0,0 +1,71 @@
+"""Provider utility functions for connection retry and cleanup."""
+
+import asyncio
+import logging
+from collections.abc import Awaitable, Callable
+
+logger = logging.getLogger(__name__)
+
+
+async def retry_async_connection(
+    connect_func: Callable[[], Awaitable[bool]],
+    service_name: str,
+    max_attempts: int = 3,
+    backoff_base: float = 1.0,
+) -> None:
+    """Retry async connection with exponential backoff.
+
+    An attempt fails when connect_func raises or returns a falsy value; both are
+    retried with the same backoff.
+
+    Args:
+        connect_func: Callable returning True once the service is reachable
+        service_name: Name used in log messages and in the raised error
+        max_attempts: Number of attempts before giving up
+        backoff_base: Base of the exponential backoff in seconds
+
+    Raises:
+        ConnectionError: If no attempt reported success and none of them raised.
+        Exception: The error raised by the last attempt, if it raised one.
+    """
+    for attempt in range(1, max_attempts + 1):
+        error: Exception
+        try:
+            if await connect_func():
+                logger.info("%s connected successfully", service_name)
+                return
+            error = ConnectionError(f"{service_name} did not report a healthy connection")
+        except Exception as e:
+            error = e
+
+        if attempt == max_attempts:
+            raise error
+
+        wait_time = backoff_base * (2 ** (attempt - 1))
+        logger.warning(
+            "%s connection failed (attempt %d/%d), retrying in %ss: %s",
+            service_name,
+            attempt,
+            max_attempts,
+            wait_time,
+            error,
+        )
+        await asyncio.sleep(wait_time)
+
+
+async def safe_async_cleanup(
+    cleanup_func: Callable[[], Awaitable[None]],
+    service_name: str,
+    exception_type: type[Exception],
+) -> None:
+    """Safely cleanup async resource."""
+    try:
+        await cleanup_func()
+        logger.info("%s cleaned up successfully", service_name)
+    except exception_type as e:
+        logger.warning("%s cleanup failed: %s", service_name, e)
+    except Exception:
+        logger.exception("Unexpected error during %s cleanup", service_name)
+
+
+__all__ = ["retry_async_connection", "safe_async_cleanup"]

{redis_client_kit-0.1.2 → redis_client_kit-0.1.4}/redis_client_kit/settings/redis.py

@@ -116,4 +116,12 @@ class BaseRedisSettings(BaseSettings):
         return self
 
 
-__all__ = ["BaseRedisSettings"]
+__all__ = [
+    "BaseRedisSettings",
+    "RedisClusterSettings",
+    "RedisConnectionSettings",
+    "RedisPoolSettings",
+    "RedisResponseSettings",
+    "RedisRetrySettings",
+    "RedisSSLSettings",
+]

{redis_client_kit-0.1.2 → redis_client_kit-0.1.4}/redis_client_kit/sync/instrumented.py

@@ -15,6 +15,26 @@ from ..protocols import RedisMetricsProtocol
 logger = logging.getLogger(__name__)
 
 
+def _translate_closed_transport(error: RuntimeError) -> RedisConnectionError | None:
+    """Translate a closed-transport RuntimeError into a Redis ConnectionError.
+
+    redis-py only handles its own ConnectionError (retry or reconnect), so the error
+    is translated. Returns None for any other RuntimeError.
+    """
+    message = str(error).lower()
+    if "the handler is closed" in message or "transport is closed" in message:
+        return RedisConnectionError(str(error))
+    return None
+
+
+def _record_error(metrics: RedisMetricsProtocol, error: BaseException) -> None:
+    """Record an error without letting the metrics backend break the command."""
+    try:
+        metrics.record_error(error_type=type(error).__name__)
+    except Exception:
+        logger.exception("Failed to record Redis error metrics")
+
+
 class InstrumentedRedis(Redis):
     """Redis client with Prometheus metrics collection."""
 
@@ -46,17 +66,15 @@ class InstrumentedRedis(Redis):
         try:
             return super().execute_command(*args, **options)
         except RuntimeError as e:
-            # Handle closed connection errors
-            if "the handler is closed" in str(e).lower() or "transport is closed" in str(e).lower():
-                raise RedisConnectionError(str(e)) from e
+            status = "error"
+            translated = _translate_closed_transport(e)
+            _record_error(self._metrics, translated or e)
+            if translated is not None:
+                raise translated from e
             raise
         except Exception as e:
             status = "error"
-            error_type = type(e).__name__
-            try:
-                self._metrics.record_error(error_type=error_type)
-            except Exception:
-                logger.exception("Failed to record Redis error metrics")
+            _record_error(self._metrics, e)
             raise
         finally:
             duration = time.perf_counter() - start
@@ -88,17 +106,15 @@ class InstrumentedRedisCluster(RedisCluster):
         try:
             return super().execute_command(*args, **options)
         except RuntimeError as e:
-            # Handle closed connection errors
-            if "the handler is closed" in str(e).lower() or "transport is closed" in str(e).lower():
-                raise RedisConnectionError(str(e)) from e
+            status = "error"
+            translated = _translate_closed_transport(e)
+            _record_error(self._metrics, translated or e)
+            if translated is not None:
+                raise translated from e
             raise
         except Exception as e:
             status = "error"
-            error_type = type(e).__name__
-            try:
-                self._metrics.record_error(error_type=error_type)
-            except Exception:
-                logger.exception("Failed to record Redis error metrics")
+            _record_error(self._metrics, e)
             raise
         finally:
             duration = time.perf_counter() - start

{redis_client_kit-0.1.2 → redis_client_kit-0.1.4}/redis_client_kit/utils.py

@@ -5,7 +5,7 @@ import binascii
 from pathlib import Path
 from urllib.parse import urlparse
 
-from redis.backoff import ExponentialBackoff
+from redis.backoff import ExponentialBackoff, NoBackoff
 from redis.retry import Retry
 
 from .config import RedisSettingsProtocol
@@ -36,8 +36,6 @@ def parse_redis_url_node(node: str) -> tuple[str, int]:
 
 def build_base_redis_kwargs(settings: RedisSettingsProtocol) -> dict[str, object]:
     """Build base Redis client keyword arguments."""
-    retry = build_redis_retry(settings)
-
     if settings.ssl.enabled:
         if settings.ssl.ca_certs:
             _validate_pem_format(settings.ssl.ca_certs, "CERTIFICATE")
@@ -54,6 +52,7 @@ def build_base_redis_kwargs(settings: RedisSettingsProtocol) -> dict[str, object
         "socket_keepalive": settings.pool.socket_keepalive,
         "socket_keepalive_options": settings.pool.socket_keepalive_options,
         "health_check_interval": settings.health_check_interval,
+        "retry": build_redis_retry(settings),
         "decode_responses": settings.response.decode_responses,
         "encoding": settings.response.encoding,
         "client_name": settings.connection.client_name,
@@ -70,14 +69,16 @@ def build_base_redis_kwargs(settings: RedisSettingsProtocol) -> dict[str, object
         kwargs["require_full_coverage"] = settings.cluster.require_full_coverage
         kwargs["read_from_replicas"] = settings.cluster.read_from_replicas
 
-    if retry is not None:
-        kwargs["retry"] = retry
-
     return kwargs
 
 
-def build_redis_retry(settings: RedisSettingsProtocol) -> Retry | None:
-    """Build Redis Retry object from settings."""
+def build_redis_retry(settings: RedisSettingsProtocol) -> Retry:
+    """Build Redis Retry object from settings.
+
+    Retries are off unless both ``retry.enabled`` and ``retry.max_attempts`` are set. Off is
+    still a ``Retry``, with zero retries: handed nothing, redis-py retries on its own (three
+    times since 6.0, ten since 8.0, with jittered backoff).
+    """
     if settings.retry.enabled and settings.retry.max_attempts:
         return Retry(
             backoff=ExponentialBackoff(
@@ -86,7 +87,7 @@ def build_redis_retry(settings: RedisSettingsProtocol) -> Retry | None:
             ),
             retries=settings.retry.max_attempts,
         )
-    return None
+    return Retry(backoff=NoBackoff(), retries=0)
 
 
 def _validate_pem_format(path: str | Path, file_type: str) -> None:
@@ -116,3 +117,11 @@ def mask_redis_kwargs(kwargs: dict[str, object]) -> dict[str, object]:
     if masked.get("password"):
         masked["password"] = "********"
     return masked
+
+
+__all__ = [
+    "build_base_redis_kwargs",
+    "build_redis_retry",
+    "mask_redis_kwargs",
+    "parse_redis_url_node",
+]

redis_client_kit-0.1.2/redis_client_kit/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.1.2"

redis_client_kit-0.1.2/redis_client_kit/providers/utils.py

@@ -1,52 +0,0 @@
-"""Provider utility functions for connection retry and cleanup."""
-
-import asyncio
-import logging
-from collections.abc import Awaitable, Callable
-
-logger = logging.getLogger(__name__)
-
-
-async def retry_async_connection(
-    connect_func: Callable[[], Awaitable[bool]],
-    service_name: str,
-    max_attempts: int = 3,
-    backoff_base: float = 1.0,
-) -> None:
-    """Retry async connection with exponential backoff."""
-    for attempt in range(1, max_attempts + 1):
-        try:
-            if await connect_func():
-                logger.info("%s connected successfully", service_name)
-                return
-        except Exception as e:
-            if attempt == max_attempts:
-                raise
-            wait_time = backoff_base * (2 ** (attempt - 1))
-            logger.warning(
-                "%s connection failed (attempt %d/%d), retrying in %ss: %s",
-                service_name,
-                attempt,
-                max_attempts,
-                wait_time,
-                e,
-            )
-            await asyncio.sleep(wait_time)
-
-
-async def safe_async_cleanup(
-    cleanup_func: Callable[[], Awaitable[None]],
-    service_name: str,
-    exception_type: type[Exception],
-) -> None:
-    """Safely cleanup async resource."""
-    try:
-        await cleanup_func()
-        logger.info("%s cleaned up successfully", service_name)
-    except exception_type as e:
-        logger.warning("%s cleanup failed: %s", service_name, e)
-    except Exception:
-        logger.exception("Unexpected error during %s cleanup", service_name)
-
-
-__all__ = ["retry_async_connection", "safe_async_cleanup"]