@trieb.work/nextjs-turbo-redis-cache 1.7.1 → 1.8.0-beta.1

package/dist/index.js

@@ -194,18 +194,22 @@ var SyncedMap = class {
     };
     try {
       await this.subscriberClient.connect().catch(async () => {
-        await this.subscriberClient.connect();
+        console.error("Failed to connect subscriber client. Retrying...");
+        await this.subscriberClient.connect().catch((error) => {
+          console.error("Failed to connect subscriber client.", error);
+          throw error;
+        });
       });
       if ((process.env.SKIP_KEYSPACE_CONFIG_CHECK || "").toUpperCase() !== "TRUE") {
         const keyspaceEventConfig = (await this.subscriberClient.configGet("notify-keyspace-events"))?.["notify-keyspace-events"];
         if (!keyspaceEventConfig.includes("E")) {
           throw new Error(
-            "Keyspace event configuration has to include 'E' for Keyevent events, published with __keyevent@<db>__ prefix. We recommend to set it to 'Exe' like so `redis-cli -h localhost config set notify-keyspace-events Exe`"
+            'Keyspace event configuration is set to "' + keyspaceEventConfig + "\" but has to include 'E' for Keyevent events, published with __keyevent@<db>__ prefix. We recommend to set it to 'Exe' like so `redis-cli -h localhost config set notify-keyspace-events Exe`"
           );
         }
         if (!keyspaceEventConfig.includes("A") && !(keyspaceEventConfig.includes("x") && keyspaceEventConfig.includes("e"))) {
           throw new Error(
-            "Keyspace event configuration has to include 'A' or 'x' and 'e' for expired and evicted events. We recommend to set it to 'Exe' like so `redis-cli -h localhost config set notify-keyspace-events Exe`"
+            'Keyspace event configuration is set to "' + keyspaceEventConfig + "\" but has to include 'A' or 'x' and 'e' for expired and evicted events. We recommend to set it to 'Exe' like so `redis-cli -h localhost config set notify-keyspace-events Exe`"
           );
         }
       }
@@ -286,8 +290,6 @@ var SyncedMap = class {
     );
     await Promise.all(operations);
   }
