Advanced Redis Usage

Advanced Real-World Examples

Distributed Locks with Redis

Distributed locks are essential for coordinating actions across multiple instances of an application.

// Distributed lock implementation
class RedisLock {
  constructor(client, options = {}) {
    this.client = client;
    this.retryDelay = options.retryDelay || 200;
    this.retryCount = options.retryCount || 10;
    this.lockTimeout = options.lockTimeout || 10000;  // 10 seconds
  }
  
  // Acquire a lock
  async acquire(lockName, lockValue = Math.random().toString(36).substring(2)) {
    let retries = 0;
    
    while (retries < this.retryCount) {
      // Try to set the lock with NX option (only if not exists)
      const result = await this.client.set(`lock:${lockName}`, lockValue, {
        NX: true,
        PX: this.lockTimeout
      });
      
      if (result === 'OK') {
        // Lock acquired successfully
        return {
          acquired: true,
          value: lockValue
        };
      }
      
      // Wait before retrying
      await new Promise(resolve => setTimeout(resolve, this.retryDelay));
      retries++;
    }
    
    return {
      acquired: false,
      value: null
    };
  }
  
  // Release a lock (using Lua script for atomicity)
  async release(lockName, lockValue) {
    // This script ensures we only delete the lock if it's still ours
    const script = `
      if redis.call("GET", KEYS[1]) == ARGV[1] then
        return redis.call("DEL", KEYS[1])
      else
        return 0
      end
    `;
    
    return this.client.eval(
      script,
      {
        keys: [`lock:${lockName}`],
        arguments: [lockValue]
      }
    );
  }
  
  // Extend a lock's expiry time
  async extend(lockName, lockValue, extensionTime = 10000) {
    const script = `
      if redis.call("GET", KEYS[1]) == ARGV[1] then
        return redis.call("PEXPIRE", KEYS[1], ARGV[2])
      else
        return 0
      end
    `;
    
    return this.client.eval(
      script,
      {
        keys: [`lock:${lockName}`],
        arguments: [lockValue, extensionTime.toString()]
      }
    );
  }
}

// Usage example
async function processWithLock() {
  const lock = new RedisLock(client, {
    retryDelay: 100,
    retryCount: 5,
    lockTimeout: 30000  // 30 seconds
  });
  
  console.log('Trying to acquire lock...');
  
  const { acquired, value } = await lock.acquire('resource:123');
  
  if (!acquired) {
    console.error('Failed to acquire lock after retries');
    return false;
  }
  
  console.log('Lock acquired, processing...');
  
  try {
    // Simulate some work
    await new Promise(resolve => setTimeout(resolve, 5000));
    
    // If processing takes longer, extend the lock
    await lock.extend('resource:123', value, 30000);
    console.log('Lock extended');
    
    // More processing...
    await new Promise(resolve => setTimeout(resolve, 10000));
    
    console.log('Processing complete');
    return true;
  } catch (error) {
    console.error('Error during processing:', error);
    return false;
  } finally {
    // Always release the lock when done
    await lock.release('resource:123', value);
    console.log('Lock released');
  }
}
            

Sliding Window Rate Limiter with Tokens

A more sophisticated rate limiter that provides a sliding window with token budgeting.

// Advanced sliding window rate limiter with Redis
class SlidingWindowRateLimiter {
  constructor(client, options = {}) {
    this.client = client;
    this.windowSize = options.windowSize || 60;  // Window size in seconds
    this.maxTokens = options.maxTokens || 10;    // Maximum tokens per window
    this.tokenReserve = options.tokenReserve || 0.2;  // Portion of tokens reserved for burst
    
    // Initialize script hash
    this.scriptHash = null;
    this.initialized = false;
    
    // Lua script for atomic rate limiting
    this.script = `
      local key = KEYS[1]
      local now = tonumber(ARGV[1])
      local windowSize = tonumber(ARGV[2])
      local maxTokens = tonumber(ARGV[3])
      local tokenReserve = tonumber(ARGV[4])
      local requestTokens = tonumber(ARGV[5])
      
      -- Calculate window bounds
      local windowStart = now - windowSize
      
      -- Remove events outside the current window
      redis.call('ZREMRANGEBYSCORE', key, 0, windowStart)
      
      -- Count events in the current window
      local windowEvents = redis.call('ZCARD', key)
      
      -- Calculate available tokens with an exponential decay function
      -- More tokens available for the beginning of the window
      local availableTokens = maxTokens
      
      if windowEvents > 0 then
        local eventTimes = redis.call('ZRANGE', key, 0, -1, 'WITHSCORES')
        local usedTokens = 0
        local reserveTokens = math.floor(maxTokens * tokenReserve)
        
        for i = 1, #eventTimes, 2 do
          local timestamp = tonumber(eventTimes[i+1])
          local age = (now - timestamp) / windowSize
          local weight = math.min(1, age * 2)  -- Linear decay up to 2x speed
          
          usedTokens = usedTokens + 1 - weight
        end
        
        availableTokens = math.max(0, math.floor(maxTokens - usedTokens))
        
        -- Ensure we always have some reserve tokens available
        availableTokens = math.max(reserveTokens, availableTokens)
      end
      
      -- Check if we have enough tokens
      if availableTokens >= requestTokens then
        -- Add the current request to the window
        redis.call('ZADD', key, now, now .. '-' .. math.random())
        -- Set expiry on the key to auto-cleanup
        redis.call('EXPIRE', key, windowSize * 2)
        
        -- Return remaining tokens and true (allowed)
        return {availableTokens - requestTokens, 1}
      else
        -- Return available tokens and false (denied)
        return {availableTokens, 0}
      end
    `;
  }
  
