chore(tiger): Raise a different timeout exception from tiger clusters

snuba/state/cache/abstract.py

@@ -15,6 +15,10 @@ class ExecutionTimeoutError(ExecutionError):
     pass
 
 
+class TigerExecutionTimeoutError(ExecutionError):
+    pass
+
+
 class Cache(Generic[TValue], ABC):
     @abstractmethod
     def get(self, key: str) -> Optional[TValue]:

snuba/state/cache/redis/backend.py

@@ -2,7 +2,7 @@
 import logging
 import uuid
 from concurrent.futures import ThreadPoolExecutor
-from typing import Callable, Optional
+from typing import Callable, Optional, Type
 
 from pkg_resources import resource_string
 
@@ -34,11 +34,13 @@ def __init__(
         prefix: str,
         codec: ExceptionAwareCodec[bytes, TValue],
         executor: ThreadPoolExecutor,
+        timeout_exception: Optional[Type[Exception]] = ExecutionTimeoutError,
     ) -> None:
         self.__client = client
         self.__prefix = prefix
         self.__codec = codec
         self.__executor = executor
+        self.__timeout_exception = timeout_exception
 
         # TODO: This should probably be lazily instantiated, rather than
         # automatically happening at startup.
@@ -257,7 +259,7 @@ def build_notify_queue_key(task_ident: str) -> str:
                     # If the effective timeout was the remaining task timeout,
                     # this means that the client responsible for generating the
                     # cache value didn't do so before it promised to.
-                    raise ExecutionTimeoutError(
+                    raise self.__timeout_exception(
                         "result not available before execution deadline"
                     )
                 else:

snuba/web/db_query.py

@@ -33,7 +33,11 @@
 from snuba.reader import Reader, Result
 from snuba.redis import redis_client
 from snuba.request.request_settings import RequestSettings
-from snuba.state.cache.abstract import Cache, ExecutionTimeoutError
+from snuba.state.cache.abstract import (
+    Cache,
+    ExecutionTimeoutError,
+    TigerExecutionTimeoutError,
+)
 from snuba.state.cache.redis.backend import RESULT_VALUE, RESULT_WAIT, RedisCache
 from snuba.state.rate_limit import (
     GLOBAL_RATE_LIMIT_NAME,
@@ -79,7 +83,10 @@ def encode_exception(self, value: SerializableException) -> bytes:
 # reader when running a query.
 cache_partitions: MutableMapping[str, Cache[Result]] = {
     DEFAULT_CACHE_PARTITION_ID: RedisCache(
-        redis_client, "snuba-query-cache:", ResultCacheCodec(), ThreadPoolExecutor()
+        redis_client,
+        "snuba-query-cache:",
+        ResultCacheCodec(),
+        ThreadPoolExecutor(),
     )
 }
 # This lock prevents us from initializing the cache twice. The cache is initialized
@@ -362,11 +369,17 @@ def _get_cache_partition(reader: Reader) -> Cache[Result]:
             # during the first query. So, for the vast majority of queries, the overhead
             # of acquiring the lock is not needed.
             if partition_id not in cache_partitions:
+                exception = (
+                    TigerExecutionTimeoutError
+                    if "tiger" in partition_id
+                    else ExecutionTimeoutError
+                )
                 cache_partitions[partition_id] = RedisCache(
                     redis_client,
                     f"snuba-query-cache:{partition_id}:",
                     ResultCacheCodec(),
                     ThreadPoolExecutor(),
+                    exception,
                 )
 
     return cache_partitions[
@@ -587,7 +600,10 @@ def raw_query(
                             errors.ErrorCodes.NETWORK_ERROR,
                         ):
                             sentry_sdk.set_tag("timeout", "network")
-                elif isinstance(cause, (TimeoutError, ExecutionTimeoutError)):
+                elif isinstance(
+                    cause,
+                    (TimeoutError, ExecutionTimeoutError, TigerExecutionTimeoutError),
+                ):
                     if scope.span:
                         sentry_sdk.set_tag("timeout", "cache_timeout")