-  // /api/revalidated-fetch
-  // true
   async delete(keys, withoutSyncMessage = false) {
     debugVerbose(
       "SyncedMap.delete() called with keys",
@@ -441,325 +443,455 @@ var REVALIDATED_TAGS_KEY = "__revalidated_tags__";
 function getTimeoutRedisCommandOptions(timeoutMs) {
   return (0, import_redis.commandOptions)({ signal: AbortSignal.timeout(timeoutMs) });
 }
+var killContainerOnErrorCount = 0;
 var RedisStringsHandler = class {
   constructor({
     redisUrl = process.env.REDIS_URL ? process.env.REDIS_URL : process.env.REDISHOST ? `redis://${process.env.REDISHOST}:${process.env.REDISPORT}` : "redis://localhost:6379",
     database = process.env.VERCEL_ENV === "production" ? 0 : 1,
     keyPrefix = process.env.VERCEL_URL || "UNDEFINED_URL_",
     sharedTagsKey = "__sharedTags__",
-    timeoutMs = 5e3,
+    timeoutMs = process.env.REDIS_COMMAND_TIMEOUT_MS ? Number.parseInt(process.env.REDIS_COMMAND_TIMEOUT_MS) ?? 5e3 : 5e3,
     revalidateTagQuerySize = 250,
     avgResyncIntervalMs = 60 * 60 * 1e3,
     redisGetDeduplication = true,
     inMemoryCachingTime = 1e4,
     defaultStaleAge = 60 * 60 * 24 * 14,
     estimateExpireAge = (staleAge) => process.env.VERCEL_ENV === "production" ? staleAge * 2 : staleAge * 1.2,
+    killContainerOnErrorThreshold = process.env.KILL_CONTAINER_ON_ERROR_THRESHOLD ? Number.parseInt(process.env.KILL_CONTAINER_ON_ERROR_THRESHOLD) ?? 0 : 0,
     socketOptions,
     clientOptions
   }) {
-    this.keyPrefix = keyPrefix;
-    this.timeoutMs = timeoutMs;
-    this.redisGetDeduplication = redisGetDeduplication;
-    this.inMemoryCachingTime = inMemoryCachingTime;
-    this.defaultStaleAge = defaultStaleAge;
-    this.estimateExpireAge = estimateExpireAge;
+    this.clientReadyCalls = 0;
     try {
-      this.client = (0, import_redis.createClient)({
-        url: redisUrl,
-        ...database !== 0 ? { database } : {},
-        ...socketOptions ? { socket: socketOptions } : {},
-        ...clientOptions || {}
+      this.keyPrefix = keyPrefix;
+      this.timeoutMs = timeoutMs;
+      this.redisGetDeduplication = redisGetDeduplication;
+      this.inMemoryCachingTime = inMemoryCachingTime;
+      this.defaultStaleAge = defaultStaleAge;
+      this.estimateExpireAge = estimateExpireAge;
+      this.killContainerOnErrorThreshold = killContainerOnErrorThreshold;
+      try {
+        this.client = (0, import_redis.createClient)({
+          url: redisUrl,
+          pingInterval: 5e3,
+          // Useful with Redis deployments that do not use TCP Keep-Alive. Restarts the connection if it is idle for too long.
+          ...database !== 0 ? { database } : {},
+          ...socketOptions ? { socket: { connectTimeout: timeoutMs, ...socketOptions } } : { connectTimeout: timeoutMs },
+          ...clientOptions || {}
+        });
+        this.client.on("error", (error) => {
+          console.error(
+            "Redis client error",
+            error,
+            killContainerOnErrorCount++
+          );
+          setTimeout(
+            () => this.client.connect().catch((error2) => {
+              console.error(
+                "Failed to reconnect Redis client after connection loss:",
+                error2
+              );
+            }),
+            1e3
+          );
+          if (this.killContainerOnErrorThreshold > 0 && killContainerOnErrorCount >= this.killContainerOnErrorThreshold) {
+            console.error(
+              "Redis client error threshold reached, disconnecting and exiting (please implement a restart process/container watchdog to handle this error)",
+              error,
+              killContainerOnErrorCount++
+            );
+            this.client.disconnect();
+            this.client.quit();
+            setTimeout(() => {
+              process.exit(1);
+            }, 500);
+          }
+        });
+        this.client.connect().then(() => {
+          console.info("Redis client connected.");
+        }).catch(() => {
+          this.client.connect().catch((error) => {
+            console.error("Failed to connect Redis client:", error);
+            this.client.disconnect();
+            throw error;
+          });
+        });
+      } catch (error) {
+        console.error("Failed to initialize Redis client");
+        throw error;
+      }
+      const filterKeys = (key) => key !== REVALIDATED_TAGS_KEY && key !== sharedTagsKey;
+      this.sharedTagsMap = new SyncedMap({
+        client: this.client,
+        keyPrefix,
+        redisKey: sharedTagsKey,
+        database,
+        timeoutMs,
+        querySize: revalidateTagQuerySize,
+        filterKeys,
+        resyncIntervalMs: avgResyncIntervalMs - avgResyncIntervalMs / 10 + Math.random() * (avgResyncIntervalMs / 10)
       });
-      this.client.on("error", (error) => {
-        console.error("Redis client error", error);
+      this.revalidatedTagsMap = new SyncedMap({
+        client: this.client,
+        keyPrefix,
+        redisKey: REVALIDATED_TAGS_KEY,
+        database,
+        timeoutMs,
+        querySize: revalidateTagQuerySize,
+        filterKeys,
+        resyncIntervalMs: avgResyncIntervalMs + avgResyncIntervalMs / 10 + Math.random() * (avgResyncIntervalMs / 10)
       });
-      this.client.connect().then(() => {
-        console.info("Redis client connected.");
-      }).catch(() => {
-        this.client.connect().catch((error) => {
-          console.error("Failed to connect Redis client:", error);
-          this.client.disconnect();
-          throw error;
-        });
+      this.inMemoryDeduplicationCache = new SyncedMap({
+        client: this.client,
+        keyPrefix,
+        redisKey: "inMemoryDeduplicationCache",
+        database,
+        timeoutMs,
+        querySize: revalidateTagQuerySize,
+        filterKeys,
+        customizedSync: {
+          withoutRedisHashmap: true,
+          withoutSetSync: true
+        }
       });
+      const redisGet = this.client.get.bind(this.client);
+      this.redisDeduplicationHandler = new DeduplicatedRequestHandler(
+        redisGet,
+        inMemoryCachingTime,
+        this.inMemoryDeduplicationCache
+      );
+      this.redisGet = redisGet;
+      this.deduplicatedRedisGet = this.redisDeduplicationHandler.deduplicatedFunction;
     } catch (error) {
-      console.error("Failed to initialize Redis client");
+      console.error(
+        "RedisStringsHandler constructor error",
+        error,
+        killContainerOnErrorCount++
+      );
+      if (killContainerOnErrorThreshold > 0 && killContainerOnErrorCount >= killContainerOnErrorThreshold) {
+        console.error(
+          "RedisStringsHandler constructor error threshold reached, disconnecting and exiting (please implement a restart process/container watchdog to handle this error)",
+          error,
+          killContainerOnErrorCount++
+        );
+        process.exit(1);
+      }
       throw error;
     }
-    const filterKeys = (key) => key !== REVALIDATED_TAGS_KEY && key !== sharedTagsKey;
-    this.sharedTagsMap = new SyncedMap({
-      client: this.client,
-      keyPrefix,
-      redisKey: sharedTagsKey,
-      database,
-      timeoutMs,
-      querySize: revalidateTagQuerySize,
-      filterKeys,
-      resyncIntervalMs: avgResyncIntervalMs - avgResyncIntervalMs / 10 + Math.random() * (avgResyncIntervalMs / 10)
-    });
-    this.revalidatedTagsMap = new SyncedMap({
-      client: this.client,
-      keyPrefix,
-      redisKey: REVALIDATED_TAGS_KEY,
-      database,
-      timeoutMs,
-      querySize: revalidateTagQuerySize,
-      filterKeys,
-      resyncIntervalMs: avgResyncIntervalMs + avgResyncIntervalMs / 10 + Math.random() * (avgResyncIntervalMs / 10)
-    });
-    this.inMemoryDeduplicationCache = new SyncedMap({
-      client: this.client,
-      keyPrefix,
-      redisKey: "inMemoryDeduplicationCache",
-      database,
-      timeoutMs,
-      querySize: revalidateTagQuerySize,
-      filterKeys,
-      customizedSync: {
-        withoutRedisHashmap: true,
-        withoutSetSync: true
-      }
-    });
-    const redisGet = this.client.get.bind(this.client);
-    this.redisDeduplicationHandler = new DeduplicatedRequestHandler(
-      redisGet,
-      inMemoryCachingTime,
-      this.inMemoryDeduplicationCache
-    );
-    this.redisGet = redisGet;
-    this.deduplicatedRedisGet = this.redisDeduplicationHandler.deduplicatedFunction;
   }
   resetRequestCache() {
   }
   async assertClientIsReady() {
-    await Promise.all([
-      this.sharedTagsMap.waitUntilReady(),
-      this.revalidatedTagsMap.waitUntilReady()
+    if (this.clientReadyCalls > 10) {
+      throw new Error(
+        "assertClientIsReady called more than 10 times without being ready."
+      );
+    }
+    await Promise.race([
+      Promise.all([
+        this.sharedTagsMap.waitUntilReady(),
+        this.revalidatedTagsMap.waitUntilReady()
+      ]),
+      new Promise(
+        (_, reject) => setTimeout(() => {
+          reject(
+            new Error(
+              "assertClientIsReady: Timeout waiting for Redis maps to be ready"
+            )
+          );
+        }, this.timeoutMs * 5)
+      )
     ]);
+    this.clientReadyCalls = 0;
     if (!this.client.isReady) {
-      throw new Error("Redis client is not ready yet or connection is lost.");
+      throw new Error(
+        "assertClientIsReady: Redis client is not ready yet or connection is lost."
+      );
     }
   }
   async get(key, ctx) {
-    if (ctx.kind !== "APP_ROUTE" && ctx.kind !== "APP_PAGE" && ctx.kind !== "FETCH") {
-      console.warn(
-        "RedisStringsHandler.get() called with",
-        key,
-        ctx,
-        " this cache handler is only designed and tested for kind APP_ROUTE and APP_PAGE and not for kind ",
-        ctx?.kind
+    try {
+      if (ctx.kind !== "APP_ROUTE" && ctx.kind !== "APP_PAGE" && ctx.kind !== "FETCH") {
+        console.warn(
+          "RedisStringsHandler.get() called with",
+          key,
+          ctx,
+          " this cache handler is only designed and tested for kind APP_ROUTE and APP_PAGE and not for kind ",
+          ctx?.kind
+        );
+      }
+      debug("green", "RedisStringsHandler.get() called with", key, ctx);
+      await this.assertClientIsReady();
+      const clientGet = this.redisGetDeduplication ? this.deduplicatedRedisGet(key) : this.redisGet;
+      const serializedCacheEntry = await clientGet(
+        getTimeoutRedisCommandOptions(this.timeoutMs),
+        this.keyPrefix + key
       );
-    }
-    debug("green", "RedisStringsHandler.get() called with", key, ctx);
-    await this.assertClientIsReady();
-    const clientGet = this.redisGetDeduplication ? this.deduplicatedRedisGet(key) : this.redisGet;
-    const serializedCacheEntry = await clientGet(
-      getTimeoutRedisCommandOptions(this.timeoutMs),
-      this.keyPrefix + key
-    );
-    debug(
-      "green",
-      "RedisStringsHandler.get() finished with result (serializedCacheEntry)",
-      serializedCacheEntry?.substring(0, 200)
-    );
-    if (!serializedCacheEntry) {
-      return null;
-    }
-    const cacheEntry = JSON.parse(
-      serializedCacheEntry,
-      bufferReviver
-    );
-    debug(
-      "green",
-      "RedisStringsHandler.get() finished with result (cacheEntry)",
-      JSON.stringify(cacheEntry).substring(0, 200)
-    );
-    if (!cacheEntry) {
-      return null;
-    }
-    if (!cacheEntry?.tags) {
-      console.warn(
-        "RedisStringsHandler.get() called with",
-        key,
-        ctx,
-        "cacheEntry is mall formed (missing tags)"
+      debug(
+        "green",
+        "RedisStringsHandler.get() finished with result (serializedCacheEntry)",
+        serializedCacheEntry?.substring(0, 200)
       );
-    }
-    if (!cacheEntry?.value) {
-      console.warn(
-        "RedisStringsHandler.get() called with",
-        key,
-        ctx,
-        "cacheEntry is mall formed (missing value)"
+      if (!serializedCacheEntry) {
+        return null;
+      }
+      const cacheEntry = JSON.parse(
+        serializedCacheEntry,
+        bufferReviver
       );
-    }
-    if (!cacheEntry?.lastModified) {
-      console.warn(
-        "RedisStringsHandler.get() called with",
-        key,
-        ctx,
-        "cacheEntry is mall formed (missing lastModified)"
+      debug(
+        "green",
+        "RedisStringsHandler.get() finished with result (cacheEntry)",
+        JSON.stringify(cacheEntry).substring(0, 200)
       );
-    }
-    if (ctx.kind === "FETCH") {
-      const combinedTags = /* @__PURE__ */ new Set([
-        ...ctx?.softTags || [],
-        ...ctx?.tags || []
-      ]);
-      if (combinedTags.size === 0) {
-        return cacheEntry;
+      if (!cacheEntry) {
+        return null;
       }
-      for (const tag of combinedTags) {
-        const revalidationTime = this.revalidatedTagsMap.get(tag);
-        if (revalidationTime && revalidationTime > cacheEntry.lastModified) {
-          const redisKey = this.keyPrefix + key;
-          this.client.unlink(getTimeoutRedisCommandOptions(this.timeoutMs), redisKey).catch((err) => {
-            console.error(
-              "Error occurred while unlinking stale data. Error was:",
-              err
+      if (!cacheEntry?.tags) {
+        console.warn(
+          "RedisStringsHandler.get() called with",
+          key,
+          ctx,
+          "cacheEntry is mall formed (missing tags)"
+        );
+      }
+      if (!cacheEntry?.value) {
+        console.warn(
+          "RedisStringsHandler.get() called with",
+          key,
+          ctx,
+          "cacheEntry is mall formed (missing value)"
+        );
+      }
+      if (!cacheEntry?.lastModified) {
+        console.warn(
+          "RedisStringsHandler.get() called with",
+          key,
+          ctx,
+          "cacheEntry is mall formed (missing lastModified)"
+        );
+      }
+      if (ctx.kind === "FETCH") {
+        const combinedTags = /* @__PURE__ */ new Set([
+          ...ctx?.softTags || [],
+          ...ctx?.tags || []
+        ]);
+        if (combinedTags.size === 0) {
+          return cacheEntry;
+        }
+        for (const tag of combinedTags) {
+          const revalidationTime = this.revalidatedTagsMap.get(tag);
+          if (revalidationTime && revalidationTime > cacheEntry.lastModified) {
+            const redisKey = this.keyPrefix + key;
+            this.client.unlink(getTimeoutRedisCommandOptions(this.timeoutMs), redisKey).catch((err) => {
+              console.error(
+                "Error occurred while unlinking stale data. Error was:",
+                err
+              );
+            }).finally(async () => {
+              await this.sharedTagsMap.delete(key);
+              await this.revalidatedTagsMap.delete(tag);
+            });
+            debug(
+              "green",
+              'RedisStringsHandler.get() found revalidation time for tag. Cache entry is stale and will be deleted and "null" will be returned.',
+              tag,
+              redisKey,
+              revalidationTime,
+              cacheEntry
             );
-          }).finally(async () => {
-            await this.sharedTagsMap.delete(key);
-            await this.revalidatedTagsMap.delete(tag);
-          });
-          debug(
-            "green",
-            'RedisStringsHandler.get() found revalidation time for tag. Cache entry is stale and will be deleted and "null" will be returned.',
-            tag,
-            redisKey,
-            revalidationTime,
-            cacheEntry
-          );
-          return null;
+            return null;
+          }
         }
       }
+      return cacheEntry;
+    } catch (error) {
+      console.error(
+        "RedisStringsHandler.get() Error occurred while getting cache entry. Returning null so site can continue to serve content while cache is disabled. The original error was:",
+        error,
+        killContainerOnErrorCount++
+      );
+      if (this.killContainerOnErrorThreshold > 0 && killContainerOnErrorCount >= this.killContainerOnErrorThreshold) {
+        console.error(
+          "RedisStringsHandler get() error threshold reached, disconnecting and exiting (please implement a restart process/container watchdog to handle this error)",
+          error,
+          killContainerOnErrorCount
+        );
+        this.client.disconnect();
+        this.client.quit();
+        setTimeout(() => {
+          process.exit(1);
+        }, 500);
+      }
+      return null;
     }
-    return cacheEntry;
   }
   async set(key, data, ctx) {
-    if (data.kind !== "APP_ROUTE" && data.kind !== "APP_PAGE" && data.kind !== "FETCH") {
-      console.warn(
-        "RedisStringsHandler.set() called with",
+    try {
+      if (data.kind !== "APP_ROUTE" && data.kind !== "APP_PAGE" && data.kind !== "FETCH") {
+        console.warn(
+          "RedisStringsHandler.set() called with",
+          key,
+          ctx,
+          data,
+          " this cache handler is only designed and tested for kind APP_ROUTE and APP_PAGE and not for kind ",
+          data?.kind
+        );
+      }
+      await this.assertClientIsReady();
+      if (data.kind === "APP_PAGE" || data.kind === "APP_ROUTE") {
+        const tags = data.headers["x-next-cache-tags"]?.split(",");
+        ctx.tags = [...ctx.tags || [], ...tags || []];
+      }
+      const cacheEntry = {
+        lastModified: Date.now(),
+        tags: ctx?.tags || [],
+        value: data
+      };
+      const serializedCacheEntry = JSON.stringify(cacheEntry, bufferReplacer);
+      if (this.redisGetDeduplication) {
+        this.redisDeduplicationHandler.seedRequestReturn(
+          key,
+          serializedCacheEntry
+        );
+      }
+      const revalidate = (
+        // For fetch requests in newest versions, the revalidate context property is never used, and instead the revalidate property of the passed-in data is used
+        data.kind === "FETCH" && data.revalidate || ctx.revalidate || ctx.cacheControl?.revalidate || data?.revalidate
+      );
+      const expireAt = revalidate && Number.isSafeInteger(revalidate) && revalidate > 0 ? this.estimateExpireAge(revalidate) : this.estimateExpireAge(this.defaultStaleAge);
+      const options = getTimeoutRedisCommandOptions(this.timeoutMs);
+      const setOperation = this.client.set(
+        options,
+        this.keyPrefix + key,
+        serializedCacheEntry,
+        {
+          EX: expireAt
+        }
+      );
+      debug(
+        "blue",
+        "RedisStringsHandler.set() will set the following serializedCacheEntry",
+        this.keyPrefix,
         key,
-        ctx,
         data,
-        " this cache handler is only designed and tested for kind APP_ROUTE and APP_PAGE and not for kind ",
-        data?.kind
+        ctx,
+        serializedCacheEntry?.substring(0, 200),
+        expireAt
       );
-    }
-    await this.assertClientIsReady();
-    if (data.kind === "APP_PAGE" || data.kind === "APP_ROUTE") {
-      const tags = data.headers["x-next-cache-tags"]?.split(",");
-      ctx.tags = [...ctx.tags || [], ...tags || []];
-    }
-    const cacheEntry = {
-      lastModified: Date.now(),
-      tags: ctx?.tags || [],
-      value: data
-    };
-    const serializedCacheEntry = JSON.stringify(cacheEntry, bufferReplacer);
-    if (this.redisGetDeduplication) {
-      this.redisDeduplicationHandler.seedRequestReturn(
+      let setTagsOperation;
+      if (ctx.tags && ctx.tags.length > 0) {
+        const currentTags = this.sharedTagsMap.get(key);
+        const currentIsSameAsNew = currentTags?.length === ctx.tags.length && currentTags.every((v) => ctx.tags.includes(v)) && ctx.tags.every((v) => currentTags.includes(v));
+        if (!currentIsSameAsNew) {
+          setTagsOperation = this.sharedTagsMap.set(
+            key,
+            structuredClone(ctx.tags)
+          );
+        }
+      }
+      debug(
+        "blue",
+        "RedisStringsHandler.set() will set the following sharedTagsMap",
         key,
-        serializedCacheEntry
+        ctx.tags
       );
-    }
-    const revalidate = (
-      // For fetch requests in newest versions, the revalidate context property is never used, and instead the revalidate property of the passed-in data is used
-      data.kind === "FETCH" && data.revalidate || ctx.revalidate || ctx.cacheControl?.revalidate
-    );
-    const expireAt = revalidate && Number.isSafeInteger(revalidate) && revalidate > 0 ? this.estimateExpireAge(revalidate) : this.estimateExpireAge(this.defaultStaleAge);
-    const options = getTimeoutRedisCommandOptions(this.timeoutMs);
-    const setOperation = this.client.set(
-      options,
-      this.keyPrefix + key,
-      serializedCacheEntry,
-      {
-        EX: expireAt
-      }
-    );
-    debug(
-      "blue",
-      "RedisStringsHandler.set() will set the following serializedCacheEntry",
-      this.keyPrefix,
-      key,
-      data,
-      ctx,
-      serializedCacheEntry?.substring(0, 200),
-      expireAt
-    );
-    let setTagsOperation;
-    if (ctx.tags && ctx.tags.length > 0) {
-      const currentTags = this.sharedTagsMap.get(key);
-      const currentIsSameAsNew = currentTags?.length === ctx.tags.length && currentTags.every((v) => ctx.tags.includes(v)) && ctx.tags.every((v) => currentTags.includes(v));
-      if (!currentIsSameAsNew) {
-        setTagsOperation = this.sharedTagsMap.set(
-          key,
-          structuredClone(ctx.tags)
+      await Promise.all([setOperation, setTagsOperation]);
+    } catch (error) {
+      console.error(
+        "RedisStringsHandler.set() Error occurred while setting cache entry. The original error was:",
+        error,
+        killContainerOnErrorCount++
+      );
+      if (this.killContainerOnErrorThreshold > 0 && killContainerOnErrorCount >= this.killContainerOnErrorThreshold) {
+        console.error(
+          "RedisStringsHandler set() error threshold reached, disconnecting and exiting (please implement a restart process/container watchdog to handle this error)",
+          error,
+          killContainerOnErrorCount
         );
+        this.client.disconnect();
+        this.client.quit();
+        setTimeout(() => {
+          process.exit(1);
+        }, 500);
       }
+      throw error;
     }
-    debug(
-      "blue",
-      "RedisStringsHandler.set() will set the following sharedTagsMap",
-      key,
-      ctx.tags
-    );
-    await Promise.all([setOperation, setTagsOperation]);
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async revalidateTag(tagOrTags, ...rest) {
-    debug(
-      "red",
-      "RedisStringsHandler.revalidateTag() called with",
-      tagOrTags,
-      rest
-    );
-    const tags = new Set([tagOrTags || []].flat());
-    await this.assertClientIsReady();
-    const keysToDelete = /* @__PURE__ */ new Set();
-    for (const tag of tags) {
-      if (tag.startsWith(NEXT_CACHE_IMPLICIT_TAG_ID)) {
-        const now = Date.now();
-        debug(
-          "red",
-          "RedisStringsHandler.revalidateTag() set revalidation time for tag",
-          tag,
-          "to",
-          now
-        );
-        await this.revalidatedTagsMap.set(tag, now);
+    try {
+      debug(
+        "red",
+        "RedisStringsHandler.revalidateTag() called with",
+        tagOrTags,
+        rest
+      );
+      const tags = new Set([tagOrTags || []].flat());
+      await this.assertClientIsReady();
+      const keysToDelete = /* @__PURE__ */ new Set();
+      for (const tag of tags) {
+        if (tag.startsWith(NEXT_CACHE_IMPLICIT_TAG_ID)) {
+          const now = Date.now();
+          debug(
+            "red",
+            "RedisStringsHandler.revalidateTag() set revalidation time for tag",
+            tag,
+            "to",
+            now
+          );
+          await this.revalidatedTagsMap.set(tag, now);
+        }
       }
-    }
-    for (const [key, sharedTags] of this.sharedTagsMap.entries()) {
-      if (sharedTags.some((tag) => tags.has(tag))) {
-        keysToDelete.add(key);
+      for (const [key, sharedTags] of this.sharedTagsMap.entries()) {
+        if (sharedTags.some((tag) => tags.has(tag))) {
+          keysToDelete.add(key);
+        }
       }
-    }
-    debug(
-      "red",
-      "RedisStringsHandler.revalidateTag() found",
-      keysToDelete,
-      "keys to delete"
-    );
-    if (keysToDelete.size === 0) {
-      return;
-    }
-    const redisKeys = Array.from(keysToDelete);
-    const fullRedisKeys = redisKeys.map((key) => this.keyPrefix + key);
-    const options = getTimeoutRedisCommandOptions(this.timeoutMs);
-    const deleteKeysOperation = this.client.unlink(options, fullRedisKeys);
-    if (this.redisGetDeduplication && this.inMemoryCachingTime > 0) {
-      for (const key of keysToDelete) {
-        this.inMemoryDeduplicationCache.delete(key);
+      debug(
+        "red",
+        "RedisStringsHandler.revalidateTag() found",
+        keysToDelete,
+        "keys to delete"
+      );
+      if (keysToDelete.size === 0) {
+        return;
+      }
+      const redisKeys = Array.from(keysToDelete);
+      const fullRedisKeys = redisKeys.map((key) => this.keyPrefix + key);
+      const options = getTimeoutRedisCommandOptions(this.timeoutMs);
+      const deleteKeysOperation = this.client.unlink(options, fullRedisKeys);
+      if (this.redisGetDeduplication && this.inMemoryCachingTime > 0) {
+        for (const key of keysToDelete) {
+          this.inMemoryDeduplicationCache.delete(key);
+        }
       }
+      const deleteTagsOperation = this.sharedTagsMap.delete(redisKeys);
+      await Promise.all([deleteKeysOperation, deleteTagsOperation]);
+      debug(
+        "red",
+        "RedisStringsHandler.revalidateTag() finished delete operations"
+      );
+    } catch (error) {
+      console.error(
+        "RedisStringsHandler.revalidateTag() Error occurred while revalidating tags. The original error was:",
+        error,
+        killContainerOnErrorCount++
+      );
+      if (this.killContainerOnErrorThreshold > 0 && killContainerOnErrorCount >= this.killContainerOnErrorThreshold) {
+        console.error(
+          "RedisStringsHandler revalidateTag() error threshold reached, disconnecting and exiting (please implement a restart process/container watchdog to handle this error)",
+          error,
+          killContainerOnErrorCount
+        );
+        this.client.disconnect();
+        this.client.quit();
+        setTimeout(() => {
+          process.exit(1);
+        }, 500);
+      }
+      throw error;
     }
-    const deleteTagsOperation = this.sharedTagsMap.delete(redisKeys);
-    await Promise.all([deleteKeysOperation, deleteTagsOperation]);
-    debug(
-      "red",
-      "RedisStringsHandler.revalidateTag() finished delete operations"
-    );
   }
 };