gcache 1.2.0__tar.gz → 2.0.0__tar.gz

{gcache-1.2.0 → gcache-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: gcache
-Version: 1.2.0
+Version: 2.0.0
 Summary: Fine grained caching.
 License: MIT
 Author: Galileo Technologies Inc.
@@ -21,7 +21,7 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Dist: cachetools (>=5.5.2)
-Requires-Dist: prometheus-client (>=0.23.1,<0.24.0)
+Requires-Dist: prometheus-client (>=0.22.1,<0.23.0)
 Requires-Dist: pydantic (>=2.11.4,<3.0.0)
 Requires-Dist: redis (>=5.0.0)
 Requires-Dist: types-cachetools (>=6.2.0.20250827,<7.0.0.0)
@@ -136,6 +136,24 @@ Caching doesn't happen automatically—you control when it's active:
 
 - **Dynamic config** — The config provider runs on each request, so you can adjust TTLs or ramp percentages without redeploying.
 
+### Why Explicit `enable()`?
+
+GCache requires you to explicitly enable caching with `with gcache.enable():`. This is intentional.
+
+Caching in write paths can cause subtle bugs—a stale read might get cached right before a write, leading to inconsistent data. By requiring explicit opt-in, GCache forces you to consciously decide where caching is safe:
+
+```python
+# Read path — caching is safe
+with gcache.enable():
+    user = await get_user(user_id)
+
+# Write path — no caching, function runs normally
+await update_user(user_id, new_data)
+await gcache.ainvalidate("user_id", user_id)
+```
+
+This design prevents accidental caching in dangerous places.
+
 ## Runtime Configuration
 
 For dynamic control, provide a config provider when creating GCache. This lets you adjust caching behavior without redeploying:
@@ -230,7 +248,6 @@ from gcache import RedisConfig
 
 gcache = GCache(
     GCacheConfig(
-        cache_config_provider=config_provider,
         redis_config=RedisConfig(
             host="redis.example.com",
             port=6379,
@@ -261,7 +278,6 @@ def make_redis_factory():
 
 gcache = GCache(
     GCacheConfig(
-        cache_config_provider=config_provider,
         redis_client_factory=make_redis_factory(),
     )
 )
@@ -337,7 +353,6 @@ You can add a prefix to avoid collisions:
 
 ```python
 GCacheConfig(
-    cache_config_provider=config_provider,
     metrics_prefix="myapp_",  # Metrics become myapp_gcache_request_counter, etc.
 )
 ```

{gcache-1.2.0 → gcache-2.0.0}/README.md

@@ -104,6 +104,24 @@ Caching doesn't happen automatically—you control when it's active:
 
 - **Dynamic config** — The config provider runs on each request, so you can adjust TTLs or ramp percentages without redeploying.
 
+### Why Explicit `enable()`?
+
+GCache requires you to explicitly enable caching with `with gcache.enable():`. This is intentional.
+
+Caching in write paths can cause subtle bugs—a stale read might get cached right before a write, leading to inconsistent data. By requiring explicit opt-in, GCache forces you to consciously decide where caching is safe:
+
+```python
+# Read path — caching is safe
+with gcache.enable():
+    user = await get_user(user_id)
+
+# Write path — no caching, function runs normally
+await update_user(user_id, new_data)
+await gcache.ainvalidate("user_id", user_id)
+```
+
+This design prevents accidental caching in dangerous places.
+
 ## Runtime Configuration
 
 For dynamic control, provide a config provider when creating GCache. This lets you adjust caching behavior without redeploying:
@@ -198,7 +216,6 @@ from gcache import RedisConfig
 
 gcache = GCache(
     GCacheConfig(
-        cache_config_provider=config_provider,
         redis_config=RedisConfig(
             host="redis.example.com",
             port=6379,
@@ -229,7 +246,6 @@ def make_redis_factory():
 
 gcache = GCache(
     GCacheConfig(
-        cache_config_provider=config_provider,
         redis_client_factory=make_redis_factory(),
     )
 )
@@ -305,7 +321,6 @@ You can add a prefix to avoid collisions:
 
 ```python
 GCacheConfig(
-    cache_config_provider=config_provider,
     metrics_prefix="myapp_",  # Metrics become myapp_gcache_request_counter, etc.
 )
 ```

{gcache-1.2.0 → gcache-2.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gcache"
-version = "1.2.0"
+version = "2.0.0"
 description = "Fine grained caching."
 authors = [{ name = "Galileo Technologies Inc.", email = "team@rungalileo.io" }]
 readme = "README.md"
@@ -31,7 +31,7 @@ repository = "https://github.com/rungalileo/gcache"
 [tool.poetry.dependencies]
 python = "^3.10"
 pydantic = "^2.11.4"
-prometheus-client = "^0.23.1"
+prometheus-client = "^0.22.1"
 cachetools = ">=5.5.2"
 types-cachetools = "^6.2.0.20250827"
 redis = ">=5.0.0"

{gcache-1.2.0 → gcache-2.0.0}/src/gcache/__init__.py

@@ -1,3 +1,4 @@
-from .base import CacheConfigProvider, CacheLayer, GCache, GCacheConfig, GCacheKey, GCacheKeyConfig, RedisConfig
+from gcache.config import CacheConfigProvider, CacheLayer, GCacheConfig, GCacheKey, GCacheKeyConfig, RedisConfig
+from gcache.gcache import GCache
 
 __all__ = ["CacheConfigProvider", "CacheLayer", "GCache", "GCacheConfig", "GCacheKey", "GCacheKeyConfig", "RedisConfig"]

gcache-2.0.0/src/gcache/_internal/__init__.py

@@ -0,0 +1 @@
+# Internal implementation modules - not part of public API

gcache-2.0.0/src/gcache/_internal/cache_interface.py

@@ -0,0 +1,69 @@
+from abc import ABC, abstractmethod
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from gcache.config import CacheConfigProvider, CacheLayer, GCacheKey, GCacheKeyConfig
+
+#: Async callable that fetches the actual value on cache miss.
+#: Invoked by cache implementations when the requested key is not found or is stale.
+Fallback = Callable[..., Awaitable[Any]]
+
+
+class CacheInterface(ABC):
+    def __init__(self, cache_config_provider: CacheConfigProvider):
+        self.config_provider = cache_config_provider
+
+    async def _resolve_config(self, key: GCacheKey) -> GCacheKeyConfig | None:
+        """
+        Resolve the cache config for a key.
+
+        First tries the config provider, then falls back to the key's default_config.
+        Returns None if neither provides a config.
+        """
+        config = await self.config_provider(key)
+        if config is None:
+            config = key.default_config
+        return config
+
+    @abstractmethod
+    async def get(self, key: GCacheKey, fallback: Fallback) -> Any:
+        pass
+
+    @abstractmethod
+    async def put(self, key: GCacheKey, value: Any) -> None:
+        pass
+
+    @abstractmethod
+    async def delete(self, key: GCacheKey) -> bool:
+        pass
+
+    async def invalidate(self, key_type: str, id: str, future_buffer_ms: int) -> None:
+        """
+        Invalidate all cache entries matching key_type and id.
+
+        Sets a watermark timestamp so that any cached value created before
+        (now + future_buffer_ms) is considered stale on subsequent reads.
+
+        :param key_type: The entity type (e.g., 'user', 'project') matching the
+            key_type used in @cached decorators.
+        :param id: The entity identifier to invalidate.
+        :param future_buffer_ms: Extends invalidation window into the future.
+            Useful to handle race conditions where a read starts before a write
+            completes but finishes after, preventing caching of stale data.
+        """
+        pass
+
+    @abstractmethod
+    def layer(self) -> CacheLayer:
+        pass
+
+    async def flushall(self) -> None:
+        """
+        Remove all entries from this cache layer.
+
+        Used primarily for testing to reset cache state between tests.
+        Default implementation is a no-op; subclasses should override if
+        they support flushing (e.g., LocalCache clears its TTLCache dict,
+        RedisCache calls FLUSHALL on Redis).
+        """
+        pass

gcache-2.0.0/src/gcache/_internal/constants.py

@@ -0,0 +1,18 @@
+# Cache sizes
+# Default max entries per use case to prevent unbounded memory growth.
+LOCAL_CACHE_MAX_SIZE = 10_000
+
+# Thresholds
+# Threshold above which pickling runs in a thread to avoid blocking the event loop.
+ASYNC_PICKLE_THRESHOLD_BYTES = 50_000
+
+# TTLs (seconds)
+# Watermark TTL must be longer than any invalidatable cache's TTL to ensure
+# invalidation works correctly. 4 hours is a heuristic that covers most use cases.
+# If your cache TTLs exceed 4 hours, consider making this configurable.
+WATERMARK_TTL_SECONDS = 3600 * 4  # 4 hours
+
+# Thread pool
+# Default thread pool size for running async operations from sync code.
+# Balances concurrency for I/O-bound Redis operations without excessive resource usage.
+EVENT_LOOP_THREAD_POOL_SIZE = 16

{gcache-1.2.0/src/gcache → gcache-2.0.0/src/gcache/_internal}/event_loop_thread.py

@@ -7,7 +7,21 @@ from concurrent.futures import Future
 from logging import getLogger
 from typing import Any
 
-import uvloop
+from gcache._internal.constants import EVENT_LOOP_THREAD_POOL_SIZE
+
+# uvloop is optional - provides better performance on Linux/macOS but
+# doesn't work on Windows or PyPy. Fall back to standard asyncio if unavailable.
+try:
+    import uvloop
+
+    def _new_event_loop() -> asyncio.AbstractEventLoop:
+        return uvloop.new_event_loop()
+
+except ImportError:
+
+    def _new_event_loop() -> asyncio.AbstractEventLoop:
+        return asyncio.new_event_loop()
+
 
 logger = getLogger(__name__)
 
@@ -31,7 +45,7 @@ class EventLoopThread(EventLoopThreadInterface, threading.Thread):
     def __init__(self, name: str = "EventLoopThread", daemon: bool = True) -> None:
         super().__init__(name=name)
         self.daemon = daemon
-        self.loop = uvloop.new_event_loop()
+        self.loop = _new_event_loop()
 
     def run(self) -> None:
         # Set the event loop for this thread.
@@ -68,12 +82,12 @@ class EventLoopThread(EventLoopThreadInterface, threading.Thread):
 
 class EventLoopThreadPool(EventLoopThreadInterface):
     """
-    Manage collection of EventLoopThread instances and also initailize them lazily.
+    Manage collection of EventLoopThread instances and also initialize them lazily.
 
     Lazy initialization is important when running in forked processes.
     """
 
-    def __init__(self, name: str = "EventLoopThreadPool", num_threads: int = 16) -> None:
+    def __init__(self, name: str = "EventLoopThreadPool", num_threads: int = EVENT_LOOP_THREAD_POOL_SIZE) -> None:
         self.name = name
         self.num_threads = num_threads
         self.threads: list[EventLoopThread] | None = None

gcache-2.0.0/src/gcache/_internal/local_cache.py

@@ -0,0 +1,71 @@
+import asyncio
+from typing import Any
+
+from cachetools import TTLCache
+
+from gcache._internal.cache_interface import CacheInterface, Fallback
+from gcache._internal.constants import LOCAL_CACHE_MAX_SIZE
+from gcache._internal.state import _GLOBAL_GCACHE_STATE
+from gcache.config import CacheConfigProvider, CacheLayer, GCacheKey
+from gcache.exceptions import MissingKeyConfig
+
+
+class LocalCache(CacheInterface):
+    """
+    In-memory cache layer using TTLCache from cachetools.
+
+    Maintains a separate TTLCache instance per use_case, each with a configurable
+    TTL and a max size of LOCAL_CACHE_MAX_SIZE entries. This is the first layer
+    in the cache chain, checked before Redis.
+
+    Note: LocalCache does not support invalidation (watermarks). If you need
+    invalidation support, rely on the Redis layer with track_for_invalidation=True.
+    """
+
+    def __init__(self, cache_config_provider: CacheConfigProvider):
+        super().__init__(cache_config_provider)
+        self.caches: dict[str, TTLCache] = {}  # use_case -> TTLCache instance
+        self.lock = asyncio.Lock()  # Protects cache creation
+
+    async def _get_ttl_cache(self, key: GCacheKey) -> TTLCache:
+        cache = self.caches.get(key.use_case, None)
+        if cache is None:
+            config = await self._resolve_config(key)
+            if config is None:
+                raise MissingKeyConfig(key.use_case)
+
+            async with self.lock:
+                # See if cache was already created by another worker.
+                cache = self.caches.get(key.use_case, None)
+                if cache is None:
+                    self.caches[key.use_case] = cache = TTLCache(
+                        maxsize=LOCAL_CACHE_MAX_SIZE, ttl=config.ttl_sec[self.layer()]
+                    )
+
+        return cache
+
+    async def get(self, key: GCacheKey, fallback: Fallback) -> Any:
+        _GLOBAL_GCACHE_STATE.logger.debug("Calling local cache")
+        cache = await self._get_ttl_cache(key)
+
+        if key not in cache:
+            await self.put(key, await fallback())
+
+        return cache[key]
+
+    async def put(self, key: GCacheKey, value: Any) -> None:
+        (await self._get_ttl_cache(key))[key] = value
+
+    async def delete(self, key: GCacheKey) -> bool:
+        try:
+            (await self._get_ttl_cache(key)).pop(key)
+        except KeyError:
+            return False
+        return True
+
+    def layer(self) -> CacheLayer:
+        return CacheLayer.LOCAL
+
+    async def flushall(self) -> None:
+        async with self.lock:
+            self.caches.clear()

gcache-2.0.0/src/gcache/_internal/metrics.py

@@ -0,0 +1,86 @@
+from prometheus_client import Counter, Histogram
+
+
+class GCacheMetrics:
+    """Centralized Prometheus metrics for GCache."""
+
+    _initialized: bool = False
+
+    # Counters
+    DISABLED_COUNTER: Counter
+    MISS_COUNTER: Counter
+    REQUEST_COUNTER: Counter
+    ERROR_COUNTER: Counter
+    INVALIDATION_COUNTER: Counter
+
+    # Histograms
+    GET_TIMER: Histogram
+    FALLBACK_TIMER: Histogram
+    SERIALIZATION_TIMER: Histogram
+    SIZE_HISTOGRAM: Histogram
+
+    @classmethod
+    def initialize(cls, prefix: str = "") -> None:
+        """Initialize all metrics with the given prefix. Only initializes once."""
+        if cls._initialized:
+            return
+
+        cls.DISABLED_COUNTER = Counter(
+            name=prefix + "gcache_disabled_counter",
+            labelnames=["use_case", "key_type", "layer", "reason"],
+            documentation="Cache disabled counter",
+        )
+
+        cls.MISS_COUNTER = Counter(
+            name=prefix + "gcache_miss_counter",
+            labelnames=["use_case", "key_type", "layer"],
+            documentation="Cache miss counter",
+        )
+
+        cls.REQUEST_COUNTER = Counter(
+            name=prefix + "gcache_request_counter",
+            labelnames=["use_case", "key_type", "layer"],
+            documentation="Cache request counter",
+        )
+
+        cls.ERROR_COUNTER = Counter(
+            name=prefix + "gcache_error_counter",
+            labelnames=["use_case", "key_type", "layer", "error", "in_fallback"],
+            documentation="Cache error counter",
+        )
+
+        cls.INVALIDATION_COUNTER = Counter(
+            name=prefix + "gcache_invalidation_counter",
+            labelnames=["key_type", "layer"],
+            documentation="Cache invalidation counter",
+        )
+
+        cls.GET_TIMER = Histogram(
+            name=prefix + "gcache_get_timer",
+            labelnames=["use_case", "key_type", "layer"],
+            documentation="Cache get timer",
+            buckets=[0.001] + list(Histogram.DEFAULT_BUCKETS),
+        )
+
+        cls.FALLBACK_TIMER = Histogram(
+            name=prefix + "gcache_fallback_timer",
+            labelnames=["use_case", "key_type", "layer"],
+            documentation="Fallback timer",
+            buckets=[0.001] + list(Histogram.DEFAULT_BUCKETS),
+        )
+
+        cls.SERIALIZATION_TIMER = Histogram(
+            name=prefix + "gcache_serialization_timer",
+            labelnames=["use_case", "key_type", "layer", "operation"],
+            documentation="Cache serialization timer",
+            buckets=[0.001] + list(Histogram.DEFAULT_BUCKETS),
+        )
+
+        cls.SIZE_HISTOGRAM = Histogram(
+            name=prefix + "gcache_size_histogram",
+            labelnames=["use_case", "key_type", "layer"],
+            documentation="Cache size histogram",
+            buckets=[100, 1000, 10_000, 100_000, 1_000_000, 10_000_000],
+        )
+
+        cls._initialized = True

gcache-2.0.0/src/gcache/_internal/noop_cache.py

@@ -0,0 +1,22 @@
+from typing import Any
+
+from gcache._internal.cache_interface import CacheInterface, Fallback
+from gcache.config import CacheLayer, GCacheKey
+
+
+class NoopCache(CacheInterface):
+    """
+    NOOP Cache that does nothing but invoke fallback on get.
+    """
+
+    async def get(self, key: GCacheKey, fallback: Fallback) -> Any:
+        return await fallback()
+
+    async def put(self, key: GCacheKey, value: Any) -> None:
+        pass
+
+    async def delete(self, key: GCacheKey) -> bool:
+        return False
+
+    def layer(self) -> CacheLayer:
+        return CacheLayer.NOOP

gcache-2.0.0/src/gcache/_internal/redis_cache.py

@@ -0,0 +1,205 @@
+import asyncio
+import pickle
+import threading
+import time
+from collections.abc import Callable
+from concurrent.futures.thread import ThreadPoolExecutor
+from dataclasses import dataclass
+from typing import Any
+
+from redis.asyncio import Redis, RedisCluster
+
+from gcache._internal.cache_interface import CacheInterface, Fallback
+from gcache._internal.constants import ASYNC_PICKLE_THRESHOLD_BYTES, WATERMARK_TTL_SECONDS
+from gcache._internal.metrics import GCacheMetrics
+from gcache._internal.state import _GLOBAL_GCACHE_STATE
+from gcache.config import CacheConfigProvider, CacheLayer, GCacheKey, RedisConfig
+from gcache.exceptions import MissingKeyConfig
+
+
+@dataclass(frozen=True, slots=True)
+class RedisValue:
+    """
+    Wrapper around cached payload that includes creation timestamp.
+
+    The timestamp enables cache invalidation: when a watermark is set for a key,
+    any cached value with created_at_ms <= watermark is considered stale.
+    """
+
+    created_at_ms: int  # Unix timestamp in milliseconds when this value was cached
+    payload: Any  # The actual cached data (may be serialized if Serializer is used)
+
+
+def create_default_redis_client_factory(
+    config: RedisConfig,
+) -> Callable[[], Redis | RedisCluster]:
+    """
+    Create a default Redis client factory function from a RedisConfig.
+
+    This factory creates a new Redis client each time it's called. Thread-local
+    caching is handled by RedisCache, so the factory doesn't need to manage it.
+
+    :param config: RedisConfig containing URL, cluster flag, and redis-py options
+    :return: Factory function that creates a Redis client
+    """
+
+    def factory() -> Redis | RedisCluster:
+        options: dict[str, int | bool | str] = config.redis_py_options
+        if config.cluster:
+            return RedisCluster.from_url(config.url, **options)
+        else:
+            return Redis.from_url(config.url, **options)  # type: ignore[arg-type]
+
+    return factory
+
+
+class RedisCache(CacheInterface):
+    _executor = ThreadPoolExecutor()
+
+    def __init__(
+        self,
+        cache_config_provider: CacheConfigProvider,
+        client_factory: Callable[[], Redis | RedisCluster],
+    ):
+        """
+        Initialize RedisCache.
+
+        :param cache_config_provider: Provider for cache configuration
+        :param client_factory: Factory function to create Redis clients.
+            The factory should return a new Redis client when called. Thread-local
+            caching is handled internally by RedisCache - the factory will only be
+            called once per thread, and the resulting client will be reused for
+            subsequent operations on that thread.
+        """
+        super().__init__(cache_config_provider)
+        self._client_factory = client_factory
+        # Thread-local storage is required because async redis-py clients maintain
+        # internal state (connection pool, pending requests) bound to a specific event loop.
+        # Since gcache runs sync cached functions in EventLoopThread workers (each with its
+        # own event loop), sharing a client across threads causes "attached to a different
+        # event loop" RuntimeError. One client per thread ensures correct event loop binding.
+        self._thread_local = threading.local()
+
+    @property
+    def client(self) -> Redis | RedisCluster:
+        """
+        Get a Redis client for the current thread.
+
+        The client is created once per thread using the factory and cached
+        in thread-local storage for reuse.
+        """
+        if not hasattr(self._thread_local, "client"):
+            self._thread_local.client = self._client_factory()
+        return self._thread_local.client
+
+    async def _exec_fallback(
+        self,
+        key: GCacheKey,
+        watermark_ms: int | None,
+        fallback: Fallback,
+    ) -> Any:
+        """
+        Execute the fallback function, optionally cache the result, and return it.
+
+        The result is stored in cache unless there's an active invalidation window
+        (watermark_ms is in the future). This prevents caching potentially stale data
+        that was fetched during an invalidation period.
+
+        :param key: Cache key for storing the result.
+        :param watermark_ms: Invalidation watermark timestamp in milliseconds, or None.
+            If set and greater than current time, the result is not cached.
+        :param fallback: Async function that fetches the actual value.
+        :return: The value returned by the fallback function.
+        """
+        val = await fallback()
+        if watermark_ms is None or watermark_ms < time.time() * 1e3:
+            await self.put(key, val)
+        return val
+
+    async def invalidate(self, key_type: str, id: str, future_buffer_ms: int) -> None:
+        GCacheMetrics.INVALIDATION_COUNTER.labels(key_type, self.layer().name).inc()
+
+        key = "{" + _GLOBAL_GCACHE_STATE.urn_prefix + ":" + key_type + ":" + id + "}#watermark"
+        exp_ms = int(time.time() * 1000 + future_buffer_ms)
+        await self.client.setex(key, WATERMARK_TTL_SECONDS, exp_ms)
+
+    @staticmethod
+    async def _async_pickle_loads(data: bytes) -> Any:
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(RedisCache._executor, pickle.loads, data)
+
+    async def get(self, key: GCacheKey, fallback: Fallback) -> Any:
+        _GLOBAL_GCACHE_STATE.logger.debug("Calling Redis Cache")
+
+        watermark_ms = None
+        if key.invalidation_tracking:
+            vals = await self.client.mget(key.urn, key.prefix + "#watermark")
+            val_pickle = vals[0]
+            watermark_ms = vals[1]
+            if watermark_ms is not None:
+                watermark_ms = float(watermark_ms)
+        else:
+            val_pickle = await self.client.get(key.urn)
+        if val_pickle is not None:
+            start_sec = time.monotonic()
+
+            deserialized_value: RedisValue = (
+                pickle.loads(val_pickle)
+                if len(val_pickle) < ASYNC_PICKLE_THRESHOLD_BYTES
+                else await RedisCache._async_pickle_loads(val_pickle)
+            )
+
+            # Load payload using custom serializer if present.
+            payload = deserialized_value.payload
+            if key.serializer is not None:
+                payload = await key.serializer.load(payload)
+
+            (
+                GCacheMetrics.SERIALIZATION_TIMER.labels(key.use_case, key.key_type, self.layer().name, "load").observe(
+                    time.monotonic() - start_sec
+                )
+            )
+
+            # Check if cache val is expired.
+            if watermark_ms is not None:
+                watermark_ms = int(watermark_ms)
+                if watermark_ms >= deserialized_value.created_at_ms:
+                    return await self._exec_fallback(key, watermark_ms, fallback)
+            return payload
+        else:
+            return await self._exec_fallback(key, watermark_ms, fallback)
+
+    async def put(self, key: GCacheKey, value: Any) -> None:
+        config = await self._resolve_config(key)
+        if config is None:
+            raise MissingKeyConfig(key.use_case)
+
+        current_time_ms = int(time.time() * 1000)
+
+        start_time = time.monotonic()
+        serialized_value = value if key.serializer is None else await key.serializer.dump(value)
+
+        val_pickle = pickle.dumps(
+            RedisValue(created_at_ms=current_time_ms, payload=serialized_value), protocol=pickle.HIGHEST_PROTOCOL
+        )
+
+        GCacheMetrics.SERIALIZATION_TIMER.labels(key.use_case, key.key_type, self.layer().name, "dump").observe(
+            time.monotonic() - start_time
+        )
+
+        GCacheMetrics.SIZE_HISTOGRAM.labels(key.use_case, key.key_type, self.layer().name).observe(len(val_pickle))
+
+        ttl = config.ttl_sec.get(self.layer(), None)
+        if ttl is None:
+            raise MissingKeyConfig(key.use_case)
+
+        await self.client.setex(key.urn, ttl, val_pickle)
+
+    async def delete(self, key: GCacheKey) -> bool:
+        return (await self.client.delete(key.urn)) > 0
+
+    def layer(self) -> CacheLayer:
+        return CacheLayer.REMOTE
+
+    async def flushall(self) -> None:
+        return await self.client.flushall()