feat: handle redis errors (hiero-ledger#4558)

Signed-off-by: Mariusz Jasuwienas <jasuwienas@gmail.com>

Author: jasuwienas

packages/relay/src/lib/clients/cache/redisCache/index.ts

@@ -0,0 +1,3 @@
+// SPDX-License-Identifier: Apache-2.0
+
+export { SafeRedisCache as RedisCache } from './safeRedisCache';

packages/relay/src/lib/clients/cache/redisCache.ts renamed to packages/relay/src/lib/clients/cache/redisCache/redisCache.ts

@@ -4,8 +4,8 @@ import { ConfigService } from '@hashgraph/json-rpc-config-service/dist/services'
 import { Logger } from 'pino';
 import { RedisClientType } from 'redis';
 
-import { Utils } from '../../../utils';
-import { ICacheClient } from './ICacheClient';
+import { Utils } from '../../../../utils';
+import { ICacheClient } from '../ICacheClient';
 
 /**
  * A class that provides caching functionality using Redis.
@@ -35,7 +35,7 @@ export class RedisCache implements ICacheClient {
    * The logger used for logging all output from this class.
    * @private
    */
-  private readonly logger: Logger;
+  protected readonly logger: Logger;
 
   /**
    * The Redis client.

packages/relay/src/lib/clients/cache/redisCache/safeRedisCache.ts

@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import { RedisCacheError } from '../../../errors/RedisCacheError';
+import { RedisCache } from './redisCache';
+
+/**
+ * A safer wrapper around {@link RedisCache} which is responsible for:
+ *  - ignoring all Redis command errors.
+ *  - logging all errors,
+ *  - returning default values in cases of failures.
+ *
+ * Thanks to that our application will be able to continue functioning even with Redis being down...
+ */
+export class SafeRedisCache extends RedisCache {
+  /**
+   * Retrieves a value from the cache.
+   *
+   * This method wraps {@link RedisCache.get} and ensures `null` is returned instead of throwing error.
+   *
+   * @param key - The cache key.
+   * @param callingMethod - Name of the method making the request (for logging).
+   * @returns The cached value, or `null` if Redis fails or the value does not exist.
+   */
+  async get(key: string, callingMethod: string): Promise<any> {
+    return await this.safeCall(() => super.get(key, callingMethod), null);
+  }
+
+  /**
+   /**
+   * Stores a value in the cache safely.
+   *
+   * Wraps {@link RedisCache.set} and suppresses Redis errors.
+   * On failure, nothing is thrown and the error is logged.
+   *
+   * @param key - The cache key.
+   * @param value - The value to store.
+   * @param callingMethod - Name of the calling method.
+   * @param ttl - Optional TTL in milliseconds.
+   */
+  async set(key: string, value: any, callingMethod: string, ttl?: number): Promise<void> {
+    await this.safeCall(() => super.set(key, value, callingMethod, ttl), undefined);
+  }
+
+  /**
+   * Stores multiple key-value pairs safely.
+   *
+   * Wraps {@link RedisCache.multiSet} with error suppression.
+   *
+   * @param keyValuePairs - Object of key-value pairs to set.
+   * @param callingMethod - Name of the calling method.
+   * @param ttl - Optional TTL used in fallback pipeline mode.
+   */
+  async multiSet(keyValuePairs: Record<string, any>, callingMethod: string, ttl?: number): Promise<void> {
+    await this.safeCall(() => super.multiSet(keyValuePairs, callingMethod, ttl), undefined);
+  }
+
+  /**
+   * Performs a pipelined multi-set operation safely.
+   *
+   * Wraps {@link RedisCache.pipelineSet} with error suppression.
+   *
+   * @param keyValuePairs - Key-value pairs to write.
+   * @param callingMethod - Name of the calling method.
+   * @param ttl - Optional TTL.
+   */
+  async pipelineSet(keyValuePairs: Record<string, any>, callingMethod: string, ttl?: number): Promise<void> {
+    await this.safeCall(() => super.pipelineSet(keyValuePairs, callingMethod, ttl), undefined);
+  }
+
+  /**
+   * Deletes a value from the cache safely.
+   *
+   * Wraps {@link RedisCache.delete} with error suppression.
+   *
+   * @param key - Key to delete.
+   * @param callingMethod - Name of the calling method.
+   */
+  async delete(key: string, callingMethod: string): Promise<void> {
+    await this.safeCall(() => super.delete(key, callingMethod), undefined);
+  }
+
+  /**
+   * Increments a numeric value safely.
+   *
+   * Wraps {@link RedisCache.incrBy}.
+   * On failure, returns the `amount` argument as fallback.
+   *
+   * @param key - Key to increment.
+   * @param amount - Increment amount.
+   * @param callingMethod - Name of the calling method.
+   * @returns The incremented value or the fallback (amount) if Redis fails.
+   */
+  async incrBy(key: string, amount: number, callingMethod: string): Promise<number> {
+    return await this.safeCall(() => super.incrBy(key, amount, callingMethod), amount);
+  }
+
+  /**
+   * Retrieves a list slice safely.
+   *
+   * Wraps {@link RedisCache.lRange}.
+   * On error, returns an empty array.
+   *
+   * @param key - List key.
+   * @param start - Start index.
+   * @param end - End index.
+   * @param callingMethod - Name of the calling method.
+   * @returns List of elements, or an empty array on failure.
+   */
+  async lRange(key: string, start: number, end: number, callingMethod: string): Promise<any[]> {
+    return await this.safeCall(() => super.lRange(key, start, end, callingMethod), []);
+  }
+
+  /**
+   * Pushes a value to a list safely.
+   *
+   * Wraps {@link RedisCache.rPush}.
+   * Returns `0` on failure.
+   *
+   * @param key - List key.
+   * @param value - Value to push.
+   * @param callingMethod - Name of the calling method.
+   * @returns The new list length, or `0` if Redis fails.
+   */
+  async rPush(key: string, value: any, callingMethod: string): Promise<number> {
+    return await this.safeCall(() => super.rPush(key, value, callingMethod), 0);
+  }
+
+  /**
+   * Retrieves keys matching a pattern safely.
+   *
+   * Wraps {@link RedisCache.keys}.
+   * Returns an empty array on error.
+   *
+   * @param pattern - Match pattern.
+   * @param callingMethod - Name of the calling method.
+   * @returns Array of matched keys (prefix removed), or empty array on error.
+   */
+  async keys(pattern: string, callingMethod: string): Promise<string[]> {
+    return await this.safeCall(() => super.keys(pattern, callingMethod), []);
+  }
+
+  /**
+   * Clears all cache keys safely.
+   *
+   * Wraps {@link RedisCache.clear}.
+   * Any Redis failure is logged and ignored.
+   */
+
+  async clear(): Promise<void> {
+    await this.safeCall(() => super.clear(), null);
+  }
+
+  /**
+   * Executes a Redis call safely.
+   *
+   * This is the core safety mechanism of {@link SafeRedisCache}.
+   *
+   * @template T The expected return type.
+   * @param fn - Function containing the Redis call.
+   * @param fallback - Value to return if an error occurs.
+   * @returns The result of `fn()` or the fallback.
+   */
+  async safeCall<T>(fn: () => Promise<T>, fallback: T): Promise<T> {
+    try {
+      return await fn();
+    } catch (error) {
+      const redisError = new RedisCacheError(error);
+      this.logger.error(redisError, 'Error occurred while getting the cache from Redis.');
+      return fallback;
+    }
+  }
+}

packages/relay/src/lib/clients/index.ts

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export * from './cache/localLRUCache';
-export * from './cache/redisCache';
+export * from './cache/redisCache/index';
 export * from './mirrorNodeClient';
 export * from './sdkClient';

packages/relay/tests/lib/services/cacheService/cacheService.spec.ts

@@ -324,58 +324,43 @@ describe('CacheService Test Suite', async function () {
       }
     });
 
