✨ tweak: optimize redis client and retry logic

Author: warengonzaga

src/config/redis.ts

@@ -36,11 +36,13 @@ export const redisEventConfig = {
     keyPrefix: 'unthread:eventid:',
 };
 
-// Create Redis client for v4.x - use URL string directly with timeout
+// Create Redis client for v4.x - Railway-optimized configuration
 const client = createClient({ 
     url: redisConfig.url,
     socket: {
-        connectTimeout: 5000 // 5 second timeout
+        connectTimeout: 10000,      // 10 seconds for initial connection - Railway optimized
+        keepAlive: 30000,          // Keep connection alive (30 seconds)
+        noDelay: true,             // Disable Nagle's algorithm for better latency
     }
 });
 

src/services/redisService.ts

@@ -51,8 +51,12 @@ export class RedisService {
                 completeTransformedData: event
             });
 
-            // Use Redis LIST for FIFO queue (LPUSH + BRPOP pattern)
-            const result = await this.client.lPush(queueName, eventJson);
+            // Use Redis LIST for FIFO queue with Railway-optimized retry logic
+            const result = await this.executeWithRetry(
+                () => this.client.lPush(queueName, eventJson),
+                `lPush to ${queueName}`,
+                3 // max retries
+            );
 
             LogEngine.info(`✅ Event successfully queued: ${event.data?.eventId || 'unknown'} -> ${queueName} (${result} items in queue)`);
             return result;
@@ -62,14 +66,81 @@ export class RedisService {
         }
     }
 
+    /**
+     * Railway-optimized retry logic for Redis operations with timeout handling
+     */
+    private async executeWithRetry<T>(
+        operation: () => Promise<T>,
+        operationName: string,
+        maxRetries: number = 3,
+        baseDelay: number = 1000,
+        operationTimeout: number = 8000 // 8 seconds for individual operations
+    ): Promise<T> {
+        let lastError: Error = new Error('Unknown error');
+        
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                // Wrap operation with timeout for Railway optimization
+                const timeoutPromise = new Promise<never>((_, reject) => {
+                    setTimeout(() => {
+                        reject(new Error(`Redis operation ${operationName} timed out after ${operationTimeout}ms`));
+                    }, operationTimeout);
+                });
+                
+                return await Promise.race([operation(), timeoutPromise]);
+            } catch (error) {
+                lastError = error as Error;
+                
+                if (attempt === maxRetries) {
+                    LogEngine.error(`Redis operation ${operationName} failed after ${maxRetries} attempts: ${lastError.message}`);
+                    break;
+                }
+                
+                // Check if it's a timeout or connection error
+                const isRetryableError = (
+                    lastError.message.includes('ETIMEDOUT') ||
+                    lastError.message.includes('ECONNRESET') ||
+                    lastError.message.includes('ENOTFOUND') ||
+                    lastError.message.includes('Connection is closed') ||
+                    lastError.message.includes('timed out')
+                );
+                
+                if (!isRetryableError) {
+                    LogEngine.error(`Redis operation ${operationName} failed with non-retryable error: ${lastError.message}`);
+                    break;
+                }
+                
+                const delay = baseDelay * Math.pow(2, attempt - 1); // Exponential backoff
+                LogEngine.warn(`Redis operation ${operationName} failed (attempt ${attempt}/${maxRetries}), retrying in ${delay}ms: ${lastError.message}`);
+                
+                await new Promise(resolve => setTimeout(resolve, delay));
+                
+                // Try to reconnect if connection is closed
+                if (!this.isConnected()) {
+                    try {
+                        await this.connect();
+                    } catch (reconnectError) {
+                        LogEngine.warn(`Failed to reconnect during retry: ${reconnectError}`);
+                    }
+                }
+            }
+        }
+        
+        throw lastError;
+    }
+
     /**
      * Check if webhook event already exists (duplicate detection)
      * @param eventId - Unique event identifier
      * @returns Promise<boolean> - true if event exists
      */
     async eventExists(eventId: string): Promise<boolean> {
         const key = `${redisEventConfig.keyPrefix}${eventId}`;
-        const exists = await this.client.exists(key);
+        const exists = await this.executeWithRetry(
+            () => this.client.exists(key),
+            `exists check for ${eventId}`,
+            2 // fewer retries for existence checks
+        );
         return exists === 1;
     }
 
@@ -81,7 +152,11 @@ export class RedisService {
     async markEventProcessed(eventId: string, ttlSeconds?: number): Promise<void> {
         const key = `${redisEventConfig.keyPrefix}${eventId}`;
         const ttl = ttlSeconds || redisEventConfig.eventTtl; // 3 days default
-        await this.client.setEx(key, ttl, 'processed');
+        await this.executeWithRetry(
+            () => this.client.setEx(key, ttl, 'processed'),
+            `setEx for ${eventId}`,
+            2 // fewer retries for marking processed
+        );
     }
 
     async close(): Promise<void> {