import time import redis from typing import List, Dict, Callable, Any class SafeRedisClient: def __init__(self, redis_conf: Dict, logger: Callable[[str], None] = None): safe_conf = dict(redis_conf) safe_conf.setdefault('socket_timeout', 5.0) # Read/write timeout safe_conf.setdefault('socket_connect_timeout', 5.0) # Connection timeout safe_conf.setdefault('socket_keepalive', True) # TCP OS-level keepalive safe_conf.setdefault('health_check_interval', 30) # Auto disconnect detection & reconnect self._client = redis.Redis(**safe_conf) self._logger = logger self._closed = False def close(self): self._closed = True self._client.close() self._client.connection_pool.disconnect() def _log(self, msg: str): if self._logger: self._logger(f"[Safe-Redis] {msg}") else: print(f"[Safe-Redis] {msg}") def _safe_execute(self, func, default_return, *args, **kwargs): """General safe executor: auto-retries once on error, returns safe fallback on total failure.""" if self._closed: return default_return try: return func(*args, **kwargs) except Exception as e: func_name = getattr(func, '__name__', 'operation') self._log(f"Attempt 1 failed ({func_name}): {e}. Retrying in 0.5s...") time.sleep(0.5) if self._closed: return default_return try: return func(*args, **kwargs) except Exception as e2: self._log(f"Attempt 2 failed ({func_name}): {e2}. Returning safe fallback: {default_return}.") return default_return def exists(self, name) -> bool: return bool(self._safe_execute(self._client.exists, False, name)) def get(self, name) -> Any: return self._safe_execute(self._client.get, None, name) def mget(self, names): if not names: return [] return self._safe_execute(self._client.mget, [None] * len(names), names) def set(self, name, value, ex=None) -> bool: return self._safe_execute(self._client.set, False, name, value, ex=ex) def setex(self, name, time_s, value) -> bool: return self._safe_execute(self._client.setex, False, name, time_s, value) def delete(self, *names) -> int: if not names: return 0 return self._safe_execute(self._client.delete, 0, *names) def incr(self, name, amount=1) -> int: # Fallback to 1 on failure to avoid calculation crashes while preserving backoff return self._safe_execute(self._client.incr, 1, name, amount=amount) def zadd(self, name, mapping) -> int: if not mapping: return 0 return self._safe_execute(self._client.zadd, 0, name, mapping) def zrem(self, name, *values) -> int: if not values: return 0 return self._safe_execute(self._client.zrem, 0, name, *values) def bulk_zadd(self, name, mapping) -> bool: """Wraps Pipeline to safely batch write zset elements.""" if not mapping: return True def _op(): self._client.zadd(name, mapping) return True return self._safe_execute(_op, False)