Performance Optimization

Cache-Control Headers

// Cache for 1 hour (public resources)
Cache-Control: public, max-age=3600

// Cache for 5 minutes (private user data)
Cache-Control: private, max-age=300

// No caching (sensitive data)
Cache-Control: no-cache, no-store, must-revalidate

// Cache but validate with server (ETags)
Cache-Control: no-cache
ETag: "33a64df551425fcc55e4d42a148795d9f25f89d4"

ETag (Entity Tag) Validation

// Server response with ETag
HTTP/1.1 200 OK
ETag: "686897696a7c876b7e"
Content-Type: application/json

{ "id": 123, "name": "John Doe" }

// Client subsequent request
GET /users/123
If-None-Match: "686897696a7c876b7e"

// Server response if not modified
HTTP/1.1 304 Not Modified
ETag: "686897696a7c876b7e"

// No response body sent (saves bandwidth)

// Implementation example
function getUserWithETag(userId) {
  const user = db.users.findById(userId);
  const etag = generateETag(user);
  
  if (req.headers['if-none-match'] === etag) {
    return res.status(304).send();
  }
  
  return res
    .set('ETag', etag)
    .set('Cache-Control', 'no-cache')
    .json(user);
}

function generateETag(data) {
  return crypto
    .createHash('md5')
    .update(JSON.stringify(data))
    .digest('hex');
}

Last-Modified Header

// Server response
HTTP/1.1 200 OK
Last-Modified: Wed, 15 Jan 2024 10:30:00 GMT
Content-Type: application/json

{ "id": 123, "name": "John Doe" }

// Client subsequent request
GET /users/123
If-Modified-Since: Wed, 15 Jan 2024 10:30:00 GMT

// Server response if not modified
HTTP/1.1 304 Not Modified

In-Memory Cache (Redis/Memcached)

// Redis cache implementation
import Redis from 'ioredis';

const redis = new Redis({
  host: 'localhost',
  port: 6379
});

async function getUsers() {
  const cacheKey = 'users:all';
  
  // Try cache first
  const cached = await redis.get(cacheKey);
  if (cached) {
    return JSON.parse(cached);
  }
  
  // Cache miss - fetch from database
  const users = await db.users.findAll();
  
  // Store in cache for 5 minutes
  await redis.setex(
    cacheKey,
    300,  // TTL in seconds
    JSON.stringify(users)
  );
  
  return users;
}

// Cache invalidation on update
async function updateUser(userId, updates) {
  const user = await db.users.update(userId, updates);
  
  // Invalidate related cache keys
  await redis.del('users:all');
  await redis.del(`users:${userId}`);
  
  return user;
}

Query Result Caching

// Cache expensive queries
async function getProductsByCategory(category, filters) {
  const cacheKey = `products:${category}:${JSON.stringify(filters)}`;
  
  const cached = await redis.get(cacheKey);
  if (cached) {
    return JSON.parse(cached);
  }
  
  // Expensive database query
  const products = await db.products
    .where({ category })
    .filter(filters)
    .sort('-created_at')
    .limit(100);
  
  // Cache for 10 minutes
  await redis.setex(cacheKey, 600, JSON.stringify(products));
  
  return products;
}

Token Bucket Algorithm

// Rate limiter using Redis
class RateLimiter {
  constructor(redis) {
    this.redis = redis;
  }
  
  async checkLimit(userId, limit = 100, window = 900) {
    // limit: max requests, window: time in seconds (900s = 15min)
    const key = `rate_limit:${userId}`;
    const now = Date.now();
    
    // Remove old requests outside window
    await this.redis.zremrangebyscore(key, 0, now - (window * 1000));
    
    // Count requests in current window
    const requestCount = await this.redis.zcard(key);
    
    if (requestCount >= limit) {
      // Rate limit exceeded
      const oldest = await this.redis.zrange(key, 0, 0);
      const resetTime = parseInt(oldest[0]) + (window * 1000);
      
      return {
        allowed: false,
        limit,
        remaining: 0,
        resetAt: new Date(resetTime)
      };
    }
    
    // Add current request
    await this.redis.zadd(key, now, now);
    await this.redis.expire(key, window);
    
    return {
      allowed: true,
      limit,
      remaining: limit - requestCount - 1,
      resetAt: new Date(now + (window * 1000))
    };
  }
}

// Middleware usage
app.use(async (req, res, next) => {
  const userId = req.user?.id || req.ip;
  const result = await rateLimiter.checkLimit(userId);
  
  // Set rate limit headers
  res.set({
    'X-RateLimit-Limit': result.limit,
    'X-RateLimit-Remaining': result.remaining,
    'X-RateLimit-Reset': result.resetAt.toISOString()
  });
  
  if (!result.allowed) {
    return res.status(429).json({
      error: 'Too many requests',
      retry_after: Math.ceil((result.resetAt - Date.now()) / 1000)
    });
  }
  
  next();
});

Tiered Rate Limits

// Different limits based on user tier
const RATE_LIMITS = {
  free: { limit: 100, window: 900 },      // 100 req/15min
  basic: { limit: 1000, window: 900 },    // 1000 req/15min
  premium: { limit: 10000, window: 900 }, // 10000 req/15min
  enterprise: { limit: -1, window: 0 }    // Unlimited
};

async function getRateLimit(userId) {
  const user = await db.users.findById(userId);
  const tier = user.subscription_tier || 'free';
  return RATE_LIMITS[tier];
}

Client-Side Rate Limit Handling

// Respect rate limits in API client
async function fetchWithRateLimit(url, options = {}) {
  const response = await fetch(url, options);
  
  const limit = response.headers.get('X-RateLimit-Limit');
  const remaining = response.headers.get('X-RateLimit-Remaining');
  const reset = response.headers.get('X-RateLimit-Reset');
  
  console.log(`Rate limit: ${remaining}/${limit} remaining`);
  
  if (response.status === 429) {
    const retryAfter = response.headers.get('Retry-After');
    console.warn(`Rate limited. Retry after ${retryAfter} seconds`);
    
    // Wait and retry
    await new Promise(resolve => 
      setTimeout(resolve, retryAfter * 1000)
    );
    
    return fetchWithRateLimit(url, options);
  }
  
  // Warn when approaching limit
  if (remaining < limit * 0.1) {
    console.warn(`Approaching rate limit: ${remaining} remaining`);
  }
  
  return response;
}

Express.js Implementation

import compression from 'compression';
import express from 'express';
import { CodeBlock } from '@/app/components/CodeBlock';

const app = express();

// Enable GZIP compression
app.use(compression({
  level: 6,              // Compression level (0-9)
  threshold: 1024,       // Only compress responses > 1KB
  filter: (req, res) => {
    // Don't compress if client doesn't support it
    if (req.headers['x-no-compression']) {
      return false;
    }
    return compression.filter(req, res);
  }
}));

Compression Impact