Skip to content

AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.

fix(backend): Make Redis connection lazy in cache module (#11775)

Zamil Majdy5ff669e9996c
diff --git a/autogpt_platform/backend/backend/util/cache.py b/autogpt_platform/backend/backend/util/cache.py
index 757ba45b42..38c3667951 100644
--- a/autogpt_platform/backend/backend/util/cache.py
+++ b/autogpt_platform/backend/backend/util/cache.py
@@ -16,7 +16,7 @@ import pickle
import threading
import time
from dataclasses import dataclass
-from functools import wraps
+from functools import cache, wraps
from typing import Any, Callable, ParamSpec, Protocol, TypeVar, cast, runtime_checkable
from redis import ConnectionPool, Redis
@@ -38,29 +38,34 @@ settings = Settings()
# maxmemory 2gb # Set memory limit (adjust based on your needs)
# save "" # Disable persistence if using Redis purely for caching
-# Create a dedicated Redis connection pool for caching (binary mode for pickle)
-_cache_pool: ConnectionPool | None = None
-
-@conn_retry("Redis", "Acquiring cache connection pool")
+@cache
def _get_cache_pool() -> ConnectionPool:
- """Get or create a connection pool for cache operations."""
- global _cache_pool
- if _cache_pool is None:
- _cache_pool = ConnectionPool(
- host=settings.config.redis_host,
- port=settings.config.redis_port,
- password=settings.config.redis_password or None,
- decode_responses=False, # Binary mode for pickle
- max_connections=50,
- socket_keepalive=True,
- socket_connect_timeout=5,
- retry_on_timeout=True,
- )
- return _cache_pool
-
-
-redis = Redis(connection_pool=_get_cache_pool())
+ """Get or create a connection pool for cache operations (lazy, thread-safe)."""
+ return ConnectionPool(
+ host=settings.config.redis_host,
+ port=settings.config.redis_port,
+ password=settings.config.redis_password or None,
+ decode_responses=False, # Binary mode for pickle
+ max_connections=50,
+ socket_keepalive=True,
+ socket_connect_timeout=5,
+ retry_on_timeout=True,
+ )
+
+
+@cache
+@conn_retry("Redis", "Acquiring cache connection")
+def _get_redis() -> Redis:
+ """
+ Get the lazily-initialized Redis client for shared cache operations.
+ Uses @cache for thread-safe singleton behavior - connection is only
+ established when first accessed, allowing services that only use
+ in-memory caching to work without Redis configuration.
+ """
+ r = Redis(connection_pool=_get_cache_pool())
+ r.ping() # Verify connection
+ return r
@dataclass
@@ -179,9 +184,9 @@ def cached(
try:
if refresh_ttl_on_get:
# Use GETEX to get value and refresh expiry atomically
- cached_bytes = redis.getex(redis_key, ex=ttl_seconds)
+ cached_bytes = _get_redis().getex(redis_key, ex=ttl_seconds)
else:
- cached_bytes = redis.get(redis_key)
+ cached_bytes = _get_redis().get(redis_key)
if cached_bytes and isinstance(cached_bytes, bytes):
return pickle.loads(cached_bytes)
@@ -195,7 +200,7 @@ def cached(
"""Set value in Redis with TTL."""
try:
pickled_value = pickle.dumps(value, protocol=pickle.HIGHEST_PROTOCOL)
- redis.setex(redis_key, ttl_seconds, pickled_value)
+ _get_redis().setex(redis_key, ttl_seconds, pickled_value)
except Exception as e:
logger.error(
f"Redis error storing cache for {target_func.__name__}: {e}"
@@ -333,14 +338,18 @@ def cached(
if pattern:
# Clear entries matching pattern
keys = list(
- redis.scan_iter(f"cache:{target_func.__name__}:{pattern}")
+ _get_redis().scan_iter(
+ f"cache:{target_func.__name__}:{pattern}"
+ )
)
else:
# Clear all cache keys
- keys = list(redis.scan_iter(f"cache:{target_func.__name__}:*"))
+ keys = list(
+ _get_redis().scan_iter(f"cache:{target_func.__name__}:*")
+ )
if keys:
- pipeline = redis.pipeline()
+ pipeline = _get_redis().pipeline()
for key in keys:
pipeline.delete(key)
pipeline.execute()
@@ -355,7 +364,9 @@ def cached(
def cache_info() -> dict[str, int | None]:
if shared_cache:
- cache_keys = list(redis.scan_iter(f"cache:{target_func.__name__}:*"))
+ cache_keys = list(
+ _get_redis().scan_iter(f"cache:{target_func.__name__}:*")
+ )
return {
"size": len(cache_keys),
"maxsize": None, # Redis manages its own size
@@ -373,10 +384,8 @@ def cached(
key = _make_hashable_key(args, kwargs)
if shared_cache:
redis_key = _make_redis_key(key, target_func.__name__)
- if redis.exists(redis_key):
- redis.delete(redis_key)
- return True
- return False
+ deleted_count = cast(int, _get_redis().delete(redis_key))
+ return deleted_count > 0
else:
if key in cache_storage:
del cache_storage[key]