  // Initialize the rate limiter
  async init() {
    if (!this.initialized) {
      this.scriptHash = await this.client.scriptLoad(this.script);
      this.initialized = true;
    }
    return this;
  }
  
  // Check if a request is allowed
  async checkLimit(userId, tokens = 1) {
    if (!this.initialized) {
      await this.init();
    }
    
    const key = `rate:${userId}:sliding`;
    const now = Math.floor(Date.now() / 1000);
    
    const result = await this.client.evalSha(
      this.scriptHash,
      {
        keys: [key],
        arguments: [
          now.toString(),
          this.windowSize.toString(),
          this.maxTokens.toString(),
          this.tokenReserve.toString(),
          tokens.toString()
        ]
      }
    );
    
    return {
      allowed: result[1] === 1,
      remainingTokens: result[0],
      resetAfter: this.windowSize - (now % this.windowSize)
    };
  }
}

// Express middleware using the sliding window rate limiter
async function createAdvancedRateLimiterMiddleware() {
  // Different rate limits for different endpoints/methods
  const rateLimiters = {
    // Standard API endpoints (10 requests per minute)
    standard: await new SlidingWindowRateLimiter(client, {
      windowSize: 60,
      maxTokens: 10,
      tokenReserve: 0.2
    }).init(),
    
    // Search endpoints (5 requests per minute)
    search: await new SlidingWindowRateLimiter(client, {
      windowSize: 60,
      maxTokens: 5,
      tokenReserve: 0.2
    }).init(),
    
    // Admin endpoints (30 requests per minute)
    admin: await new SlidingWindowRateLimiter(client, {
      windowSize: 60,
      maxTokens: 30,
      tokenReserve: 0.1
    }).init()
  };
  
  return async (req, res, next) => {
    // Determine which rate limiter to use based on the route
    let limiterKey = 'standard';
    
    if (req.path.includes('/api/search')) {
      limiterKey = 'search';
    } else if (req.path.includes('/api/admin')) {
      limiterKey = 'admin';
    }
    
    const rateLimiter = rateLimiters[limiterKey];
    const identifier = req.ip || 'anonymous';
    
    // Check the rate limit
    const result = await rateLimiter.checkLimit(identifier);
    
    // Set headers
    res.setHeader('X-RateLimit-Limit', rateLimiter.maxTokens);
    res.setHeader('X-RateLimit-Remaining', result.remainingTokens);
    res.setHeader('X-RateLimit-Reset', result.resetAfter);
    
    if (!result.allowed) {
      return res.status(429).json({
        error: 'Too many requests',
        message: `Rate limit exceeded. Try again in ${result.resetAfter} seconds.`
      });
    }
    
    next();
  };
}
            

Real-time Analytics with Redis

Redis can be used to build real-time analytics dashboards with high performance.

// Real-time analytics tracking
class AnalyticsTracker {
  constructor(client) {
    this.client = client;
    this.dayFormat = 'YYYY-MM-DD';
    this.hourFormat = 'YYYY-MM-DD:HH';
    this.minuteFormat = 'YYYY-MM-DD:HH:mm';
  }
  
  // Format date according to specified format
  formatDate(date, format) {
    const d = date || new Date();
    const year = d.getFullYear();
    const month = String(d.getMonth() + 1).padStart(2, '0');
    const day = String(d.getDate()).padStart(2, '0');
    const hour = String(d.getHours()).padStart(2, '0');
    const minute = String(d.getMinutes()).padStart(2, '0');
    
    if (format === this.dayFormat) {
      return `${year}-${month}-${day}`;
    } else if (format === this.hourFormat) {
      return `${year}-${month}-${day}:${hour}`;
    } else if (format === this.minuteFormat) {
      return `${year}-${month}-${day}:${hour}:${minute}`;
    }
    
    return `${year}-${month}-${day}:${hour}:${minute}`;
  }
  
