Refactor Redis subscriber client initialization to ensure main Redis client readiness before creating subscriber. Update error handling and connection logic for improved reliability.

Author: nygrenh

backend/services/redis.ts

@@ -124,83 +124,56 @@ const getRedisClient = (): RedisClient | undefined => {
   return client
 }
 
-const getRedisSubscriberClient = (): RedisClient | undefined => {
+const getRedisSubscriberClient = async (): Promise<RedisClient | undefined> => {
   if (redisSubscriberClient) {
     return redisSubscriberClient
   }
   if (NEXUS_REFLECTION ?? isTest) {
     return
   }
 
-  const useSentinel = REDIS_SENTINELS && REDIS_SENTINEL_MASTER_NAME
-
-  let client: RedisClient
-
-  if (useSentinel && REDIS_SENTINELS && REDIS_SENTINEL_MASTER_NAME) {
-    const sentinels = REDIS_SENTINELS.split(",").map((sentinel: string) => {
-      const [host, port] = sentinel.trim().split(":")
-      return { host, port: parseInt(port) ?? 26379 }
-    })
-
-    const sentinelClient = createSentinel({
-      name: REDIS_SENTINEL_MASTER_NAME,
-      sentinelRootNodes: sentinels,
-      nodeClientOptions: {
-        password: REDIS_PASSWORD,
-        database: REDIS_DB,
-        socket: {
-          reconnectStrategy: redisReconnectStrategy("Redis Subscriber"),
-        },
-      },
-    })
-
-    sentinelClient.on("error", (err: any) => {
-      _logger.error(`Redis Sentinel subscriber error`, err)
-    })
-    sentinelClient.on("ready", () => {
-      _logger.info(
-        `Redis Sentinel subscriber connected to master: ${REDIS_SENTINEL_MASTER_NAME}`,
-      )
-    })
-
-    sentinelClient.connect().catch((err: any) => {
-      _logger.error(`Redis Sentinel subscriber connection failed`, err)
-    })
+  // Wait for main client to be ready first
+  const mainClient = getRedisClient()
+  if (!mainClient?.isOpen) {
+    _logger.info(
+      "Waiting for main Redis client to be ready before creating subscriber",
+    )
+    return
+  }
 
-    client = sentinelClient as RedisClient
-  } else {
+  try {
     let url = (REDIS_URL && REDIS_URL.trim()) || "redis://127.0.0.1:6379"
     if (url && !url.startsWith("redis://") && !url.startsWith("rediss://")) {
       url = `redis://${url}`
     }
     if (url && !url.includes(":") && !url.includes("/")) {
       url = `${url}:6379`
     }
-    const regularClient = createClient({
+
+    const subscriber = createClient({
       url,
       password: REDIS_PASSWORD,
       database: REDIS_DB,
       socket: {
         reconnectStrategy: redisReconnectStrategy("Redis Subscriber"),
       },
-    })
+    }) as RedisClient
 
-    regularClient.on("error", (err: any) => {
+    subscriber.on("error", (err: any) => {
       _logger.error(`Redis subscriber error`, err)
     })
-    regularClient.on("ready", () => {
+    subscriber.on("ready", () => {
       _logger.info(`Redis subscriber connected to: ${url}`)
     })
 
-    regularClient.connect().catch((err: any) => {
-      _logger.error(`Redis subscriber connection failed`, err)
-    })
+    await subscriber.connect()
 
-    client = regularClient as RedisClient
+    redisSubscriberClient = subscriber
+    return redisSubscriberClient
+  } catch (err) {
+    _logger.error("Failed to create Redis subscriber client", err)
+    return
   }
-
-  redisSubscriberClient = client
-  return client
 }
 
 export { getRedisSubscriberClient }

backend/wsServer.ts

@@ -135,12 +135,13 @@ const createSubscriber = async () => {
     return
   }
 
-  while (!getRedisSubscriberClient()?.isOpen) {
-    logger.info("Waiting on Redis subscriber client to be created...")
+  // Wait for main Redis client to be ready
+  while (!getRedisClient()?.isOpen) {
+    logger.info("Waiting on main Redis client to be ready...")
     await new Promise((resolve) => setTimeout(resolve, 100))
   }
 
-  subscriber = getRedisSubscriberClient()
+  subscriber = await getRedisSubscriberClient()
 
   if (!subscriber) {
     logger.error("Failed to get Redis subscriber client")