RATE
LIMITER

// Key: ratelimit:{userId}:{window_minute}
// Limit: 100 req/min

function checkLimit(userId) {
  window = Math.floor(Date.now() / 60000)   // minute bucket
  key = `rl:${userId}:${window}`
  
  count = redis.incr(key)
  if (count == 1) redis.expire(key, 120)  // set TTL on first request
  
  return count <= 100
}

// Memory: O(1) — just one counter per user
// Speed: one INCR + one EXPIRE (conditional)

// Key: ratelimit:{userId} — Sorted Set, score = timestamp
function checkLimit(userId) {
  now     = Date.now()           // ms
  window  = 60000                // 60s in ms
  cutoff  = now - window

  redis.zremrangebyscore(`rl:${userId}`, 0, cutoff)  // remove old
  count = redis.zcard(`rl:${userId}`)               // count remaining

  if (count >= 100) return REJECT

  redis.zadd(`rl:${userId}`, now, now)             // log this request
  redis.expire(`rl:${userId}`, 120)              // TTL cleanup
  return ALLOW
}
// Memory: O(N) — stores EVERY request timestamp
// 100 req/min × 1M users = 100M Redis entries → expensive

function checkLimit(userId, limit, windowSec) {
  now     = Math.floor(Date.now() / 1000)
  bucket  = Math.floor(now / windowSec)
  elapsed = (now % windowSec) / windowSec

  keyCurr = `rl:${userId}:${bucket}`
  keyPrev = `rl:${userId}:${bucket - 1}`

  [prevCount, currCount] = redis.mget(keyPrev, keyCurr)
  prevCount = prevCount || 0
  currCount = currCount || 0

  rate = prevCount * (1 - elapsed) + currCount

  if (rate >= limit) return REJECT

  redis.incr(keyCurr)
  redis.expire(keyCurr, windowSec * 2)
  return ALLOW
}
// Memory: O(1) — only 2 counter keys per user at any time
// Accuracy: ~99.997% vs true sliding window (0.003% error)

-- KEYS[1] = bucket key
-- ARGV[1] = capacity, ARGV[2] = rate/sec, ARGV[3] = now_ms

local capacity = tonumber(ARGV[1])
local rate     = tonumber(ARGV[2])
local now      = tonumber(ARGV[3])

local bucket   = redis.call("HMGET", KEYS[1], "tokens", "last")
local tokens   = tonumber(bucket[1] or capacity)
local last     = tonumber(bucket[2] or now)

local elapsed  = (now - last) / 1000   -- seconds
tokens = math.min(capacity, tokens + elapsed * rate)

if tokens >= 1 then
    tokens = tokens - 1
    redis.call("HMSET", KEYS[1], "tokens", tokens, "last", now)
    redis.call("EXPIRE", KEYS[1], 3600)
    return 1   -- ALLOW
else
    redis.call("HMSET", KEYS[1], "tokens", tokens, "last", now)
    return 0   -- REJECT
end

// Without Lua — BROKEN under concurrency:
Thread A: GET tokens → 1             // sees 1 token available
Thread B: GET tokens → 1             // also sees 1 token available
Thread A: SET tokens 0                 // decrements to 0, allows request
Thread B: SET tokens 0                 // also decrements to 0, ALSO allows request
// Result: 2 requests allowed when only 1 token existed!

// With Lua script — CORRECT:
// Redis executes Lua scripts atomically
// No other Redis command can interleave between Lua lines
// Equivalent to a Redis MULTI/EXEC transaction but faster

// Execute Lua script in application code:
const script = redis.createScript(luaCode);
const result = await script.eval(
  [`bucket:${userId}`],              // KEYS[1]
  [capacity, refillRate, Date.now()]  // ARGV[1,2,3]
);

function checkRateLimit(userId) {
  try {
    return redis.checkLimit(userId)
  } catch (RedisUnavailable) {
    
    // Option A: Fail-Open (allow all)
    return ALLOW
    // Pro: service stays up, users unaffected
    // Con: during Redis outage, limits not enforced → potential abuse
    // Use for: internal services, non-critical limits
    
    // Option B: Fail-Closed (reject all)
    return REJECT
    // Pro: strict — no abuse during outage
    // Con: service degraded for ALL users when Redis is down
    // Use for: financial APIs, security-critical endpoints
    
    // Option C: Local fallback (temporary local counter)
    return localFallback.checkLimit(userId)  // in-memory, less accurate
    // Best of both worlds for most production systems
  }
}

// Response body:
{
  "error": "rate_limit_exceeded",
  "message": "100 requests per minute exceeded",
  "retry_after_seconds": 42,
  "limit": 100,
  "window": "1 minute"
}

// Good client behavior (using Retry-After):
if (response.status === 429) {
  retryAfter = response.headers.get('Retry-After')
  await sleep(retryAfter * 1000)
  return retry(request)  // not immediately — that hammers the server
}

// Include on EVERY response (not just 429):
// Allows clients to monitor their quota proactively
X-RateLimit-Limit:     100
X-RateLimit-Remaining: 73   ← still have 73 left
X-RateLimit-Reset:     1700000060