Module 7: Độ Tin Cậy - Timeout/Retry/Idempotency/Rate Limit

Attempt 1: wait 1s
Attempt 2: wait 2s
Attempt 3: wait 4s
Attempt 4: wait 8s
Max attempts: 3-5

interface RetryPolicy {
  maxAttempts: number;        // 3-5 lần
  initialDelay: number;       // 1000ms
  maxDelay: number;           // 30000ms
  backoffMultiplier: number;  // 2
  retryableStatusCodes: number[];  // [502, 503, 504]
  retryableErrors: string[];  // ['ECONNRESET', 'ETIMEDOUT']
}

const policy: RetryPolicy = {
  maxAttempts: 3,
  initialDelay: 1000,
  maxDelay: 10000,
  backoffMultiplier: 2,
  retryableStatusCodes: [502, 503, 504, 429],
  retryableErrors: ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED']
};

// Ví dụ implementation
async function fetchWithRetry(url: string, policy: RetryPolicy) {
  let lastError;
  
  for (let attempt = 1; attempt <= policy.maxAttempts; attempt++) {
    try {
      const response = await fetch(url, { 
        signal: AbortSignal.timeout(30000) // 30s timeout
      });
      
      if (response.ok || !policy.retryableStatusCodes.includes(response.status)) {
        return response;
      }
      
      lastError = new Error(`HTTP ${response.status}`);
      
    } catch (error) {
      lastError = error;
      
      // Không retry nếu không phải lỗi tạm thời
      if (!isRetryableError(error, policy)) {
        throw error;
      }
    }
    
    // Tính delay với jitter
    if (attempt < policy.maxAttempts) {
      const baseDelay = Math.min(
        policy.initialDelay * Math.pow(policy.backoffMultiplier, attempt - 1),
        policy.maxDelay
      );
      const jitter = baseDelay * 0.1 * Math.random();
      await sleep(baseDelay + jitter);
    }
  }
  
  throw lastError;
}

POST /orders
Idempotency-Key: unique-key-123
Content-Type: application/json

{
  "items": [...],
  "amount": 100000
}

// 1. Database schema
CREATE TABLE idempotency_keys (
  key VARCHAR(255) PRIMARY KEY,
  resource_type VARCHAR(50),
  resource_id VARCHAR(255),
  response_body JSON,
  status_code INT,
  created_at TIMESTAMP,
  expires_at TIMESTAMP
);

CREATE INDEX idx_expires ON idempotency_keys(expires_at);

// 2. Middleware
async function idempotencyMiddleware(req, res, next) {
  const idempotencyKey = req.headers['idempotency-key'];
  
  if (!idempotencyKey) {
    return res.status(400).json({
      error: {
        code: 'MISSING_IDEMPOTENCY_KEY',
        message: 'Idempotency-Key header is required for this endpoint'
      }
    });
  }
  
  // Check cache
  const cached = await redis.get(`idem:${idempotencyKey}`);
  if (cached) {
    const { statusCode, body } = JSON.parse(cached);
    return res.status(statusCode).json(body);
  }
  
  // Check database
  const record = await db.idempotencyKeys.findOne({ key: idempotencyKey });
  if (record) {
    return res.status(record.statusCode).json(record.responseBody);
  }
  
  // Proceed with request
  req.idempotencyKey = idempotencyKey;
  next();
}

// 3. Save result
async function saveIdempotencyResult(key, resourceId, statusCode, body) {
  const expiresAt = new Date(Date.now() + 24 * 60 * 60 * 1000); // 24h
  
  await db.idempotencyKeys.create({
    key,
    resourceType: 'deposit',
    resourceId,
    responseBody: body,
    statusCode,
    expiresAt
  });
  
  // Cache for 5 minutes
  await redis.setex(`idem:${key}`, 300, JSON.stringify({ statusCode, body }));
}

async function checkRateLimit(key: string, limit: number, windowSeconds: number) {
  const now = Date.now();
  const windowKey = `ratelimit:${key}:${Math.floor(now / (windowSeconds * 1000))}`;
  
  const current = await redis.incr(windowKey);
  
  if (current === 1) {
    await redis.expire(windowKey, windowSeconds);
  }
  
  if (current > limit) {
    throw new Error('RATE_LIMIT_EXCEEDED');
  }
  
  return {
    limit,
    remaining: Math.max(0, limit - current),
    reset: Math.ceil(now / (windowSeconds * 1000)) * windowSeconds * 1000
  };
}

// Middleware
app.use(async (req, res, next) => {
  const key = req.user?.id || req.ip;
  
  try {
    const rateLimit = await checkRateLimit(key, 100, 60);
    
    res.setHeader('X-RateLimit-Limit', rateLimit.limit);
    res.setHeader('X-RateLimit-Remaining', rateLimit.remaining);
    res.setHeader('X-RateLimit-Reset', rateLimit.reset);
    
    next();
  } catch (error) {
    res.status(429).json({
      error: {
        code: 'RATE_LIMIT_EXCEEDED',
        message: 'Too many requests. Please try again later.',
        retryAfter: 60
      }
    });
  }
});