  // Track a page view
  async trackPageView(page, userId = 'anonymous') {
    const now = new Date();
    const day = this.formatDate(now, this.dayFormat);
    const hour = this.formatDate(now, this.hourFormat);
    const minute = this.formatDate(now, this.minuteFormat);
    
    const pipeline = this.client.multi();
    
    // Increment counters at different granularities
    pipeline.incr(`stats:pageviews:total`);
    pipeline.incr(`stats:pageviews:${day}`);
    pipeline.incr(`stats:pageviews:${hour}`);
    pipeline.incr(`stats:pageviews:${minute}`);
    
    // Increment page-specific counters
    pipeline.incr(`stats:pageviews:${page}:total`);
    pipeline.incr(`stats:pageviews:${page}:${day}`);
    
    // Add to sorted set for most popular pages
    pipeline.zIncrBy('stats:popular:pages', 1, page);
    
    // Track unique visitors with HyperLogLog
    pipeline.pfAdd(`stats:unique:${day}`, userId);
    pipeline.pfAdd(`stats:unique:${hour}`, userId);
    
    // Add to time series if using RedisTimeSeries
    // pipeline.ts.add(`stats:ts:pageviews`, now.getTime(), 1);
    
    // Execute all commands
    await pipeline.exec();
  }
  
  // Track an event (button click, form submission, etc.)
  async trackEvent(eventName, properties = {}, userId = 'anonymous') {
    const now = new Date();
    const day = this.formatDate(now, this.dayFormat);
    
    const pipeline = this.client.multi();
    
    // Increment event counters
    pipeline.incr(`stats:events:${eventName}:total`);
    pipeline.incr(`stats:events:${eventName}:${day}`);
    
    // Add to sorted set for most common events
    pipeline.zIncrBy('stats:popular:events', 1, eventName);
    
    // Store event details in a stream (good for later analysis)
    const eventData = {
      userId,
      eventName,
      timestamp: now.toISOString(),
      ...properties
    };
    
    pipeline.xAdd(
      'stats:events:stream',
      '*',  // Auto-generate ID
      {
        ...eventData,
        // Convert object properties to string
        properties: JSON.stringify(properties)
      }
    );
    
    // Execute all commands
    await pipeline.exec();
  }
  
  // Get real-time analytics
  async getRealTimeStats() {
    const now = new Date();
    const day = this.formatDate(now, this.dayFormat);
    const hour = this.formatDate(now, this.hourFormat);
    const prevHour = this.formatDate(new Date(now.getTime() - 3600000), this.hourFormat);
    
    // Get various stats in parallel
    const [
      totalPageviews,
      todayPageviews,
      currentHourPageviews,
      prevHourPageviews,
      uniqueVisitorsToday,
      uniqueVisitorsHour,
      topPages,
      topEvents
    ] = await Promise.all([
      this.client.get('stats:pageviews:total'),
      this.client.get(`stats:pageviews:${day}`),
      this.client.get(`stats:pageviews:${hour}`),
      this.client.get(`stats:pageviews:${prevHour}`),
      this.client.pfCount(`stats:unique:${day}`),
      this.client.pfCount(`stats:unique:${hour}`),
      this.client.zRevRangeWithScores('stats:popular:pages', 0, 9),
      this.client.zRevRangeWithScores('stats:popular:events', 0, 9)
    ]);
    
    // Calculate hour-over-hour change
    const hourChange = prevHourPageviews 
      ? ((currentHourPageviews - prevHourPageviews) / prevHourPageviews) * 100 
      : 0;
    
    return {
      pageviews: {
        total: parseInt(totalPageviews || 0),
        today: parseInt(todayPageviews || 0),
        currentHour: parseInt(currentHourPageviews || 0),
        hourChange: parseFloat(hourChange.toFixed(2))
      },
      uniqueVisitors: {
        today: uniqueVisitorsToday,
        currentHour: uniqueVisitorsHour
      },
      topPages: topPages.map(({ value, score }) => ({
        page: value,
        views: parseInt(score)
      })),
      topEvents: topEvents.map(({ value, score }) => ({
        event: value,
        count: parseInt(score)
      }))
    };
  }
  
  // Get historical analytics data
  async getHistoricalData(metric, days = 7) {
    const result = [];
    const now = new Date();
    
    for (let i = 0; i < days; i++) {
      const date = new Date(now);
      date.setDate(now.getDate() - i);
      const day = this.formatDate(date, this.dayFormat);
      
      const value = await this.client.get(`stats:${metric}:${day}`);
      
      result.push({
        date: day,
        value: parseInt(value || 0)
      });
    }
    
    // Sort by date ascending
    return result.sort((a, b) => a.date