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.pydeleted file mode 100644index 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__.pyindex c03311d9ab..a6c16393c7 100644--- a/autogpt_platform/backend/backend/blocks/__init__.py+++ b/autogpt_platform/backend/backend/blocks/__init__.py@@ -5,7 +5,7 @@ import refrom pathlib import Pathfrom typing import TYPE_CHECKING, TypeVar-from autogpt_libs.utils.cache import cached+from backend.util.cache import cachedlogger = 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 Blockfrom backend.util.settings import Configdiff --git a/autogpt_platform/backend/backend/data/block.py b/autogpt_platform/backend/backend/data/block.pyindex 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 jsonrefimport jsonschema-from autogpt_libs.utils.cache import cachedfrom prisma.models import AgentBlockfrom prisma.types import AgentBlockCreateInputfrom pydantic import BaseModel@@ -28,6 +27,7 @@ from pydantic import BaseModelfrom backend.data.model import NodeExecutionStatsfrom backend.integrations.providers import ProviderNamefrom backend.util import json+from backend.util.cache import cachedfrom backend.util.settings import Configfrom .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 [iddiff --git a/autogpt_platform/backend/backend/data/onboarding.py b/autogpt_platform/backend/backend/data/onboarding.pyindex 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, Optionalimport prismaimport pydantic-from autogpt_libs.utils.cache import cachedfrom prisma.enums import OnboardingStepfrom prisma.models import UserOnboardingfrom prisma.types import UserOnboardingCreateInput, UserOnboardingUpdateInput@@ -13,6 +12,7 @@ from backend.data.block import get_blocksfrom backend.data.credit import get_user_credit_modelfrom backend.data.model import CredentialsMetaInputfrom backend.server.v2.store.model import StoreAgentDetails+from backend.util.cache import cachedfrom backend.util.json import SafeJson# Mapping from user reason id to categories to search for when choosing agent to showdiff --git a/autogpt_platform/backend/backend/data/redis_client.py b/autogpt_platform/backend/backend/data/redis_client.pyindex 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 loggingimport os-from autogpt_libs.utils.cache import cached, thread_cachedfrom dotenv import load_dotenvfrom redis import Redisfrom redis.asyncio import Redis as AsyncRedis+from backend.util.cache import cached, thread_cachedfrom backend.util.retry import conn_retryload_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.pyindex 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, castfrom urllib.parse import quote_plusfrom autogpt_libs.auth.models import DEFAULT_USER_ID-from autogpt_libs.utils.cache import cachedfrom fastapi import HTTPExceptionfrom prisma.enums import NotificationTypefrom prisma.models import User as PrismaUser@@ -16,6 +15,7 @@ from prisma.types import JsonFilter, UserCreateInput, UserUpdateInputfrom backend.data.db import prismafrom backend.data.model import User, UserIntegrations, UserMetadatafrom backend.data.notifications import NotificationPreference, NotificationPreferenceDTO+from backend.util.cache import cachedfrom backend.util.encryption import JSONCryptorfrom backend.util.exceptions import DatabaseErrorfrom backend.util.json import SafeJsondiff --git a/autogpt_platform/backend/backend/integrations/webhooks/__init__.py b/autogpt_platform/backend/backend/integrations/webhooks/__init__.pyindex 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 cachedif 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.pyindex 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 pydanticimport stripefrom autogpt_libs.auth import get_user_id, requires_userfrom autogpt_libs.auth.jwt_utils import get_jwt_payload-from autogpt_libs.utils.cache import cachedfrom fastapi import (APIRouter,Body,@@ -85,6 +84,7 @@ from backend.server.model import (UpdateTimezoneRequest,UploadFileResponse,)+from backend.util.cache import cachedfrom backend.util.clients import get_scheduler_clientfrom backend.util.cloud_storage import get_cloud_storage_handlerfrom 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.pyindex 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 loggingfrom datetime import datetime, timedelta, timezoneimport prisma-from autogpt_libs.utils.cache import cachedimport backend.data.blockfrom backend.blocks import load_all_blocks@@ -18,6 +17,7 @@ from backend.server.v2.builder.model import (ProviderResponse,SearchBlocksResponse,)+from backend.util.cache import cachedfrom backend.util.models import Paginationlogger = 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.pyindex 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.pynew file mode 100644index 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.pysimilarity index 59%rename from autogpt_platform/autogpt_libs/autogpt_libs/utils/cache_test.pyrename to autogpt_platform/backend/backend/util/cache_test.pyindex 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 Mockimport pytest-from autogpt_libs.utils.cache import cached, clear_thread_cache, thread_cached+from backend.util.cache import cached, clear_thread_cache, thread_cachedclass 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_countcall_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_countcall_count += 1@@ -385,7 +385,7 @@ class TestCache:call_count = 0results = []- @cached()+ @cached(ttl_seconds=300)def slow_function(x: int) -> int:nonlocal call_countcall_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_countcall_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_countcall_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_countcall_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_countcall_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_countcall_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_countcall_count += 1@@ -674,3 +674,450 @@ class TestCache:# Try to delete non-existent entrywas_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.pyindex 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_cachedfrom backend.util.settings import Settingssettings = 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_clientdiff --git a/autogpt_platform/backend/backend/util/feature_flag.py b/autogpt_platform/backend/backend/util/feature_flag.pyindex 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 wrapsfrom typing import Any, Awaitable, Callable, TypeVarimport ldclient-from autogpt_libs.utils.cache import cachedfrom fastapi import HTTPExceptionfrom ldclient import Context, LDClientfrom ldclient.config import Configfrom typing_extensions import ParamSpec+from backend.util.cache import cachedfrom backend.util.settings import Settingslogger = logging.getLogger(__name__)diff --git a/autogpt_platform/backend/backend/util/process.py b/autogpt_platform/backend/backend/util/process.pyindex 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 Optionalfrom backend.util.logging import configure_loggingfrom backend.util.metrics import sentry_init+from backend.util.settings import set_service_namelogger = logging.getLogger(__name__)-_SERVICE_NAME = "MainProcess"---def get_service_name():- return _SERVICE_NAME---def set_service_name(name: str):- global _SERVICE_NAME- _SERVICE_NAME = nameclass AppProcess(ABC):diff --git a/autogpt_platform/backend/backend/util/retry.py b/autogpt_platform/backend/backend/util/retry.pyindex 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_namelogger = logging.getLogger(__name__)diff --git a/autogpt_platform/backend/backend/util/service.py b/autogpt_platform/backend/backend/util/service.pyindex 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 exceptionsfrom backend.monitoring.instrumentation import instrument_fastapifrom backend.util.json import to_dictfrom backend.util.metrics import sentry_init-from backend.util.process import AppProcess, get_service_name+from backend.util.process import AppProcessfrom backend.util.retry import conn_retry, create_retry_decorator-from backend.util.settings import Config+from backend.util.settings import Config, get_service_namelogger = logging.getLogger(__name__)T = TypeVar("T")diff --git a/autogpt_platform/backend/backend/util/settings.py b/autogpt_platform/backend/backend/util/settings.pyindex 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_pathT = 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",