Caching Strategies for Web Applications

# Cache for 1 hour in browser and shared caches (CDN)
Cache-Control: public, max-age=3600

# Cache for 1 day, but revalidate after 1 hour
Cache-Control: public, max-age=86400, stale-while-revalidate=3600

# Private cache only (not CDN), requires revalidation
Cache-Control: private, no-cache

# Never cache (sensitive data)
Cache-Control: no-store

# Immutable - never revalidate (for versioned assets)
Cache-Control: public, max-age=31536000, immutable

import Redis from 'ioredis';

const publisher = new Redis();
const subscriber = new Redis();

// Publisher: When data changes
async function updateProduct(productId, data) {
  // 1. Update database
  await db.products.update(productId, data);
  
  // 2. Publish invalidation event
  await publisher.publish('cache:invalidate', JSON.stringify({
    type: 'product',
    id: productId,
    keys: [
      `product:${productId}`,
      `product:${productId}:details`,
      'products:list',
      `category:${data.categoryId}:products`
    ]
  }));
}

// Subscriber: Listen for invalidation events
subscriber.subscribe('cache:invalidate');

subscriber.on('message', async (channel, message) => {
  const { type, id, keys } = JSON.parse(message);
  
  console.log(`Invalidating cache for ${type}:${id}`);
  
  // Delete all related cache keys
  if (keys.length > 0) {
    await redis.del(...keys);
  }
  
  // Optionally warm the cache immediately
  if (type === 'product') {
    await warmProductCache(id);
  }
});

// Cache warming function
async function warmProductCache(productId) {
  const product = await db.products.findById(productId);
  await redis.setex(`product:${productId}`, 3600, JSON.stringify(product));
}

class TaggedCache {
  constructor(redis) {
    this.redis = redis;
  }
  
  // Store value with tags
  async set(key, value, ttl, tags = []) {
    const pipeline = this.redis.pipeline();
    
    // Store the actual value
    pipeline.setex(key, ttl, JSON.stringify(value));
    
    // Associate key with each tag
    for (const tag of tags) {
      pipeline.sadd(`tag:${tag}`, key);
      pipeline.expire(`tag:${tag}`, ttl + 60); // Tags expire slightly later
    }
    
    await pipeline.exec();
  }
  
  // Invalidate all keys with a specific tag
  async invalidateTag(tag) {
    const keys = await this.redis.smembers(`tag:${tag}`);
    
    if (keys.length > 0) {
      await this.redis.del(...keys);
      await this.redis.del(`tag:${tag}`);
    }
    
    return keys.length;
  }
}

// Usage
const cache = new TaggedCache(redis);

// Store product with multiple tags
await cache.set(
  `product:${product.id}`,
  product,
  3600,
  ['products', `category:${product.categoryId}`, `brand:${product.brandId}`]
);

// When a category is updated, invalidate all its products
await cache.invalidateTag(`category:${categoryId}`);

// When inventory changes, invalidate all products
await cache.invalidateTag('products');

export default {
  async fetch(request, env, ctx) {
    const url = new URL(request.url);
    
    // Check edge cache first
    const cacheKey = new Request(url.toString(), request);
    const cache = caches.default;
    
    let response = await cache.match(cacheKey);
    
    if (!response) {
      // Cache miss - fetch from origin
      response = await fetch(request);
      
      // Clone response for caching
      response = new Response(response.body, response);
      
      // Set caching headers based on content type
      if (url.pathname.startsWith('/api/')) {
        response.headers.set('Cache-Control', 's-maxage=60, stale-while-revalidate=300');
      } else if (url.pathname.match(/\.(js|css|woff2)$/)) {
        response.headers.set('Cache-Control', 'public, max-age=31536000, immutable');
      }
      
      // Store in edge cache (non-blocking)
      ctx.waitUntil(cache.put(cacheKey, response.clone()));
    }
    
    return response;
  }
};

# Check cache statistics
redis-cli INFO stats

# Key metrics to monitor:
# - keyspace_hits: Number of successful key lookups
# - keyspace_misses: Number of failed key lookups
# - evicted_keys: Keys removed due to maxmemory policy

# Calculate hit rate
redis-cli INFO stats | grep keyspace
# Hit Rate = hits / (hits + misses) * 100

# Monitor memory usage
redis-cli INFO memory
# used_memory_human: Current memory usage
# maxmemory_human: Memory limit

# Check slowlog for slow operations
redis-cli SLOWLOG GET 10

// Single-flight pattern: Only one request fetches, others wait
const inFlight = new Map();

async function getWithSingleFlight(key, fetchFn, ttl = 3600) {
  // Check cache first
  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached);
  
  // Check if another request is already fetching
  if (inFlight.has(key)) {
    return inFlight.get(key);
  }
  
  // Create promise for this fetch
  const fetchPromise = (async () => {
    try {
      const data = await fetchFn();
      await redis.setex(key, ttl, JSON.stringify(data));
      return data;
    } finally {
      inFlight.delete(key);
    }
  })();
  
  inFlight.set(key, fetchPromise);
  return fetchPromise;
}

// With Redis locking for distributed systems
async function getWithLock(key, fetchFn, ttl = 3600) {
  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached);
  
  const lockKey = `lock:${key}`;
  const lockTTL = 10; // 10 second lock
  
  // Try to acquire lock
  const acquired = await redis.set(lockKey, '1', 'EX', lockTTL, 'NX');
  
  if (acquired) {
    try {
      const data = await fetchFn();
      await redis.setex(key, ttl, JSON.stringify(data));
      return data;
    } finally {
      await redis.del(lockKey);
    }
  } else {
    // Wait and retry
    await new Promise(r => setTimeout(r, 100));
    return getWithLock(key, fetchFn, ttl);
  }
}