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.

feat(platform): Shared cache (#11150)

Swifty2c6d85d15e3e
diff --git a/autogpt_platform/autogpt_libs/autogpt_libs/utils/cache.py b/autogpt_platform/autogpt_libs/autogpt_libs/utils/cache.py
deleted file mode 100644
index 57fd3b0382..0000000000
--- a/autogpt_platform/autogpt_libs/autogpt_libs/utils/cache.py
+++ /dev/null
@@ -1,339 +0,0 @@
-import asyncio
-import inspect
-import logging
-import threading
-import time
-from functools import wraps
-from typing import (
- Any,
- Callable,
- ParamSpec,
- Protocol,
- TypeVar,
- cast,
- runtime_checkable,
-)
-
-P = ParamSpec("P")
-R = TypeVar("R")
-R_co = TypeVar("R_co", covariant=True)
-
-logger = logging.getLogger(__name__)
-
-
-def _make_hashable_key(
- args: tuple[Any, ...], kwargs: dict[str, Any]
-) -> tuple[Any, ...]:
- """
- Convert args and kwargs into a hashable cache key.
-
- Handles unhashable types like dict, list, set by converting them to
- their sorted string representations.
- """
-
- def make_hashable(obj: Any) -> Any:
- """Recursively convert an object to a hashable representation."""
- if isinstance(obj, dict):
- # Sort dict items to ensure consistent ordering
- return (
- "__dict__",
- tuple(sorted((k, make_hashable(v)) for k, v in obj.items())),
- )
- elif isinstance(obj, (list, tuple)):
- return ("__list__", tuple(make_hashable(item) for item in obj))
- elif isinstance(obj, set):
- return ("__set__", tuple(sorted(make_hashable(item) for item in obj)))
- elif hasattr(obj, "__dict__"):
- # Handle objects with __dict__ attribute
- return ("__obj__", obj.__class__.__name__, make_hashable(obj.__dict__))
- else:
- # For basic hashable types (str, int, bool, None, etc.)
- try:
- hash(obj)
- return obj
- except TypeError:
- # Fallback: convert to string representation
- return ("__str__", str(obj))
-
- hashable_args = tuple(make_hashable(arg) for arg in args)
- hashable_kwargs = tuple(sorted((k, make_hashable(v)) for k, v in kwargs.items()))
- return (hashable_args, hashable_kwargs)
-
-
-@runtime_checkable
-class CachedFunction(Protocol[P, R_co]):
- """Protocol for cached functions with cache management methods."""
-
- def cache_clear(self) -> None:
- """Clear all cached entries."""
- return None
-
- def cache_info(self) -> dict[str, int | None]:
- """Get cache statistics."""
- return {}
-
- def cache_delete(self, *args: P.args, **kwargs: P.kwargs) -> bool:
- """Delete a specific cache entry by its arguments. Returns True if entry existed."""
- return False
-
- def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R_co:
- """Call the cached function."""
- return None # type: ignore
-
-
-def cached(
- *,
- maxsize: int = 128,
- ttl_seconds: int | None = None,
-) -> Callable[[Callable], CachedFunction]:
- """
- Thundering herd safe cache decorator for both sync and async functions.
-
- Uses double-checked locking to prevent multiple threads/coroutines from
- executing the expensive operation simultaneously during cache misses.
-
- Args:
- func: The function to cache (when used without parentheses)
- maxsize: Maximum number of cached entries
- ttl_seconds: Time to live in seconds. If None, entries never expire
-
- Returns:
- Decorated function or decorator
-
- Example:
- @cache() # Default: maxsize=128, no TTL
- def expensive_sync_operation(param: str) -> dict:
- return {"result": param}
-
- @cache() # Works with async too
- async def expensive_async_operation(param: str) -> dict:
- return {"result": param}
-
- @cache(maxsize=1000, ttl_seconds=300) # Custom maxsize and TTL
- def another_operation(param: str) -> dict:
- return {"result": param}
- """
-
- def decorator(target_func):
- # Cache storage and per-event-loop locks
- cache_storage = {}
- _event_loop_locks = {} # Maps event loop to its asyncio.Lock
-
- if inspect.iscoroutinefunction(target_func):
-
- def _get_cache_lock():
- """Get or create an asyncio.Lock for the current event loop."""
- try:
- loop = asyncio.get_running_loop()
- except RuntimeError:
- # No event loop, use None as default key
- loop = None
-
- if loop not in _event_loop_locks:
- return _event_loop_locks.setdefault(loop, asyncio.Lock())
- return _event_loop_locks[loop]
-
- @wraps(target_func)
- async def async_wrapper(*args: P.args, **kwargs: P.kwargs):
- key = _make_hashable_key(args, kwargs)
- current_time = time.time()
-
- # Fast path: check cache without lock
- if key in cache_storage:
- if ttl_seconds is None:
- logger.debug(f"Cache hit for {target_func.__name__}")
- return cache_storage[key]
- else:
- cached_data = cache_storage[key]
- if isinstance(cached_data, tuple):
- result, timestamp = cached_data
- if current_time - timestamp < ttl_seconds:
- logger.debug(f"Cache hit for {target_func.__name__}")
- return result
-
- # Slow path: acquire lock for cache miss/expiry
- async with _get_cache_lock():
- # Double-check: another coroutine might have populated cache
- if key in cache_storage:
- if ttl_seconds is None:
- return cache_storage[key]
- else:
- cached_data = cache_storage[key]
- if isinstance(cached_data, tuple):
- result, timestamp = cached_data
- if current_time - timestamp < ttl_seconds:
- return result
-
- # Cache miss - execute function
- logger.debug(f"Cache miss for {target_func.__name__}")
- result = await target_func(*args, **kwargs)
-
- # Store result
- if ttl_seconds is None:
- cache_storage[key] = result
- else:
- cache_storage[key] = (result, current_time)
-
- # Cleanup if needed
- if len(cache_storage) > maxsize:
- cutoff = maxsize // 2
- oldest_keys = (
- list(cache_storage.keys())[:-cutoff] if cutoff > 0 else []
- )
- for old_key in oldest_keys:
- cache_storage.pop(old_key, None)
-
- return result
-
- wrapper = async_wrapper
-
- else:
- # Sync function with threading.Lock
- cache_lock = threading.Lock()
-
- @wraps(target_func)
- def sync_wrapper(*args: P.args, **kwargs: P.kwargs):
- key = _make_hashable_key(args, kwargs)
- current_time = time.time()
-
- # Fast path: check cache without lock
- if key in cache_storage:
- if ttl_seconds is None:
- logger.debug(f"Cache hit for {target_func.__name__}")
- return cache_storage[key]
- else:
- cached_data = cache_storage[key]
- if isinstance(cached_data, tuple):
- result, timestamp = cached_data
- if current_time - timestamp < ttl_seconds:
- logger.debug(f"Cache hit for {target_func.__name__}")
- return result
-
- # Slow path: acquire lock for cache miss/expiry
- with cache_lock:
- # Double-check: another thread might have populated cache
- if key in cache_storage:
- if ttl_seconds is None:
- return cache_storage[key]
- else:
- cached_data = cache_storage[key]
- if isinstance(cached_data, tuple):
- result, timestamp = cached_data
- if current_time - timestamp < ttl_seconds:
- return result
-
- # Cache miss - execute function
- logger.debug(f"Cache miss for {target_func.__name__}")
- result = target_func(*args, **kwargs)
-
- # Store result
- if ttl_seconds is None:
- cache_storage[key] = result
- else:
- cache_storage[key] = (result, current_time)
-
- # Cleanup if needed
- if len(cache_storage) > maxsize:
- cutoff = maxsize // 2
- oldest_keys = (
- list(cache_storage.keys())[:-cutoff] if cutoff > 0 else []
- )
- for old_key in oldest_keys:
- cache_storage.pop(old_key, None)
-
- return result
-
- wrapper = sync_wrapper
-
- # Add cache management methods
- def cache_clear() -> None:
- cache_storage.clear()
-
- def cache_info() -> dict[str, int | None]:
- return {
- "size": len(cache_storage),
- "maxsize": maxsize,
- "ttl_seconds": ttl_seconds,
- }
-
- def cache_delete(*args, **kwargs) -> bool:
- """Delete a specific cache entry. Returns True if entry existed."""
- key = _make_hashable_key(args, kwargs)
- if key in cache_storage:
- del cache_storage[key]
- return True
- return False
-
- setattr(wrapper, "cache_clear", cache_clear)
- setattr(wrapper, "cache_info", cache_info)
- setattr(wrapper, "cache_delete", cache_delete)
-
- return cast(CachedFunction, wrapper)
-
- return decorator
-
-
-def thread_cached(func):
- """
- Thread-local cache decorator for both sync and async functions.
-
- Each thread gets its own cache, which is useful for request-scoped caching
- in web applications where you want to cache within a single request but
- not across requests.
-
- Args:
- func: The function to cache
-
- Returns:
- Decorated function with thread-local caching
-
- Example:
- @thread_cached
- def expensive_operation(param: str) -> dict:
- return {"result": param}
-
- @thread_cached # Works with async too
- async def expensive_async_operation(param: str) -> dict:
- return {"result": param}
- """
- thread_local = threading.local()
-
- def _clear():
- if hasattr(thread_local, "cache"):
- del thread_local.cache
-
- if inspect.iscoroutinefunction(func):
-
- @wraps(func)
- async def async_wrapper(*args, **kwargs):
- cache = getattr(thread_local, "cache", None)
- if cache is None:
- cache = thread_local.cache = {}
- key = _make_hashable_key(args, kwargs)
- if key not in cache:
- cache[key] = await func(*args, **kwargs)
- return cache[key]
-
- setattr(async_wrapper, "clear_cache", _clear)
- return async_wrapper
-
- else:
-
- @wraps(func)
- def sync_wrapper(*args, **kwargs):
- cache = getattr(thread_local, "cache", None)
- if cache is None:
- cache = thread_local.cache = {}
- key = _make_hashable_key(args, kwargs)
- if key not in cache:
- cache[key] = func(*args, **kwargs)
- return cache[key]
-
- setattr(sync_wrapper, "clear_cache", _clear)
- return sync_wrapper
-
-
-def clear_thread_cache(func: Callable) -> None:
- """Clear thread-local cache for a function."""
- if clear := getattr(func, "clear_cache", None):
- clear()
diff --git a/autogpt_platform/backend/backend/blocks/__init__.py b/autogpt_platform/backend/backend/blocks/__init__.py
index c03311d9ab..a6c16393c7 100644
--- a/autogpt_platform/backend/backend/blocks/__init__.py
+++ b/autogpt_platform/backend/backend/blocks/__init__.py
@@ -5,7 +5,7 @@ import re
from pathlib import Path
from typing import TYPE_CHECKING, TypeVar
-from autogpt_libs.utils.cache import cached
+from backend.util.cache import cached
logger = logging.getLogger(__name__)
@@ -16,7 +16,7 @@ if TYPE_CHECKING:
T = TypeVar("T")
-@cached()
+@cached(ttl_seconds=3600)
def load_all_blocks() -> dict[str, type["Block"]]:
from backend.data.block import Block
from backend.util.settings import Config
diff --git a/autogpt_platform/backend/backend/data/block.py b/autogpt_platform/backend/backend/data/block.py
index fcd5b3c647..b96211a829 100644
--- a/autogpt_platform/backend/backend/data/block.py
+++ b/autogpt_platform/backend/backend/data/block.py
@@ -20,7 +20,6 @@ from typing import (
import jsonref
import jsonschema
-from autogpt_libs.utils.cache import cached
from prisma.models import AgentBlock
from prisma.types import AgentBlockCreateInput
from pydantic import BaseModel
@@ -28,6 +27,7 @@ from pydantic import BaseModel
from backend.data.model import NodeExecutionStats
from backend.integrations.providers import ProviderName
from backend.util import json
+from backend.util.cache import cached
from backend.util.settings import Config
from .model import (
@@ -722,7 +722,7 @@ def get_block(block_id: str) -> Block[BlockSchema, BlockSchema] | None:
return cls() if cls else None
-@cached()
+@cached(ttl_seconds=3600)
def get_webhook_block_ids() -> Sequence[str]:
return [
id
@@ -731,7 +731,7 @@ def get_webhook_block_ids() -> Sequence[str]:
]
-@cached()
+@cached(ttl_seconds=3600)
def get_io_block_ids() -> Sequence[str]:
return [
id
diff --git a/autogpt_platform/backend/backend/data/onboarding.py b/autogpt_platform/backend/backend/data/onboarding.py
index 799b88d03a..6bfc9b494d 100644
--- a/autogpt_platform/backend/backend/data/onboarding.py
+++ b/autogpt_platform/backend/backend/data/onboarding.py
@@ -4,7 +4,6 @@ from typing import Any, Optional
import prisma
import pydantic
-from autogpt_libs.utils.cache import cached
from prisma.enums import OnboardingStep
from prisma.models import UserOnboarding
from prisma.types import UserOnboardingCreateInput, UserOnboardingUpdateInput
@@ -13,6 +12,7 @@ from backend.data.block import get_blocks
from backend.data.credit import get_user_credit_model
from backend.data.model import CredentialsMetaInput
from backend.server.v2.store.model import StoreAgentDetails
+from backend.util.cache import cached
from backend.util.json import SafeJson
# Mapping from user reason id to categories to search for when choosing agent to show
diff --git a/autogpt_platform/backend/backend/data/redis_client.py b/autogpt_platform/backend/backend/data/redis_client.py
index 8227b28c39..f7d030c62b 100644
--- a/autogpt_platform/backend/backend/data/redis_client.py
+++ b/autogpt_platform/backend/backend/data/redis_client.py
@@ -1,11 +1,11 @@
import logging
import os
-from autogpt_libs.utils.cache import cached, thread_cached
from dotenv import load_dotenv
from redis import Redis
from redis.asyncio import Redis as AsyncRedis
+from backend.util.cache import cached, thread_cached
from backend.util.retry import conn_retry
load_dotenv()
@@ -34,7 +34,7 @@ def disconnect():
get_redis().close()
-@cached()
+@cached(ttl_seconds=3600)
def get_redis() -> Redis:
return connect()
diff --git a/autogpt_platform/backend/backend/data/user.py b/autogpt_platform/backend/backend/data/user.py
index 5234e28d95..8c9d53b0fa 100644
--- a/autogpt_platform/backend/backend/data/user.py
+++ b/autogpt_platform/backend/backend/data/user.py
@@ -7,7 +7,6 @@ from typing import Optional, cast
from urllib.parse import quote_plus
from autogpt_libs.auth.models import DEFAULT_USER_ID
-from autogpt_libs.utils.cache import cached
from fastapi import HTTPException
from prisma.enums import NotificationType
from prisma.models import User as PrismaUser
@@ -16,6 +15,7 @@ from prisma.types import JsonFilter, UserCreateInput, UserUpdateInput
from backend.data.db import prisma
from backend.data.model import User, UserIntegrations, UserMetadata
from backend.data.notifications import NotificationPreference, NotificationPreferenceDTO
+from backend.util.cache import cached
from backend.util.encryption import JSONCryptor
from backend.util.exceptions import DatabaseError
from backend.util.json import SafeJson
diff --git a/autogpt_platform/backend/backend/integrations/webhooks/__init__.py b/autogpt_platform/backend/backend/integrations/webhooks/__init__.py
index fb60626998..3b87855e41 100644
--- a/autogpt_platform/backend/backend/integrations/webhooks/__init__.py
+++ b/autogpt_platform/backend/backend/integrations/webhooks/__init__.py
@@ -1,6 +1,6 @@
from typing import TYPE_CHECKING
-from autogpt_libs.utils.cache import cached
+from backend.util.cache import cached
if TYPE_CHECKING:
from ..providers import ProviderName
@@ -8,7 +8,7 @@ if TYPE_CHECKING:
# --8<-- [start:load_webhook_managers]
-@cached()
+@cached(ttl_seconds=3600)
def load_webhook_managers() -> dict["ProviderName", type["BaseWebhooksManager"]]:
webhook_managers = {}
diff --git a/autogpt_platform/backend/backend/server/routers/v1.py b/autogpt_platform/backend/backend/server/routers/v1.py
index 39c7d9a5e4..b5612d58f9 100644
--- a/autogpt_platform/backend/backend/server/routers/v1.py
+++ b/autogpt_platform/backend/backend/server/routers/v1.py
@@ -11,7 +11,6 @@ import pydantic
import stripe
from autogpt_libs.auth import get_user_id, requires_user
from autogpt_libs.auth.jwt_utils import get_jwt_payload
-from autogpt_libs.utils.cache import cached
from fastapi import (
APIRouter,
Body,
@@ -85,6 +84,7 @@ from backend.server.model import (
UpdateTimezoneRequest,
UploadFileResponse,
)
+from backend.util.cache import cached
from backend.util.clients import get_scheduler_client
from backend.util.cloud_storage import get_cloud_storage_handler
from backend.util.exceptions import GraphValidationError, NotFoundError
@@ -289,7 +289,7 @@ def _compute_blocks_sync() -> str:
return dumps(result)
-@cached()
+@cached(ttl_seconds=3600)
async def _get_cached_blocks() -> str:
"""
Async cached function with thundering herd protection.
diff --git a/autogpt_platform/backend/backend/server/v2/builder/db.py b/autogpt_platform/backend/backend/server/v2/builder/db.py
index b8eecad424..0b34f50c92 100644
--- a/autogpt_platform/backend/backend/server/v2/builder/db.py
+++ b/autogpt_platform/backend/backend/server/v2/builder/db.py
@@ -2,7 +2,6 @@ import logging
from datetime import datetime, timedelta, timezone
import prisma
-from autogpt_libs.utils.cache import cached
import backend.data.block
from backend.blocks import load_all_blocks
@@ -18,6 +17,7 @@ from backend.server.v2.builder.model import (
ProviderResponse,
SearchBlocksResponse,
)
+from backend.util.cache import cached
from backend.util.models import Pagination
logger = logging.getLogger(__name__)
@@ -307,7 +307,7 @@ def _matches_llm_model(schema_cls: type[BlockSchema], query: str) -> bool:
return False
-@cached()
+@cached(ttl_seconds=3600)
def _get_all_providers() -> dict[ProviderName, Provider]:
providers: dict[ProviderName, Provider] = {}
diff --git a/autogpt_platform/backend/backend/server/v2/store/cache.py b/autogpt_platform/backend/backend/server/v2/store/cache.py
index 8a212d61a4..6d62e684ac 100644
--- a/autogpt_platform/backend/backend/server/v2/store/cache.py
+++ b/autogpt_platform/backend/backend/server/v2/store/cache.py
@@ -1,6 +1,5 @@
-from autogpt_libs.utils.cache import cached
-
import backend.server.v2.store.db
+from backend.util.cache import cached
##############################################
############### Caches #######################
@@ -17,7 +16,7 @@ def clear_all_caches():
# Cache store agents list for 5 minutes
# Different cache entries for different query combinations
-@cached(maxsize=5000, ttl_seconds=300)
+@cached(maxsize=5000, ttl_seconds=300, shared_cache=True)
async def _get_cached_store_agents(
featured: bool,
creator: str | None,
@@ -40,7 +39,7 @@ async def _get_cached_store_agents(
# Cache individual agent details for 15 minutes
-@cached(maxsize=200, ttl_seconds=300)
+@cached(maxsize=200, ttl_seconds=300, shared_cache=True)
async def _get_cached_agent_details(username: str, agent_name: str):
"""Cached helper to get agent details."""
return await backend.server.v2.store.db.get_store_agent_details(
@@ -49,7 +48,7 @@ async def _get_cached_agent_details(username: str, agent_name: str):
# Cache creators list for 5 minutes
-@cached(maxsize=200, ttl_seconds=300)
+@cached(maxsize=200, ttl_seconds=300, shared_cache=True)
async def _get_cached_store_creators(
featured: bool,
search_query: str | None,
@@ -68,7 +67,7 @@ async def _get_cached_store_creators(
# Cache individual creator details for 5 minutes
-@cached(maxsize=100, ttl_seconds=300)
+@cached(maxsize=100, ttl_seconds=300, shared_cache=True)
async def _get_cached_creator_details(username: str):
"""Cached helper to get creator details."""
return await backend.server.v2.store.db.get_store_creator_details(
diff --git a/autogpt_platform/backend/backend/util/cache.py b/autogpt_platform/backend/backend/util/cache.py
new file mode 100644
index 0000000000..c718d4ef90
--- /dev/null
+++ b/autogpt_platform/backend/backend/util/cache.py
@@ -0,0 +1,457 @@
+"""
+Caching utilities for the AutoGPT platform.
+
+Provides decorators for caching function results with support for:
+- In-memory caching with TTL
+- Shared Redis-backed caching across processes
+- Thread-local caching for request-scoped data
+- Thundering herd protection
+- LRU eviction with optional TTL refresh
+"""
+
+import asyncio
+import inspect
+import logging
+import pickle
+import threading
+import time
+from dataclasses import dataclass
+from functools import wraps
+from typing import Any, Callable, ParamSpec, Protocol, TypeVar, cast, runtime_checkable
+
+from redis import ConnectionPool, Redis
+
+from backend.util.retry import conn_retry
+from backend.util.settings import Settings
+
+P = ParamSpec("P")
+R = TypeVar("R")
+R_co = TypeVar("R_co", covariant=True)
+
+logger = logging.getLogger(__name__)
+settings = Settings()
+
+# RECOMMENDED REDIS CONFIGURATION FOR PRODUCTION:
+# Configure Redis with the following settings for optimal caching performance:
+# maxmemory-policy allkeys-lru # Evict least recently used keys when memory limit reached
+# 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")
+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())
+
+
+@dataclass
+class CachedValue:
+ """Wrapper for cached values with timestamp to avoid tuple ambiguity."""
+
+ result: Any
+ timestamp: float
+
+
+def _make_hashable_key(
+ args: tuple[Any, ...], kwargs: dict[str, Any]
+) -> tuple[Any, ...]:
+ """
+ Convert args and kwargs into a hashable cache key.
+
+ Handles unhashable types like dict, list, set by converting them to
+ their sorted string representations.
+ """
+
+ def make_hashable(obj: Any) -> Any:
+ """Recursively convert an object to a hashable representation."""
+ if isinstance(obj, dict):
+ # Sort dict items to ensure consistent ordering
+ return (
+ "__dict__",
+ tuple(sorted((k, make_hashable(v)) for k, v in obj.items())),
+ )
+ elif isinstance(obj, (list, tuple)):
+ return ("__list__", tuple(make_hashable(item) for item in obj))
+ elif isinstance(obj, set):
+ return ("__set__", tuple(sorted(make_hashable(item) for item in obj)))
+ elif hasattr(obj, "__dict__"):
+ # Handle objects with __dict__ attribute
+ return ("__obj__", obj.__class__.__name__, make_hashable(obj.__dict__))
+ else:
+ # For basic hashable types (str, int, bool, None, etc.)
+ try:
+ hash(obj)
+ return obj
+ except TypeError:
+ # Fallback: convert to string representation
+ return ("__str__", str(obj))
+
+ hashable_args = tuple(make_hashable(arg) for arg in args)
+ hashable_kwargs = tuple(sorted((k, make_hashable(v)) for k, v in kwargs.items()))
+ return (hashable_args, hashable_kwargs)
+
+
+def _make_redis_key(key: tuple[Any, ...], func_name: str) -> str:
+ """Convert a hashable key tuple to a Redis key string."""
+ # Ensure key is already hashable
+ hashable_key = key if isinstance(key, tuple) else (key,)
+ return f"cache:{func_name}:{hash(hashable_key)}"
+
+
+@runtime_checkable
+class CachedFunction(Protocol[P, R_co]):
+ """Protocol for cached functions with cache management methods."""
+
+ def cache_clear(self, pattern: str | None = None) -> None:
+ """Clear cached entries. If pattern provided, clear matching entries only."""
+ return None
+
+ def cache_info(self) -> dict[str, int | None]:
+ """Get cache statistics."""
+ return {}
+
+ def cache_delete(self, *args: P.args, **kwargs: P.kwargs) -> bool:
+ """Delete a specific cache entry by its arguments. Returns True if entry existed."""
+ return False
+
+ def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R_co:
+ """Call the cached function."""
+ return None # type: ignore
+
+
+def cached(
+ *,
+ maxsize: int = 128,
+ ttl_seconds: int,
+ shared_cache: bool = False,
+ refresh_ttl_on_get: bool = False,
+) -> Callable[[Callable], CachedFunction]:
+ """
+ Thundering herd safe cache decorator for both sync and async functions.
+
+ Uses double-checked locking to prevent multiple threads/coroutines from
+ executing the expensive operation simultaneously during cache misses.
+
+ Args:
+ maxsize: Maximum number of cached entries (only for in-memory cache)
+ ttl_seconds: Time to live in seconds. Required - entries must expire.
+ shared_cache: If True, use Redis for cross-process caching
+ refresh_ttl_on_get: If True, refresh TTL when cache entry is accessed (LRU behavior)
+
+ Returns:
+ Decorated function with caching capabilities
+
+ Example:
+ @cached(ttl_seconds=300) # 5 minute TTL
+ def expensive_sync_operation(param: str) -> dict:
+ return {"result": param}
+
+ @cached(ttl_seconds=600, shared_cache=True, refresh_ttl_on_get=True)
+ async def expensive_async_operation(param: str) -> dict:
+ return {"result": param}
+ """
+
+ def decorator(target_func):
+ cache_storage: dict[tuple, CachedValue] = {}
+ _event_loop_locks: dict[Any, asyncio.Lock] = {}
+
+ def _get_from_redis(redis_key: str) -> Any | None:
+ """Get value from Redis, optionally refreshing TTL."""
+ try:
+ if refresh_ttl_on_get:
+ # Use GETEX to get value and refresh expiry atomically
+ cached_bytes = redis.getex(redis_key, ex=ttl_seconds)
+ else:
+ cached_bytes = redis.get(redis_key)
+
+ if cached_bytes and isinstance(cached_bytes, bytes):
+ return pickle.loads(cached_bytes)
+ except Exception as e:
+ logger.error(
+ f"Redis error during cache check for {target_func.__name__}: {e}"
+ )
+ return None
+
+ def _set_to_redis(redis_key: str, value: Any) -> None:
+ """Set value in Redis with TTL."""
+ try:
+ pickled_value = pickle.dumps(value, protocol=pickle.HIGHEST_PROTOCOL)
+ redis.setex(redis_key, ttl_seconds, pickled_value)
+ except Exception as e:
+ logger.error(
+ f"Redis error storing cache for {target_func.__name__}: {e}"
+ )
+
+ def _get_from_memory(key: tuple) -> Any | None:
+ """Get value from in-memory cache, checking TTL."""
+ if key in cache_storage:
+ cached_data = cache_storage[key]
+ if time.time() - cached_data.timestamp < ttl_seconds:
+ logger.debug(
+ f"Cache hit for {target_func.__name__} args: {key[0]} kwargs: {key[1]}"
+ )
+ return cached_data.result
+ return None
+
+ def _set_to_memory(key: tuple, value: Any) -> None:
+ """Set value in in-memory cache with timestamp."""
+ cache_storage[key] = CachedValue(result=value, timestamp=time.time())
+
+ # Cleanup if needed
+ if len(cache_storage) > maxsize:
+ cutoff = maxsize // 2
+ oldest_keys = list(cache_storage.keys())[:-cutoff] if cutoff > 0 else []
+ for old_key in oldest_keys:
+ cache_storage.pop(old_key, None)
+
+ if inspect.iscoroutinefunction(target_func):
+
+ def _get_cache_lock():
+ """Get or create an asyncio.Lock for the current event loop."""
+ try:
+ loop = asyncio.get_running_loop()
+ except RuntimeError:
+ loop = None
+
+ if loop not in _event_loop_locks:
+ return _event_loop_locks.setdefault(loop, asyncio.Lock())
+ return _event_loop_locks[loop]
+
+ @wraps(target_func)
+ async def async_wrapper(*args: P.args, **kwargs: P.kwargs):
+ key = _make_hashable_key(args, kwargs)
+ redis_key = (
+ _make_redis_key(key, target_func.__name__) if shared_cache else ""
+ )
+
+ # Fast path: check cache without lock
+ if shared_cache:
+ result = _get_from_redis(redis_key)
+ if result is not None:
+ return result
+ else:
+ result = _get_from_memory(key)
+ if result is not None:
+ return result
+
+ # Slow path: acquire lock for cache miss/expiry
+ async with _get_cache_lock():
+ # Double-check: another coroutine might have populated cache
+ if shared_cache:
+ result = _get_from_redis(redis_key)
+ if result is not None:
+ return result
+ else:
+ result = _get_from_memory(key)
+ if result is not None:
+ return result
+
+ # Cache miss - execute function
+ logger.debug(f"Cache miss for {target_func.__name__}")
+ result = await target_func(*args, **kwargs)
+
+ # Store result
+ if shared_cache:
+ _set_to_redis(redis_key, result)
+ else:
+ _set_to_memory(key, result)
+
+ return result
+
+ wrapper = async_wrapper
+
+ else:
+ # Sync function with threading.Lock
+ cache_lock = threading.Lock()
+
+ @wraps(target_func)
+ def sync_wrapper(*args: P.args, **kwargs: P.kwargs):
+ key = _make_hashable_key(args, kwargs)
+ redis_key = (
+ _make_redis_key(key, target_func.__name__) if shared_cache else ""
+ )
+
+ # Fast path: check cache without lock
+ if shared_cache:
+ result = _get_from_redis(redis_key)
+ if result is not None:
+ return result
+ else:
+ result = _get_from_memory(key)
+ if result is not None:
+ return result
+
+ # Slow path: acquire lock for cache miss/expiry
+ with cache_lock:
+ # Double-check: another thread might have populated cache
+ if shared_cache:
+ result = _get_from_redis(redis_key)
+ if result is not None:
+ return result
+ else:
+ result = _get_from_memory(key)
+ if result is not None:
+ return result
+
+ # Cache miss - execute function
+ logger.debug(f"Cache miss for {target_func.__name__}")
+ result = target_func(*args, **kwargs)
+
+ # Store result
+ if shared_cache:
+ _set_to_redis(redis_key, result)
+ else:
+ _set_to_memory(key, result)
+
+ return result
+
+ wrapper = sync_wrapper
+
+ # Add cache management methods
+ def cache_clear(pattern: str | None = None) -> None:
+ """Clear cache entries. If pattern provided, clear matching entries."""
+ if shared_cache:
+ if pattern:
+ # Clear entries matching pattern
+ keys = list(
+ redis.scan_iter(f"cache:{target_func.__name__}:{pattern}")
+ )
+ else:
+ # Clear all cache keys
+ keys = list(redis.scan_iter(f"cache:{target_func.__name__}:*"))
+
+ if keys:
+ pipeline = redis.pipeline()
+ for key in keys:
+ pipeline.delete(key)
+ pipeline.execute()
+ else:
+ if pattern:
+ # For in-memory cache, pattern matching not supported
+ logger.warning(
+ "Pattern-based clearing not supported for in-memory cache"
+ )
+ else:
+ cache_storage.clear()
+
+ def cache_info() -> dict[str, int | None]:
+ if shared_cache:
+ cache_keys = list(redis.scan_iter(f"cache:{target_func.__name__}:*"))
+ return {
+ "size": len(cache_keys),
+ "maxsize": None, # Redis manages its own size
+ "ttl_seconds": ttl_seconds,
+ }
+ else:
+ return {
+ "size": len(cache_storage),
+ "maxsize": maxsize,
+ "ttl_seconds": ttl_seconds,
+ }
+
+ def cache_delete(*args, **kwargs) -> bool:
+ """Delete a specific cache entry. Returns True if entry existed."""
+ 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
+ else:
+ if key in cache_storage:
+ del cache_storage[key]
+ return True
+ return False
+
+ setattr(wrapper, "cache_clear", cache_clear)
+ setattr(wrapper, "cache_info", cache_info)
+ setattr(wrapper, "cache_delete", cache_delete)
+
+ return cast(CachedFunction, wrapper)
+
+ return decorator
+
+
+def thread_cached(func):
+ """
+ Thread-local cache decorator for both sync and async functions.
+
+ Each thread gets its own cache, which is useful for request-scoped caching
+ in web applications where you want to cache within a single request but
+ not across requests.
+
+ Args:
+ func: The function to cache
+
+ Returns:
+ Decorated function with thread-local caching
+
+ Example:
+ @thread_cached
+ def expensive_operation(param: str) -> dict:
+ return {"result": param}
+
+ @thread_cached # Works with async too
+ async def expensive_async_operation(param: str) -> dict:
+ return {"result": param}
+ """
+ thread_local = threading.local()
+
+ def _clear():
+ if hasattr(thread_local, "cache"):
+ del thread_local.cache
+
+ if inspect.iscoroutinefunction(func):
+
+ @wraps(func)
+ async def async_wrapper(*args, **kwargs):
+ cache = getattr(thread_local, "cache", None)
+ if cache is None:
+ cache = thread_local.cache = {}
+ key = _make_hashable_key(args, kwargs)
+ if key not in cache:
+ cache[key] = await func(*args, **kwargs)
+ return cache[key]
+
+ setattr(async_wrapper, "clear_cache", _clear)
+ return async_wrapper
+
+ else:
+
+ @wraps(func)
+ def sync_wrapper(*args, **kwargs):
+ cache = getattr(thread_local, "cache", None)
+ if cache is None:
+ cache = thread_local.cache = {}
+ key = _make_hashable_key(args, kwargs)
+ if key not in cache:
+ cache[key] = func(*args, **kwargs)
+ return cache[key]
+
+ setattr(sync_wrapper, "clear_cache", _clear)
+ return sync_wrapper
+
+
+def clear_thread_cache(func: Callable) -> None:
+ """Clear thread-local cache for a function."""
+ if clear := getattr(func, "clear_cache", None):
+ clear()
diff --git a/autogpt_platform/autogpt_libs/autogpt_libs/utils/cache_test.py b/autogpt_platform/backend/backend/util/cache_test.py
similarity index 59%
rename from autogpt_platform/autogpt_libs/autogpt_libs/utils/cache_test.py
rename to autogpt_platform/backend/backend/util/cache_test.py
index b4b624c6db..d2702a63c2 100644
--- a/autogpt_platform/autogpt_libs/autogpt_libs/utils/cache_test.py
+++ b/autogpt_platform/backend/backend/util/cache_test.py
@@ -16,7 +16,7 @@ from unittest.mock import Mock
import pytest
-from autogpt_libs.utils.cache import cached, clear_thread_cache, thread_cached
+from backend.util.cache import cached, clear_thread_cache, thread_cached
class TestThreadCached:
@@ -332,7 +332,7 @@ class TestCache:
"""Test basic sync caching functionality."""
call_count = 0
- @cached()
+ @cached(ttl_seconds=300)
def expensive_sync_function(x: int, y: int = 0) -> int:
nonlocal call_count
call_count += 1
@@ -358,7 +358,7 @@ class TestCache:
"""Test basic async caching functionality."""
call_count = 0
- @cached()
+ @cached(ttl_seconds=300)
async def expensive_async_function(x: int, y: int = 0) -> int:
nonlocal call_count
call_count += 1
@@ -385,7 +385,7 @@ class TestCache:
call_count = 0
results = []
- @cached()
+ @cached(ttl_seconds=300)
def slow_function(x: int) -> int:
nonlocal call_count
call_count += 1
@@ -412,7 +412,7 @@ class TestCache:
"""Test that concurrent async calls don't cause thundering herd."""
call_count = 0
- @cached()
+ @cached(ttl_seconds=300)
async def slow_async_function(x: int) -> int:
nonlocal call_count
call_count += 1
@@ -508,7 +508,7 @@ class TestCache:
"""Test cache clearing functionality."""
call_count = 0
- @cached()
+ @cached(ttl_seconds=300)
def clearable_function(x: int) -> int:
nonlocal call_count
call_count += 1
@@ -537,7 +537,7 @@ class TestCache:
"""Test cache clearing functionality with async function."""
call_count = 0
- @cached()
+ @cached(ttl_seconds=300)
async def async_clearable_function(x: int) -> int:
nonlocal call_count
call_count += 1
@@ -567,7 +567,7 @@ class TestCache:
"""Test that cached async functions return actual results, not coroutines."""
call_count = 0
- @cached()
+ @cached(ttl_seconds=300)
async def async_result_function(x: int) -> str:
nonlocal call_count
call_count += 1
@@ -593,7 +593,7 @@ class TestCache:
"""Test selective cache deletion functionality."""
call_count = 0
- @cached()
+ @cached(ttl_seconds=300)
def deletable_function(x: int) -> int:
nonlocal call_count
call_count += 1
@@ -636,7 +636,7 @@ class TestCache:
"""Test selective cache deletion functionality with async function."""
call_count = 0
- @cached()
+ @cached(ttl_seconds=300)
async def async_deletable_function(x: int) -> int:
nonlocal call_count
call_count += 1
@@ -674,3 +674,450 @@ class TestCache:
# Try to delete non-existent entry
was_deleted = async_deletable_function.cache_delete(99)
assert was_deleted is False
+
+
+class TestSharedCache:
+ """Tests for shared_cache (Redis-backed) functionality."""
+
+ def test_sync_shared_cache_basic(self):
+ """Test basic shared cache functionality with sync function."""
+ call_count = 0
+
+ @cached(ttl_seconds=30, shared_cache=True)
+ def shared_sync_function(x: int, y: int = 0) -> int:
+ nonlocal call_count
+ call_count += 1
+ return x + y
+
+ # Clear any existing cache
+ shared_sync_function.cache_clear()
+
+ # First call
+ result1 = shared_sync_function(10, 20)
+ assert result1 == 30
+ assert call_count == 1
+
+ # Second call - should use Redis cache
+ result2 = shared_sync_function(10, 20)
+ assert result2 == 30
+ assert call_count == 1
+
+ # Different args - should call function again
+ result3 = shared_sync_function(15, 25)
+ assert result3 == 40
+ assert call_count == 2
+
+ # Cleanup
+ shared_sync_function.cache_clear()
+
+ @pytest.mark.asyncio
+ async def test_async_shared_cache_basic(self):
+ """Test basic shared cache functionality with async function."""
+ call_count = 0
+
+ @cached(ttl_seconds=30, shared_cache=True)
+ async def shared_async_function(x: int, y: int = 0) -> int:
+ nonlocal call_count
+ call_count += 1
+ await asyncio.sleep(0.01)
+ return x + y
+
+ # Clear any existing cache
+ shared_async_function.cache_clear()
+
+ # First call
+ result1 = await shared_async_function(10, 20)
+ assert result1 == 30
+ assert call_count == 1
+
+ # Second call - should use Redis cache
+ result2 = await shared_async_function(10, 20)
+ assert result2 == 30
+ assert call_count == 1
+
+ # Different args - should call function again
+ result3 = await shared_async_function(15, 25)
+ assert result3 == 40
+ assert call_count == 2
+
+ # Cleanup
+ shared_async_function.cache_clear()
+
+ def test_shared_cache_ttl_refresh(self):
+ """Test TTL refresh functionality with shared cache."""
+ call_count = 0
+
+ @cached(ttl_seconds=2, shared_cache=True, refresh_ttl_on_get=True)
+ def ttl_refresh_function(x: int) -> int:
+ nonlocal call_count
+ call_count += 1
+ return x * 10
+
+ # Clear any existing cache
+ ttl_refresh_function.cache_clear()
+
+ # First call
+ result1 = ttl_refresh_function(3)
+ assert result1 == 30
+ assert call_count == 1
+
+ # Wait 1 second
+ time.sleep(1)
+
+ # Second call - should refresh TTL and use cache
+ result2 = ttl_refresh_function(3)
+ assert result2 == 30
+ assert call_count == 1
+
+ # Wait another 1.5 seconds (total 2.5s from first call, 1.5s from second)
+ time.sleep(1.5)
+
+ # Third call - TTL should have been refreshed, so still cached
+ result3 = ttl_refresh_function(3)
+ assert result3 == 30
+ assert call_count == 1
+
+ # Wait 2.1 seconds - now it should expire
+ time.sleep(2.1)
+
+ # Fourth call - should call function again
+ result4 = ttl_refresh_function(3)
+ assert result4 == 30
+ assert call_count == 2
+
+ # Cleanup
+ ttl_refresh_function.cache_clear()
+
+ def test_shared_cache_without_ttl_refresh(self):
+ """Test that TTL doesn't refresh when refresh_ttl_on_get=False."""
+ call_count = 0
+
+ @cached(ttl_seconds=2, shared_cache=True, refresh_ttl_on_get=False)
+ def no_ttl_refresh_function(x: int) -> int:
+ nonlocal call_count
+ call_count += 1
+ return x * 10
+
+ # Clear any existing cache
+ no_ttl_refresh_function.cache_clear()
+
+ # First call
+ result1 = no_ttl_refresh_function(4)
+ assert result1 == 40
+ assert call_count == 1
+
+ # Wait 1 second
+ time.sleep(1)
+
+ # Second call - should use cache but NOT refresh TTL
+ result2 = no_ttl_refresh_function(4)
+ assert result2 == 40
+ assert call_count == 1
+
+ # Wait another 1.1 seconds (total 2.1s from first call)
+ time.sleep(1.1)
+
+ # Third call - should have expired
+ result3 = no_ttl_refresh_function(4)
+ assert result3 == 40
+ assert call_count == 2
+
+ # Cleanup
+ no_ttl_refresh_function.cache_clear()
+
+ def test_shared_cache_complex_objects(self):
+ """Test caching complex objects with shared cache (pickle serialization)."""
+ call_count = 0
+
+ @cached(ttl_seconds=30, shared_cache=True)
+ def complex_object_function(x: int) -> dict:
+ nonlocal call_count
+ call_count += 1
+ return {
+ "number": x,
+ "squared": x**2,
+ "nested": {"list": [1, 2, x], "tuple": (x, x * 2)},
+ "string": f"value_{x}",
+ }
+
+ # Clear any existing cache
+ complex_object_function.cache_clear()
+
+ # First call
+ result1 = complex_object_function(5)
+ assert result1["number"] == 5
+ assert result1["squared"] == 25
+ assert result1["nested"]["list"] == [1, 2, 5]
+ assert call_count == 1
+
+ # Second call - should use cache
+ result2 = complex_object_function(5)
+ assert result2 == result1
+ assert call_count == 1
+
+ # Cleanup
+ complex_object_function.cache_clear()
+
+ def test_shared_cache_info(self):
+ """Test cache_info for shared cache."""
+
+ @cached(ttl_seconds=30, shared_cache=True)
+ def info_shared_function(x: int) -> int:
+ return x * 2
+
+ # Clear any existing cache
+ info_shared_function.cache_clear()
+
+ # Check initial info
+ info = info_shared_function.cache_info()
+ assert info["size"] == 0
+ assert info["maxsize"] is None # Redis manages size
+ assert info["ttl_seconds"] == 30
+
+ # Add some entries
+ info_shared_function(1)
+ info_shared_function(2)
+ info_shared_function(3)
+
+ info = info_shared_function.cache_info()
+ assert info["size"] == 3
+
+ # Cleanup
+ info_shared_function.cache_clear()
+
+ def test_shared_cache_delete(self):
+ """Test selective deletion with shared cache."""
+ call_count = 0
+
+ @cached(ttl_seconds=30, shared_cache=True)
+ def delete_shared_function(x: int) -> int:
+ nonlocal call_count
+ call_count += 1
+ return x * 3
+
+ # Clear any existing cache
+ delete_shared_function.cache_clear()
+
+ # Add entries
+ delete_shared_function(1)
+ delete_shared_function(2)
+ delete_shared_function(3)
+ assert call_count == 3
+
+ # Verify cached
+ delete_shared_function(1)
+ delete_shared_function(2)
+ assert call_count == 3
+
+ # Delete specific entry
+ was_deleted = delete_shared_function.cache_delete(2)
+ assert was_deleted is True
+
+ # Entry for x=2 should be gone
+ delete_shared_function(2)
+ assert call_count == 4
+
+ # Others should still be cached
+ delete_shared_function(1)
+ delete_shared_function(3)
+ assert call_count == 4
+
+ # Try to delete non-existent
+ was_deleted = delete_shared_function.cache_delete(99)
+ assert was_deleted is False
+
+ # Cleanup
+ delete_shared_function.cache_clear()
+
+ @pytest.mark.asyncio
+ async def test_async_shared_cache_thundering_herd(self):
+ """Test that shared cache prevents thundering herd for async functions."""
+ call_count = 0
+
+ @cached(ttl_seconds=30, shared_cache=True)
+ async def shared_slow_function(x: int) -> int:
+ nonlocal call_count
+ call_count += 1
+ await asyncio.sleep(0.1)
+ return x * x
+
+ # Clear any existing cache
+ shared_slow_function.cache_clear()
+
+ # Launch multiple concurrent tasks
+ tasks = [shared_slow_function(8) for _ in range(10)]
+ results = await asyncio.gather(*tasks)
+
+ # All should return same result
+ assert all(r == 64 for r in results)
+ # Only one should have executed
+ assert call_count == 1
+
+ # Cleanup
+ shared_slow_function.cache_clear()
+
+ def test_shared_cache_clear_pattern(self):
+ """Test pattern-based cache clearing (Redis feature)."""
+
+ @cached(ttl_seconds=30, shared_cache=True)
+ def pattern_function(category: str, item: int) -> str:
+ return f"{category}_{item}"
+
+ # Clear any existing cache
+ pattern_function.cache_clear()
+
+ # Add various entries
+ pattern_function("fruit", 1)
+ pattern_function("fruit", 2)
+ pattern_function("vegetable", 1)
+ pattern_function("vegetable", 2)
+
+ info = pattern_function.cache_info()
+ assert info["size"] == 4
+
+ # Note: Pattern clearing with wildcards requires specific Redis scan
+ # implementation. The current code clears by pattern but needs
+ # adjustment for partial matching. For now, test full clear.
+ pattern_function.cache_clear()
+ info = pattern_function.cache_info()
+ assert info["size"] == 0
+
+ def test_shared_vs_local_cache_isolation(self):
+ """Test that shared and local caches are isolated."""
+ shared_count = 0
+ local_count = 0
+
+ @cached(ttl_seconds=30, shared_cache=True)
+ def shared_function(x: int) -> int:
+ nonlocal shared_count
+ shared_count += 1
+ return x * 2
+
+ @cached(ttl_seconds=30, shared_cache=False)
+ def local_function(x: int) -> int:
+ nonlocal local_count
+ local_count += 1
+ return x * 2
+
+ # Clear caches
+ shared_function.cache_clear()
+ local_function.cache_clear()
+
+ # Call both with same args
+ shared_result = shared_function(5)
+ local_result = local_function(5)
+
+ assert shared_result == local_result == 10
+ assert shared_count == 1
+ assert local_count == 1
+
+ # Call again - both should use their respective caches
+ shared_function(5)
+ local_function(5)
+ assert shared_count == 1
+ assert local_count == 1
+
+ # Clear only shared cache
+ shared_function.cache_clear()
+
+ # Shared should recompute, local should still use cache
+ shared_function(5)
+ local_function(5)
+ assert shared_count == 2
+ assert local_count == 1
+
+ # Cleanup
+ shared_function.cache_clear()
+ local_function.cache_clear()
+
+ @pytest.mark.asyncio
+ async def test_shared_cache_concurrent_different_keys(self):
+ """Test that concurrent calls with different keys work correctly."""
+ call_counts = {}
+
+ @cached(ttl_seconds=30, shared_cache=True)
+ async def multi_key_function(key: str) -> str:
+ if key not in call_counts:
+ call_counts[key] = 0
+ call_counts[key] += 1
+ await asyncio.sleep(0.05)
+ return f"result_{key}"
+
+ # Clear cache
+ multi_key_function.cache_clear()
+
+ # Launch concurrent tasks with different keys
+ keys = ["a", "b", "c", "d", "e"]
+ tasks = []
+ for key in keys:
+ # Multiple calls per key
+ tasks.extend([multi_key_function(key) for _ in range(3)])
+
+ results = await asyncio.gather(*tasks)
+
+ # Verify results
+ for i, key in enumerate(keys):
+ expected = f"result_{key}"
+ # Each key appears 3 times in results
+ key_results = results[i * 3 : (i + 1) * 3]
+ assert all(r == expected for r in key_results)
+
+ # Each key should only be computed once
+ for key in keys:
+ assert call_counts[key] == 1
+
+ # Cleanup
+ multi_key_function.cache_clear()
+
+ def test_shared_cache_performance_comparison(self):
+ """Compare performance of shared vs local cache."""
+ import statistics
+
+ shared_times = []
+ local_times = []
+
+ @cached(ttl_seconds=30, shared_cache=True)
+ def shared_perf_function(x: int) -> int:
+ time.sleep(0.01) # Simulate work
+ return x * 2
+
+ @cached(ttl_seconds=30, shared_cache=False)
+ def local_perf_function(x: int) -> int:
+ time.sleep(0.01) # Simulate work
+ return x * 2
+
+ # Clear caches
+ shared_perf_function.cache_clear()
+ local_perf_function.cache_clear()
+
+ # Warm up both caches
+ for i in range(5):
+ shared_perf_function(i)
+ local_perf_function(i)
+
+ # Measure cache hit times
+ for i in range(5):
+ # Shared cache hit
+ start = time.time()
+ shared_perf_function(i)
+ shared_times.append(time.time() - start)
+
+ # Local cache hit
+ start = time.time()
+ local_perf_function(i)
+ local_times.append(time.time() - start)
+
+ # Local cache should be faster (no Redis round-trip)
+ avg_shared = statistics.mean(shared_times)
+ avg_local = statistics.mean(local_times)
+
+ print(f"Avg shared cache hit time: {avg_shared:.6f}s")
+ print(f"Avg local cache hit time: {avg_local:.6f}s")
+
+ # Local should be significantly faster for cache hits
+ # Redis adds network latency even for cache hits
+ assert avg_local < avg_shared
+
+ # Cleanup
+ shared_perf_function.cache_clear()
+ local_perf_function.cache_clear()
diff --git a/autogpt_platform/backend/backend/util/clients.py b/autogpt_platform/backend/backend/util/clients.py
index c9eb881aa3..bea8a5e2f9 100644
--- a/autogpt_platform/backend/backend/util/clients.py
+++ b/autogpt_platform/backend/backend/util/clients.py
@@ -4,8 +4,7 @@ Centralized service client helpers with thread caching.
from typing import TYPE_CHECKING
-from autogpt_libs.utils.cache import cached, thread_cached
-
+from backend.util.cache import cached, thread_cached
from backend.util.settings import Settings
settings = Settings()
@@ -120,7 +119,7 @@ def get_integration_credentials_store() -> "IntegrationCredentialsStore":
# ============ Supabase Clients ============ #
-@cached()
+@cached(ttl_seconds=3600)
def get_supabase() -> "Client":
"""Get a process-cached synchronous Supabase client instance."""
from supabase import create_client
@@ -130,7 +129,7 @@ def get_supabase() -> "Client":
)
-@cached()
+@cached(ttl_seconds=3600)
async def get_async_supabase() -> "AClient":
"""Get a process-cached asynchronous Supabase client instance."""
from supabase import create_async_client
diff --git a/autogpt_platform/backend/backend/util/feature_flag.py b/autogpt_platform/backend/backend/util/feature_flag.py
index 34b73ddbf8..92625b0be9 100644
--- a/autogpt_platform/backend/backend/util/feature_flag.py
+++ b/autogpt_platform/backend/backend/util/feature_flag.py
@@ -5,12 +5,12 @@ from functools import wraps
from typing import Any, Awaitable, Callable, TypeVar
import ldclient
-from autogpt_libs.utils.cache import cached
from fastapi import HTTPException
from ldclient import Context, LDClient
from ldclient.config import Config
from typing_extensions import ParamSpec
+from backend.util.cache import cached
from backend.util.settings import Settings
logger = logging.getLogger(__name__)
diff --git a/autogpt_platform/backend/backend/util/process.py b/autogpt_platform/backend/backend/util/process.py
index d345d2d0f4..4b968163ae 100644
--- a/autogpt_platform/backend/backend/util/process.py
+++ b/autogpt_platform/backend/backend/util/process.py
@@ -8,18 +8,9 @@ from typing import Optional
from backend.util.logging import configure_logging
from backend.util.metrics import sentry_init
+from backend.util.settings import set_service_name
logger = logging.getLogger(__name__)
-_SERVICE_NAME = "MainProcess"
-
-
-def get_service_name():
- return _SERVICE_NAME
-
-
-def set_service_name(name: str):
- global _SERVICE_NAME
- _SERVICE_NAME = name
class AppProcess(ABC):
diff --git a/autogpt_platform/backend/backend/util/retry.py b/autogpt_platform/backend/backend/util/retry.py
index fd4414319c..13157a462d 100644
--- a/autogpt_platform/backend/backend/util/retry.py
+++ b/autogpt_platform/backend/backend/util/retry.py
@@ -13,7 +13,7 @@ from tenacity import (
wait_exponential_jitter,
)
-from backend.util.process import get_service_name
+from backend.util.settings import get_service_name
logger = logging.getLogger(__name__)
diff --git a/autogpt_platform/backend/backend/util/service.py b/autogpt_platform/backend/backend/util/service.py
index 2f580fe49e..f53b7f82f3 100644
--- a/autogpt_platform/backend/backend/util/service.py
+++ b/autogpt_platform/backend/backend/util/service.py
@@ -31,9 +31,9 @@ import backend.util.exceptions as exceptions
from backend.monitoring.instrumentation import instrument_fastapi
from backend.util.json import to_dict
from backend.util.metrics import sentry_init
-from backend.util.process import AppProcess, get_service_name
+from backend.util.process import AppProcess
from backend.util.retry import conn_retry, create_retry_decorator
-from backend.util.settings import Config
+from backend.util.settings import Config, get_service_name
logger = logging.getLogger(__name__)
T = TypeVar("T")
diff --git a/autogpt_platform/backend/backend/util/settings.py b/autogpt_platform/backend/backend/util/settings.py
index 6ee5ff3134..f07f998a38 100644
--- a/autogpt_platform/backend/backend/util/settings.py
+++ b/autogpt_platform/backend/backend/util/settings.py
@@ -15,6 +15,17 @@ from backend.util.data import get_data_path
T = TypeVar("T", bound=BaseSettings)
+_SERVICE_NAME = "MainProcess"
+
+
+def get_service_name():
+ return _SERVICE_NAME
+
+
+def set_service_name(name: str):
+ global _SERVICE_NAME
+ _SERVICE_NAME = name
+
class AppEnvironment(str, Enum):
LOCAL = "local"
@@ -254,6 +265,7 @@ class Config(UpdateTrackingModel["Config"], BaseSettings):
default="localhost",
description="The host for the RabbitMQ server",
)
+
rabbitmq_port: int = Field(
default=5672,
description="The port for the RabbitMQ server",
@@ -264,6 +276,21 @@ class Config(UpdateTrackingModel["Config"], BaseSettings):
description="The vhost for the RabbitMQ server",
)
+ redis_host: str = Field(
+ default="localhost",
+ description="The host for the Redis server",
+ )
+
+ redis_port: int = Field(
+ default=6379,
+ description="The port for the Redis server",
+ )
+
+ redis_password: str = Field(
+ default="",
+ description="The password for the Redis server (empty string if no password)",
+ )
+
postmark_sender_email: str = Field(
default="[email protected]",
description="The email address to use for sending emails",