Enhance Redis configuration for better cluster support; implement stale-while-revalidate caching in chat controller; improve rate limiting middleware with Redis fallback; add exponential backoff for 429 errors in API client; implement throttling and debouncing in chat context for improved performance.

Author: ShubhamPatra

server/config/redis.js

@@ -25,8 +25,7 @@ const buildRedisConfig = () => {
     port: parseInt(process.env.REDIS_PORT, 10) || 6379,
     maxRetriesPerRequest: null, // Required for BullMQ compatibility
     enableReadyCheck: true,
-    enableOfflineQueue: false, // Prevent queuing commands when disconnected (important for cluster)
-    lazyConnect: true, // Don't connect immediately
+    enableOfflineQueue: true, // Queue commands while connecting
     retryStrategy: (times) => {
       if (times > 3) {
         if (isDev) {
@@ -62,6 +61,7 @@ const buildRedisConfig = () => {
   if (process.env.REDIS_TLS === 'true' || process.env.ELASTICACHE_TLS === 'true') {
     config.tls = {
       rejectUnauthorized: process.env.REDIS_TLS_REJECT_UNAUTHORIZED !== 'false',
+      servername: process.env.REDIS_HOST || 'localhost', // Required for TLS handshake with ElastiCache
     };
     console.log('Redis: TLS enabled for ElastiCache connection');
   }
@@ -144,13 +144,6 @@ if (REDIS_ENABLED) {
   redis.on('reconnecting', (delay) => {
     console.log(`Redis: Reconnecting in ${delay}ms...`);
   });
-
-  // Attempt initial connection (non-blocking)
-  redis.connect().catch(() => {
-    if (isDev) {
-      console.warn('Redis: Not available in development. Queued features disabled.');
-    }
-  });
 } else {
   console.log('Redis: Disabled via REDIS_ENABLED=false');
 }

server/controllers/chatController.js

@@ -5,9 +5,45 @@ import redis from '../config/redis.js';
 import { notificationQueue } from '../config/queue.js';
 import { emitToGroup } from '../utils/socketEmitter.js';
 
-// Cache TTL constants
-const CACHE_TTL_MESSAGES = 60; // 60 seconds
-const CACHE_TTL_UNREAD = 30; // 30 seconds
+// Cache TTL constants (increased for better performance under load)
+const CACHE_TTL_MESSAGES = 120; // 120 seconds (2 minutes)
+const CACHE_TTL_UNREAD = 60; // 60 seconds (1 minute)
+
+// Stale-while-revalidate threshold (serve stale data while refreshing in background)
+const STALE_THRESHOLD_MESSAGES = 60; // Consider stale after 60 seconds
+const STALE_THRESHOLD_UNREAD = 30; // Consider stale after 30 seconds
+
+/**
+ * Non-blocking cache write helper - fire and forget
+ */
+const cacheSetAsync = (key, ttl, value) => {
+  redis.setex(key, ttl, typeof value === 'string' ? value : JSON.stringify(value))
+    .catch(err => console.error('Cache write error:', err));
+};
+
+/**
+ * Get cache with timestamp for stale-while-revalidate
+ * Returns { data, isStale } or null if not cached
+ */
+const getCacheWithStaleness = async (key, staleThreshold) => {
+  try {
+    const ttl = await redis.ttl(key);
+    if (ttl <= 0) return null;
+    
+    const cached = await redis.get(key);
+    if (cached === null) return null;
+    
+    // Calculate age based on remaining TTL
+    // If TTL is less than (maxTTL - staleThreshold), data is stale
+    const maxTTL = staleThreshold * 2; // Approximate max TTL
+    const isStale = ttl < (maxTTL - staleThreshold);
+    
+    return { data: cached, isStale };
+  } catch (err) {
+    console.error('Cache read error:', err);
+    return null;
+  }
+};
 
 // Rate limiting tracking (in-memory, backed by Redis for persistence)
 const MESSAGE_RATE_LIMIT = 100; // messages per minute per user per group
@@ -77,11 +113,49 @@ export const getMessages = async (req, res) => {
     // Parse and validate limit
     const parsedLimit = Math.min(Math.max(parseInt(limit) || 50, 1), 100);
 
-    // Try cache for first page (no 'before' cursor)
+    // Try cache for first page (no 'before' cursor) with stale-while-revalidate
     if (!before) {
-      const cached = await redis.get(`chat:${groupId}:latest`);
-      if (cached) {
-        return res.json(JSON.parse(cached));
+      const cacheKey = `chat:${groupId}:latest`;
+      const cacheResult = await getCacheWithStaleness(cacheKey, STALE_THRESHOLD_MESSAGES);
+      
+      if (cacheResult) {
+        const { data, isStale } = cacheResult;
+        const parsedData = JSON.parse(data);
+        
+        // If stale, trigger background refresh (non-blocking)
+        if (isStale) {
+          setImmediate(async () => {
+            try {
+              const freshMessages = await Message.find({ groupId, deletedAt: null })
+                .populate('senderId', 'name email')
+                .populate('metadata.expenseId', 'description amount currency')
+                .populate('metadata.settlementId', 'amount currency')
+                .sort({ _id: -1 })
+                .limit(51)
+                .lean();
+              
+              const hasMore = freshMessages.length > 50;
+              if (hasMore) freshMessages.pop();
+              
+              const safeMessages = freshMessages.map(msg => 
+                msg.deletedAt ? { ...msg, content: '[Message deleted]', metadata: {} } : msg
+              );
+              
+              const freshResult = {
+                messages: safeMessages.reverse(),
+                hasMore,
+                oldestMessageId: safeMessages.length > 0 ? safeMessages[0]._id : null,
+              };
+              
+              cacheSetAsync(cacheKey, CACHE_TTL_MESSAGES, freshResult);
+            } catch (err) {
+              console.error('Background message refresh error:', err);
+            }
+          });
+        }
+        
+        // Return cached data immediately
+        return res.json(parsedData);
       }
     }
 
@@ -128,9 +202,9 @@ export const getMessages = async (req, res) => {
       oldestMessageId: safeMessages.length > 0 ? safeMessages[0]._id : null,
     };
 
-    // Cache first page
+    // Cache first page (non-blocking)
     if (!before) {
-      await redis.setex(`chat:${groupId}:latest`, CACHE_TTL_MESSAGES, JSON.stringify(result));
+      cacheSetAsync(`chat:${groupId}:latest`, CACHE_TTL_MESSAGES, result);
     }
 
     res.json(result);
@@ -447,23 +521,46 @@ export const getUnreadCount = async (req, res) => {
       return res.status(403).json({ message: 'Not authorized' });
     }
 
-    // Try cache first
+    // Try cache first with stale-while-revalidate
     const cacheKey = `chat:${groupId}:unread:${req.user._id}`;
-    const cached = await redis.get(cacheKey);
-    if (cached !== null) {
-      return res.json({ count: parseInt(cached) });
+    const cacheResult = await getCacheWithStaleness(cacheKey, STALE_THRESHOLD_UNREAD);
+    
+    if (cacheResult) {
+      const { data, isStale } = cacheResult;
+      const cachedCount = parseInt(data);
+      
+      // If stale, trigger background refresh (non-blocking)
+      if (isStale) {
+        const userId = req.user._id;
+        setImmediate(async () => {
+          try {
+            const freshCount = await Message.countDocuments({
+              groupId,
+              deletedAt: null,
+              senderId: { $ne: userId },
+              readBy: { $ne: userId },
+            });
+            cacheSetAsync(cacheKey, CACHE_TTL_UNREAD, freshCount.toString());
+          } catch (err) {
+            console.error('Background unread count refresh error:', err);
+          }
+        });
+      }
+      
+      // Return cached data immediately
+      return res.json({ count: cachedCount });
     }
 
-    // Count unread messages
+    // Count unread messages (cache miss)
     const count = await Message.countDocuments({
       groupId,
       deletedAt: null,
       senderId: { $ne: req.user._id },
       readBy: { $ne: req.user._id },
     });
 
-    // Cache the result
-    await redis.setex(cacheKey, CACHE_TTL_UNREAD, count.toString());
+    // Cache the result (non-blocking)
+    cacheSetAsync(cacheKey, CACHE_TTL_UNREAD, count.toString());
 
     res.json({ count });
   } catch (error) {
@@ -529,15 +626,25 @@ export const getBatchUnreadCounts = async (req, res) => {
 
       const results = await Message.aggregate(pipeline);
 
-      // Process results and cache them
+      // Process results and warm individual caches (non-blocking)
       for (const groupId of uncachedGroupIds) {
         const result = results.find(r => r._id.toString() === groupId);
         const count = result ? result.count : 0;
         counts[groupId] = count;
 
-        // Cache the result
+        // Warm individual cache (non-blocking) - enables subsequent individual lookups to hit cache
+        const cacheKey = `chat:${groupId}:unread:${userId}`;
+        cacheSetAsync(cacheKey, CACHE_TTL_UNREAD, count.toString());
+      }
+    }
+    
+    // Also warm cache for groups that had cache hits (extend TTL for frequently accessed)
+    // This is non-blocking and helps keep hot data fresh
+    for (const groupId of validGroupIds) {
+      if (!uncachedGroupIds.includes(groupId)) {
         const cacheKey = `chat:${groupId}:unread:${userId}`;
-        await redis.setex(cacheKey, CACHE_TTL_UNREAD, count.toString());
+        // Touch the cache to extend TTL for frequently accessed groups
+        redis.expire(cacheKey, CACHE_TTL_UNREAD).catch(() => {});
       }
     }
 

server/middleware/ddosProtection.js

@@ -21,7 +21,11 @@ export const ddosProtection = async (req, res, next) => {
   }
 
   if (requests > 50) { // 50 requests per second
-    return res.status(429).json({ message: 'Too many requests' });
+    res.setHeader('Retry-After', '1');
+    return res.status(429).json({ 
+      message: 'Too many requests. Please wait 1 second.',
+      retryAfter: 1,
+    });
   }
 
   next();