-    it('should be able to getAsync from internal cache in case of Redis error', async function () {
+    it('should be able to ignore getAsync failure in case of Redis error', async function () {
       const key = 'string';
       await redisManager.disconnect();
-
-      const cachedValue = await cacheService.getAsync(key, callingMethod);
-      expect(cachedValue).eq(null);
+      await expect(cacheService.getAsync(key, callingMethod)).to.eventually.not.be.rejected;
     });
 
-    it('should be able to set to internal cache in case of Redis error', async function () {
+    it('should fail to set in case of Redis error', async function () {
       const key = 'string';
       const value = 'value';
 
       await redisManager.disconnect();
 
       await expect(cacheService.set(key, value, callingMethod)).to.eventually.not.be.rejected;
-
-      const internalCacheRes = await cacheService.getAsync(key, callingMethod);
-      expect(internalCacheRes).to.eq(value);
     });
 
-    it('should be able to multiSet to internal cache in case of Redis error', async function () {
+    it('should be able to ignore multiSet failure in case of Redis error', async function () {
       await redisManager.disconnect();
 
       await expect(cacheService.multiSet(multiSetEntries, callingMethod)).to.eventually.not.be.rejected;
-
-      for (const [key, value] of Object.entries(multiSetEntries)) {
-        const internalCacheRes = await cacheService.getAsync(key, callingMethod);
-        expect(internalCacheRes).to.eq(value);
-      }
     });
 
-    it('should be able to pipelineSet to internal cache in case of Redis error', async function () {
+    it('should be able to ignore pipelineSet failure in case of Redis error', async function () {
       // @ts-ignore
       cacheService['shouldMultiSet'] = false;
 
       await redisManager.disconnect();
 
       await expect(cacheService.multiSet(multiSetEntries, callingMethod)).to.eventually.not.be.rejected;
-
-      for (const [key, value] of Object.entries(multiSetEntries)) {
-        const internalCacheRes = await cacheService.getAsync(key, callingMethod);
-        expect(internalCacheRes).to.eq(value);
-      }
     });
 
-    it('should be able to clear from internal cache in case of Redis error', async function () {
+    it('should be able to ignore clear failure in case of Redis error', async function () {
       await redisManager.disconnect();
 
       await expect(cacheService.clear()).to.eventually.not.be.rejected;
     });
 
-    it('should be able to delete from internal cache in case of Redis error', async function () {
+    it('should be able to ignore delete failure in case of Redis error', async function () {
       const key = 'string';
       await redisManager.disconnect();
 
@@ -414,16 +399,11 @@ describe('CacheService Test Suite', async function () {
         expect(newValue).to.equal(15);
       });
 
-      it('should increment value in internal cache in case of Redis error', async function () {
+      it('should fail to increment value in case of Redis error', async function () {
         const key = 'counter';
-        const amount = 5;
-
-        await redisManager.disconnect();
-
         await cacheService.set(key, 10, callingMethod);
-        const newValue = await cacheService.incrBy(key, amount, callingMethod);
-
-        expect(newValue).to.equal(15);
+        await redisManager.disconnect();
+        expect(cacheService.incrBy(key, 5, callingMethod)).to.eventually.be.rejected;
       });
     });
 
@@ -438,7 +418,7 @@ describe('CacheService Test Suite', async function () {
         expect(cachedValue).to.deep.equal([value]);
       });
 
-      it('should push value to internal cache in case of Redis error', async function () {
+      it('should not push value in case of Redis error', async function () {
         const key = 'list';
         const value = 'item';
 
@@ -447,7 +427,7 @@ describe('CacheService Test Suite', async function () {
         await cacheService.rPush(key, value, callingMethod);
         const cachedValue = await cacheService.lRange(key, 0, -1, callingMethod);
 
-        expect(cachedValue).to.deep.equal([value]);
+        expect(cachedValue).to.deep.equal([]);
       });
     });
 
@@ -476,7 +456,7 @@ describe('CacheService Test Suite', async function () {
         expect(range).to.deep.equal(['item2', 'item3']);
       });
 
-      it('should retrieve range from internal cache in case of Redis error', async function () {
+      it('should not retrieve range in case of Redis error', async function () {
         await redisManager.disconnect();
 
         const key = 'list';
@@ -487,7 +467,7 @@ describe('CacheService Test Suite', async function () {
 
         const range = await cacheService.lRange(key, 0, 1, callingMethod);
 
-        expect(range).to.deep.equal(['item1', 'item2']);
+        expect(range).to.deep.equal([]);
       });
     });