프로덕션에서 실제로 동작하는 Redis 캐싱 전략

import Redis from "ioredis";
 
const redis = new Redis({
  host: process.env.REDIS_HOST || "127.0.0.1",
  port: Number(process.env.REDIS_PORT) || 6379,
  password: process.env.REDIS_PASSWORD || undefined,
  db: Number(process.env.REDIS_DB) || 0,
  maxRetriesPerRequest: 3,
  retryStrategy(times) {
    const delay = Math.min(times * 200, 5000);
    return delay;
  },
  lazyConnect: true,
  enableReadyCheck: true,
  connectTimeout: 10000,
});
 
redis.on("error", (err) => {
  console.error("[Redis] Connection error:", err.message);
});
 
redis.on("connect", () => {
  console.log("[Redis] Connected");
});
 
export default redis;

import redis from "./redis";
 
interface CacheOptions {
  ttl?: number; // 초
  prefix?: string;
}
 
async function cacheAside<T>(key: string, fetcher: () => Promise<T>, options: CacheOptions = {}): Promise<T> {
  const { ttl = 3600, prefix = "cache" } = options;
  const cacheKey = `${prefix}:${key}`;
 
  // 1단계: 캐시에서 읽기 시도
  const cached = await redis.get(cacheKey);
 
  if (cached !== null) {
    try {
      return JSON.parse(cached) as T;
    } catch {
      // 손상된 캐시 항목, 삭제하고 계속 진행
      await redis.del(cacheKey);
    }
  }
 
  // 2단계: 캐시 미스 — 소스에서 가져오기
  const result = await fetcher();
 
  // 3단계: 캐시에 저장 (await하지 않음 — 발사 후 잊기)
  redis.set(cacheKey, JSON.stringify(result), "EX", ttl).catch((err) => {
    console.error(`[Cache] Failed to set ${cacheKey}:`, err.message);
  });
 
  return result;
}

interface User {
  id: string;
  name: string;
  email: string;
  plan: "free" | "pro" | "enterprise";
}
 
async function getUser(userId: string): Promise<User | null> {
  return cacheAside<User | null>(
    `user:${userId}`,
    async () => {
      const row = await db.query("SELECT * FROM users WHERE id = $1", [userId]);
      return row[0] ?? null;
    },
    { ttl: 1800 }, // 30분
  );
}

async function getUserSafe(userId: string): Promise<User | null> {
  return cacheAside<User | null>(
    `user:${userId}`,
    async () => {
      const row = await db.query("SELECT * FROM users WHERE id = $1", [userId]);
      return row[0] ?? null;
    },
    {
      // null 결과에 더 짧은 TTL로 메모리 사용량 제한
      // 하지만 반복되는 미스를 흡수할 만큼 충분히 긴
      ttl: row ? 1800 : 300,
    },
  );
}

async function getUserWithDynamicTTL(userId: string): Promise<User | null> {
  const cacheKey = `cache:user:${userId}`;
 
  const cached = await redis.get(cacheKey);
  if (cached !== null) {
    return JSON.parse(cached) as User | null;
  }
 
  const row = await db.query("SELECT * FROM users WHERE id = $1", [userId]);
  const user: User | null = row[0] ?? null;
 
  // 존재하는 결과는 30분, null 결과는 5분 캐시
  const ttl = user ? 1800 : 300;
  await redis.set(cacheKey, JSON.stringify(user), "EX", ttl);
 
  return user;
}

async function updateUser(userId: string, updates: Partial<User>): Promise<User> {
  // 1단계: 데이터베이스 업데이트
  const updated = await db.query(
    "UPDATE users SET name = COALESCE($2, name), email = COALESCE($3, email) WHERE id = $1 RETURNING *",
    [userId, updates.name, updates.email],
  );
  const user: User = updated[0];
 
  // 2단계: 캐시 즉시 업데이트
  const cacheKey = `cache:user:${userId}`;
  await redis.set(cacheKey, JSON.stringify(user), "EX", 1800);
 
  return user;
}

async function updateUserWriteBehind(userId: string, updates: Partial<User>): Promise<User> {
  const cacheKey = `cache:user:${userId}`;
 
  // 현재 상태 읽기
  const current = await redis.get(cacheKey);
  const user = current ? (JSON.parse(current) as User) : null;
  if (!user) throw new Error("User not in cache");
 
  // 캐시 즉시 업데이트
  const updated = { ...user, ...updates };
  await redis.set(cacheKey, JSON.stringify(updated), "EX", 1800);
 
  // 비동기 처리를 위해 데이터베이스 쓰기 큐에 넣기
  await redis.rpush("write_behind:users", JSON.stringify({ userId, updates, timestamp: Date.now() }));
 
  return updated;
}

async function processWriteBehindQueue(): Promise<void> {
  while (true) {
    const item = await redis.blpop("write_behind:users", 5);
 
    if (item) {
      const { userId, updates } = JSON.parse(item[1]);
      try {
        await db.query("UPDATE users SET name = COALESCE($2, name), email = COALESCE($3, email) WHERE id = $1", [
          userId,
          updates.name,
          updates.email,
        ]);
      } catch (err) {
        // 실패 시 재시도 카운트와 함께 다시 큐에 넣기
        console.error("[WriteBehind] Failed:", err);
        await redis.rpush("write_behind:users:dlq", item[1]);
      }
    }
  }
}

const TTL = {
  // 계층 1: 거의 변경되지 않음, 계산 비용이 큼
  // 예: 상품 카탈로그, 사이트 설정, 기능 플래그
  STATIC: 86400, // 24시간
 
  // 계층 2: 가끔 변경됨, 중간 비용
  // 예: 사용자 프로필, 팀 설정, 권한
  MODERATE: 1800, // 30분
 
  // 계층 3: 자주 변경됨, 계산 비용은 낮지만 자주 호출됨
  // 예: 피드 데이터, 알림 수, 세션 정보
  VOLATILE: 300, // 5분
 
  // 계층 4: 임시, 레이트 리미팅과 락에 사용
  EPHEMERAL: 60, // 1분
 
  // Null 결과: 항상 짧은 수명
  NOT_FOUND: 120, // 2분
} as const;

function ttlWithJitter(baseTtl: number, jitterPercent = 0.1): number {
  const jitter = baseTtl * jitterPercent;
  const offset = Math.random() * jitter * 2 - jitter;
  return Math.max(1, Math.round(baseTtl + offset));
}
 
// 이렇게 하지 말고: redis.set(key, value, "EX", 3600)
// 이렇게 하세요: redis.set(key, value, "EX", ttlWithJitter(3600))
 
// 3600 ± 10% = 3240에서 3960 사이의 랜덤 값

const ttl = ttlWithJitter(3600, 0.2); // 2880~4320초

async function getWithSlidingExpiry<T>(key: string, ttl: number): Promise<T | null> {
  // GETEX는 값을 가져오면서 원자적으로 TTL을 리셋함
  const value = await redis.getex(key, "EX", ttl);
  if (value === null) return null;
  return JSON.parse(value) as T;
}

async function getWithSlidingExpiryCompat<T>(key: string, ttl: number): Promise<T | null> {
  const pipeline = redis.pipeline();
  pipeline.get(key);
  pipeline.expire(key, ttl);
  const results = await pipeline.exec();
 
  if (!results || !results[0] || results[0][1] === null) return null;
  return JSON.parse(results[0][1] as string) as T;
}

async function cacheAsideWithMutex<T>(key: string, fetcher: () => Promise<T>, ttl: number = 3600): Promise<T | null> {
  const cacheKey = `cache:${key}`;
  const lockKey = `lock:${key}`;
 
  // 먼저 캐시 시도
  const cached = await redis.get(cacheKey);
  if (cached !== null) {
    return JSON.parse(cached) as T;
  }
 
  // 락 획득 시도 (NX = 존재하지 않을 때만, EX = 자동 만료)
  const acquired = await redis.set(lockKey, "1", "EX", 10, "NX");
 
  if (acquired) {
    try {
      // 락을 얻었음 — 가져와서 캐시
      const result = await fetcher();
      await redis.set(cacheKey, JSON.stringify(result), "EX", ttlWithJitter(ttl));
      return result;
    } finally {
      // 락 해제
      await redis.del(lockKey);
    }
  }
 
  // 다른 요청이 락을 보유 중 — 대기 후 재시도
  await sleep(100);
 
  const retried = await redis.get(cacheKey);
  if (retried !== null) {
    return JSON.parse(retried) as T;
  }
 
  // 여전히 캐시 없음 — 데이터베이스로 직접
  // (락 보유자가 실패한 경우 처리)
  return fetcher();
}
 
function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

import { randomUUID } from "crypto";
 
async function acquireLock(lockKey: string, ttl: number): Promise<string | null> {
  const token = randomUUID();
  const acquired = await redis.set(lockKey, token, "EX", ttl, "NX");
  return acquired ? token : null;
}
 
async function releaseLock(lockKey: string, token: string): Promise<boolean> {
  // Lua 스크립트가 원자적 확인 후 삭제를 보장
  const script = `
    if redis.call("get", KEYS[1]) == ARGV[1] then
      return redis.call("del", KEYS[1])
    else
      return 0
    end
  `;
  const result = await redis.eval(script, 1, lockKey, token);
  return result === 1;
}

interface CachedValue<T> {
  data: T;
  cachedAt: number;
  ttl: number;
}
 
async function cacheWithEarlyExpiration<T>(key: string, fetcher: () => Promise<T>, ttl: number = 3600): Promise<T> {
  const cacheKey = `cache:${key}`;
  const cached = await redis.get(cacheKey);
 
  if (cached !== null) {
    const entry = JSON.parse(cached) as CachedValue<T>;
    const age = (Date.now() - entry.cachedAt) / 1000;
    const remaining = entry.ttl - age;
 
    // XFetch 알고리즘: 만료가 다가올수록 확률적으로 재생성
    // beta * Math.log(Math.random())은 음수를 생성하며
    // 만료가 가까워질수록 더 커짐 (더 음수)
    const beta = 1; // 튜닝 파라미터, 1이 잘 작동함
    const shouldRegenerate = remaining - beta * Math.log(Math.random()) * -1 <= 0;
 
    if (!shouldRegenerate) {
      return entry.data;
    }
 
    // 재생성으로 이동
    console.log(`[Cache] Early regeneration triggered for ${key}`);
  }
 
  const data = await fetcher();
  const entry: CachedValue<T> = {
    data,
    cachedAt: Date.now(),
    ttl,
  };
 
  // Redis가 재생성하기 전에 만료되지 않도록 추가 버퍼로 설정
  await redis.set(cacheKey, JSON.stringify(entry), "EX", Math.round(ttl * 1.1));
 
  return data;
}

async function staleWhileRevalidate<T>(
  key: string,
  fetcher: () => Promise<T>,
  options: {
    freshTtl: number; // 데이터가 "신선한" 기간
    staleTtl: number; // 오래된 데이터를 제공할 수 있는 기간
  },
): Promise<T | null> {
  const cacheKey = `cache:${key}`;
  const metaKey = `meta:${key}`;
 
  const [cached, meta] = await redis.mget(cacheKey, metaKey);
 
  if (cached !== null) {
    const parsedMeta = meta ? JSON.parse(meta) : null;
    const isFresh = parsedMeta && Date.now() - parsedMeta.cachedAt < options.freshTtl * 1000;
 
    if (!isFresh) {
      // 데이터가 오래됨 — 제공하되 백그라운드 새로고침 트리거
      revalidateInBackground(key, cacheKey, metaKey, fetcher, options);
    }
 
    return JSON.parse(cached) as T;
  }
 
  // 완전한 캐시 미스 — 동기적으로 가져와야 함
  return fetchAndCache(key, cacheKey, metaKey, fetcher, options);
}
 
async function fetchAndCache<T>(
  key: string,
  cacheKey: string,
  metaKey: string,
  fetcher: () => Promise<T>,
  options: { freshTtl: number; staleTtl: number },
): Promise<T> {
  const data = await fetcher();
  const totalTtl = options.freshTtl + options.staleTtl;
 
  const pipeline = redis.pipeline();
  pipeline.set(cacheKey, JSON.stringify(data), "EX", totalTtl);
  pipeline.set(metaKey, JSON.stringify({ cachedAt: Date.now() }), "EX", totalTtl);
  await pipeline.exec();
 
  return data;
}
 
function revalidateInBackground<T>(
  key: string,
  cacheKey: string,
  metaKey: string,
  fetcher: () => Promise<T>,
  options: { freshTtl: number; staleTtl: number },
): void {
  // 다중 백그라운드 새로고침을 방지하기 위해 락 사용
  const lockKey = `revalidate_lock:${key}`;
 
  redis
    .set(lockKey, "1", "EX", 30, "NX")
    .then((acquired) => {
      if (!acquired) return;
 
      return fetchAndCache(key, cacheKey, metaKey, fetcher, options).finally(() => redis.del(lockKey));
    })
    .catch((err) => {
      console.error(`[SWR] Background revalidation failed for ${key}:`, err);
    });
}

const user = await staleWhileRevalidate<User>("user:123", fetchUserFromDB, {
  freshTtl: 300, // 5분 신선
  staleTtl: 3600, // 재검증하는 동안 최대 1시간 오래된 것 제공
});

async function updateUserAndInvalidate(userId: string, updates: Partial<User>): Promise<User> {
  const user = await db.query("UPDATE users SET name = $2 WHERE id = $1 RETURNING *", [userId, updates.name]);
 
  // 캐시 무효화
  await redis.del(`cache:user:${userId}`);
 
  return user[0];
}

async function setWithTags<T>(key: string, value: T, ttl: number, tags: string[]): Promise<void> {
  const pipeline = redis.pipeline();
 
  // 값 저장
  pipeline.set(`cache:${key}`, JSON.stringify(value), "EX", ttl);
 
  // 각 태그의 집합에 키 추가
  for (const tag of tags) {
    pipeline.sadd(`tag:${tag}`, `cache:${key}`);
    pipeline.expire(`tag:${tag}`, ttl + 3600); // 태그 집합은 값보다 오래 살아남음
  }
 
  await pipeline.exec();
}
 
async function invalidateByTag(tag: string): Promise<number> {
  const keys = await redis.smembers(`tag:${tag}`);
 
  if (keys.length === 0) return 0;
 
  const pipeline = redis.pipeline();
  for (const key of keys) {
    pipeline.del(key);
  }
  pipeline.del(`tag:${tag}`);
 
  await pipeline.exec();
  return keys.length;
}

// 팀 데이터를 캐시할 때 모든 멤버 ID로 태그
const team = await fetchTeam(teamId);
await setWithTags(`team:${teamId}`, team, 1800, [
  `entity:team:${teamId}`,
  ...team.members.map((m) => `entity:user:${m.id}`),
]);
 
// 사용자 42가 프로필을 업데이트하면, 그들을 포함하는 모든 것을 무효화
await invalidateByTag("entity:user:42");

// 발행자 (API 서비스에서)
async function publishInvalidation(entityType: string, entityId: string): Promise<void> {
  await redis.publish("cache:invalidate", JSON.stringify({ entityType, entityId, timestamp: Date.now() }));
}
 
// 구독자 (각 앱 인스턴스에서)
const subscriber = new Redis(/* 같은 설정 */);
 
subscriber.subscribe("cache:invalidate", (err) => {
  if (err) console.error("[PubSub] Subscribe error:", err);
});
 
subscriber.on("message", async (_channel, message) => {
  const { entityType, entityId } = JSON.parse(message);
  await invalidateByTag(`entity:${entityType}:${entityId}`);
  console.log(`[Cache] Invalidated ${entityType}:${entityId}`);
});

async function invalidateByPattern(pattern: string): Promise<number> {
  let cursor = "0";
  let deletedCount = 0;
 
  do {
    const [nextCursor, keys] = await redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
    cursor = nextCursor;
 
    if (keys.length > 0) {
      await redis.del(...keys);
      deletedCount += keys.length;
    }
  } while (cursor !== "0");
 
  return deletedCount;
}
 
// 특정 팀의 모든 캐시된 데이터 무효화
await invalidateByPattern("cache:team:42:*");

// 사용자를 해시로 저장
async function setUserHash(user: User): Promise<void> {
  const key = `user:${user.id}`;
  await redis.hset(key, {
    name: user.name,
    email: user.email,
    plan: user.plan,
    updatedAt: Date.now().toString(),
  });
  await redis.expire(key, 1800);
}
 
// 특정 필드 읽기
async function getUserPlan(userId: string): Promise<string | null> {
  return redis.hget(`user:${userId}`, "plan");
}
 
// 단일 필드 업데이트
async function upgradeUserPlan(userId: string, plan: string): Promise<void> {
  await redis.hset(`user:${userId}`, "plan", plan);
}
 
// 전체 해시를 객체로 읽기
async function getUserHash(userId: string): Promise<User | null> {
  const data = await redis.hgetall(`user:${userId}`);
  if (!data || Object.keys(data).length === 0) return null;
 
  return {
    id: userId,
    name: data.name,
    email: data.email,
    plan: data.plan as User["plan"],
  };
}

// 리더보드
async function addScore(leaderboard: string, userId: string, score: number): Promise<void> {
  await redis.zadd(leaderboard, score, userId);
}
 
async function getTopPlayers(
  leaderboard: string,
  count: number = 10,
): Promise<Array<{ userId: string; score: number }>> {
  const results = await redis.zrevrange(leaderboard, 0, count - 1, "WITHSCORES");
 
  const players: Array<{ userId: string; score: number }> = [];
  for (let i = 0; i < results.length; i += 2) {
    players.push({
      userId: results[i],
      score: parseFloat(results[i + 1]),
    });
  }
  return players;
}
 
async function getUserRank(leaderboard: string, userId: string): Promise<number | null> {
  const rank = await redis.zrevrank(leaderboard, userId);
  return rank !== null ? rank + 1 : null; // 0-인덱스를 1-인덱스로
}

async function slidingWindowRateLimit(
  identifier: string,
  windowMs: number,
  maxRequests: number,
): Promise<{ allowed: boolean; remaining: number }> {
  const key = `ratelimit:${identifier}`;
  const now = Date.now();
  const windowStart = now - windowMs;
 
  const pipeline = redis.pipeline();
 
  // 윈도우 밖의 항목 제거
  pipeline.zremrangebyscore(key, 0, windowStart);
 
  // 현재 요청 추가
  pipeline.zadd(key, now, `${now}:${Math.random()}`);
 
  // 윈도우 내 요청 수 세기
  pipeline.zcard(key);
 
  // 전체 키에 만료 설정
  pipeline.expire(key, Math.ceil(windowMs / 1000));
 
  const results = await pipeline.exec();
  const count = results?.[2]?.[1] as number;
 
  return {
    allowed: count <= maxRequests,
    remaining: Math.max(0, maxRequests - count),
  };
}

interface Job {
  id: string;
  type: string;
  payload: Record<string, unknown>;
  createdAt: number;
}
 
// 생산자
async function enqueueJob(queue: string, type: string, payload: Record<string, unknown>): Promise<string> {
  const job: Job = {
    id: randomUUID(),
    type,
    payload,
    createdAt: Date.now(),
  };
 
  await redis.lpush(`queue:${queue}`, JSON.stringify(job));
  return job.id;
}
 
// 소비자 (작업이 가용할 때까지 블록)
async function dequeueJob(queue: string, timeout: number = 5): Promise<Job | null> {
  const result = await redis.brpop(`queue:${queue}`, timeout);
  if (!result) return null;
 
  return JSON.parse(result[1]) as Job;
}

// 일별 고유 방문자 추적
async function trackVisitor(page: string, visitorId: string): Promise<boolean> {
  const key = `visitors:${page}:${new Date().toISOString().split("T")[0]}`;
  const isNew = await redis.sadd(key, visitorId);
 
  // 48시간 후 자동 만료
  await redis.expire(key, 172800);
 
  return isNew === 1; // 1 = 새 멤버, 0 = 이미 존재
}
 
// 고유 방문자 수 가져오기
async function getUniqueVisitors(page: string, date: string): Promise<number> {
  return redis.scard(`visitors:${page}:${date}`);
}
 
// 사용자가 이미 액션을 수행했는지 확인
async function hasUserVoted(pollId: string, userId: string): Promise<boolean> {
  return (await redis.sismember(`votes:${pollId}`, userId)) === 1;
}

// 대략적인 고유 카운트를 위한 HyperLogLog
async function trackVisitorApprox(page: string, visitorId: string): Promise<void> {
  const key = `hll:visitors:${page}:${new Date().toISOString().split("T")[0]}`;
  await redis.pfadd(key, visitorId);
  await redis.expire(key, 172800);
}
 
async function getApproxUniqueVisitors(page: string, date: string): Promise<number> {
  return redis.pfcount(`hll:visitors:${page}:${date}`);
}

const user = {
  id: "usr_abc123",
  name: "Ahmet Kousa",
  email: "ahmet@example.com",
  plan: "pro",
  preferences: {
    theme: "dark",
    language: "tr",
    notifications: true,
  },
};
 
// JSON: 189 바이트
const jsonStr = JSON.stringify(user);
console.log(Buffer.byteLength(jsonStr)); // 189
 
// 핫 경로에서의 JSON.parse: 호출당 ~0.02ms
// 초당 10,000 요청에서: 초당 200ms의 총 CPU 시간

npm install msgpackr

import { pack, unpack } from "msgpackr";
 
// MessagePack: ~140 바이트 (25% 더 작음)
const packed = pack(user);
console.log(packed.length); // ~140
 
// Buffer로 저장
await redis.set("user:123", packed);
 
// Buffer로 읽기
const raw = await redis.getBuffer("user:123");
if (raw) {
  const data = unpack(raw);
}

import { promisify } from "util";
import { gzip, gunzip } from "zlib";
 
const gzipAsync = promisify(gzip);
const gunzipAsync = promisify(gunzip);
 
async function setCompressed<T>(key: string, value: T, ttl: number): Promise<void> {
  const json = JSON.stringify(value);
 
  // 1KB보다 큰 경우에만 압축 (작은 값에는 압축 오버헤드가 가치 없음)
  if (Buffer.byteLength(json) > 1024) {
    const compressed = await gzipAsync(json);
    await redis.set(key, compressed, "EX", ttl);
  } else {
    await redis.set(key, json, "EX", ttl);
  }
}
 
async function getCompressed<T>(key: string): Promise<T | null> {
  const raw = await redis.getBuffer(key);
  if (!raw) return null;
 
  try {
    // 먼저 압축 해제 시도
    const decompressed = await gunzipAsync(raw);
    return JSON.parse(decompressed.toString()) as T;
  } catch {
    // 압축되지 않음, 일반 JSON으로 파싱
    return JSON.parse(raw.toString()) as T;
  }
}

// app/api/products/route.ts
import { NextResponse } from "next/server";
import redis from "@/lib/redis";
 
export async function GET(request: Request) {
  const url = new URL(request.url);
  const category = url.searchParams.get("category") || "all";
  const cacheKey = `api:products:${category}`;
 
  // 캐시 확인
  const cached = await redis.get(cacheKey);
  if (cached) {
    return NextResponse.json(JSON.parse(cached), {
      headers: {
        "X-Cache": "HIT",
        "Cache-Control": "public, s-maxage=60",
      },
    });
  }
 
  // 데이터베이스에서 가져오기
  const products = await db.products.findMany({
    where: category !== "all" ? { category } : undefined,
    orderBy: { createdAt: "desc" },
    take: 50,
  });
 
  // 지터와 함께 5분간 캐시
  await redis.set(cacheKey, JSON.stringify(products), "EX", ttlWithJitter(300));
 
  return NextResponse.json(products, {
    headers: {
      "X-Cache": "MISS",
      "Cache-Control": "public, s-maxage=60",
    },
  });
}

// lib/session.ts
import { randomUUID } from "crypto";
import redis from "./redis";
 
interface Session {
  userId: string;
  role: string;
  createdAt: number;
  data: Record<string, unknown>;
}
 
const SESSION_TTL = 86400; // 24시간
const SESSION_PREFIX = "session:";
 
export async function createSession(userId: string, role: string): Promise<string> {
  const sessionId = randomUUID();
  const session: Session = {
    userId,
    role,
    createdAt: Date.now(),
    data: {},
  };
 
  await redis.set(`${SESSION_PREFIX}${sessionId}`, JSON.stringify(session), "EX", SESSION_TTL);
 
  return sessionId;
}
 
export async function getSession(sessionId: string): Promise<Session | null> {
  const key = `${SESSION_PREFIX}${sessionId}`;
 
  // GETEX를 사용해서 매 접근마다 TTL 새로고침 (슬라이딩 만료)
  const raw = await redis.getex(key, "EX", SESSION_TTL);
  if (!raw) return null;
 
  return JSON.parse(raw) as Session;
}
 
export async function destroySession(sessionId: string): Promise<void> {
  await redis.del(`${SESSION_PREFIX}${sessionId}`);
}
 
// 사용자의 모든 세션 파괴 ("모든 곳에서 로그아웃"에 유용)
export async function destroyAllUserSessions(userId: string): Promise<void> {
  // 사용자->세션 인덱스를 유지해야 함
  const sessionIds = await redis.smembers(`user_sessions:${userId}`);
 
  if (sessionIds.length > 0) {
    const pipeline = redis.pipeline();
    for (const sid of sessionIds) {
      pipeline.del(`${SESSION_PREFIX}${sid}`);
    }
    pipeline.del(`user_sessions:${userId}`);
    await pipeline.exec();
  }
}

// middleware.ts (또는 미들웨어에서 사용되는 헬퍼)
import redis from "@/lib/redis";
 
interface RateLimitResult {
  allowed: boolean;
  remaining: number;
  resetAt: number;
}
 
export async function rateLimit(
  identifier: string,
  limit: number = 60,
  windowSeconds: number = 60,
): Promise<RateLimitResult> {
  const key = `rate:${identifier}`;
  const now = Math.floor(Date.now() / 1000);
  const windowStart = now - windowSeconds;
 
  // 원자적 레이트 리미팅을 위한 Lua 스크립트
  const script = `
    redis.call('ZREMRANGEBYSCORE', KEYS[1], 0, ARGV[1])
    redis.call('ZADD', KEYS[1], ARGV[2], ARGV[3])
    local count = redis.call('ZCARD', KEYS[1])
    redis.call('EXPIRE', KEYS[1], ARGV[4])
    return count
  `;
 
  const count = (await redis.eval(
    script,
    1,
    key,
    windowStart,
    now,
    `${now}:${Math.random()}`,
    windowSeconds,
  )) as number;
 
  return {
    allowed: count <= limit,
    remaining: Math.max(0, limit - count),
    resetAt: now + windowSeconds,
  };
}

// lib/distributed-lock.ts
import { randomUUID } from "crypto";
import redis from "./redis";
 
export async function withLock<T>(
  lockName: string,
  fn: () => Promise<T>,
  options: { ttl?: number; retryDelay?: number; maxRetries?: number } = {},
): Promise<T | null> {
  const { ttl = 30, retryDelay = 200, maxRetries = 10 } = options;
  const token = randomUUID();
  const lockKey = `dlock:${lockName}`;
 
  // 락 획득 시도
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const acquired = await redis.set(lockKey, token, "EX", ttl, "NX");
 
    if (acquired) {
      try {
        // 장기 실행 작업을 위해 자동으로 락 연장
        const extender = setInterval(
          async () => {
            const script = `
            if redis.call("get", KEYS[1]) == ARGV[1] then
              return redis.call("expire", KEYS[1], ARGV[2])
            else
              return 0
            end
          `;
            await redis.eval(script, 1, lockKey, token, ttl);
          },
          (ttl * 1000) / 3,
        );
 
        const result = await fn();
        clearInterval(extender);
        return result;
      } finally {
        // 여전히 소유하고 있을 때만 락 해제
        const releaseScript = `
          if redis.call("get", KEYS[1]) == ARGV[1] then
            return redis.call("del", KEYS[1])
          else
            return 0
          end
        `;
        await redis.eval(releaseScript, 1, lockKey, token);
      }
    }
 
    // 재시도 전 대기
    await new Promise((r) => setTimeout(r, retryDelay));
  }
 
  // 모든 재시도 후에도 락을 획득할 수 없음
  return null;
}

// cron으로 트리거되는 API 라우트에서
export async function POST() {
  const result = await withLock("daily-report", async () => {
    // 하나의 인스턴스만 이것을 실행
    const report = await generateDailyReport();
    await sendReportEmail(report);
    return report;
  });
 
  if (result === null) {
    return NextResponse.json({ message: "Another instance is already processing" }, { status: 409 });
  }
 
  return NextResponse.json({ success: true });
}

// lib/cache-metrics.ts
import redis from "./redis";
 
const METRICS_KEY = "metrics:cache";
 
export async function recordCacheHit(): Promise<void> {
  await redis.hincrby(METRICS_KEY, "hits", 1);
}
 
export async function recordCacheMiss(): Promise<void> {
  await redis.hincrby(METRICS_KEY, "misses", 1);
}
 
export async function getCacheStats(): Promise<{
  hits: number;
  misses: number;
  hitRate: number;
}> {
  const stats = await redis.hgetall(METRICS_KEY);
  const hits = parseInt(stats.hits || "0", 10);
  const misses = parseInt(stats.misses || "0", 10);
  const total = hits + misses;
 
  return {
    hits,
    misses,
    hitRate: total > 0 ? hits / total : 0,
  };
}
 
// 매일 메트릭 리셋
export async function resetCacheStats(): Promise<void> {
  await redis.del(METRICS_KEY);
}

redis-cli INFO memory

redis-cli INFO stats

# 프로덕션에서 절대 이것을 실행한 채로 두지 마세요
# 상당한 오버헤드를 추가하고 민감한 데이터를 로깅할 수 있음
redis-cli MONITOR

# 만료 및 퇴거 이벤트에 대한 키스페이스 알림 활성화
redis-cli CONFIG SET notify-keyspace-events Ex

const subscriber = new Redis(/* 설정 */);
 
// 키 만료 이벤트 수신
subscriber.subscribe("__keyevent@0__:expired", (err) => {
  if (err) console.error("Subscribe error:", err);
});
 
subscriber.on("message", (_channel, expiredKey) => {
  console.log(`Key expired: ${expiredKey}`);
 
  // 중요한 키를 사전에 재생성
  if (expiredKey.startsWith("cache:homepage")) {
    regenerateHomepageCache().catch(console.error);
  }
});

# 가장 큰 키 10개 샘플
redis-cli --bigkeys

# 특정 키의 메모리 사용량 (바이트)
redis-cli MEMORY USAGE "cache:search:electronics"

// 프로그래밍 방식 메모리 분석
async function analyzeMemory(pattern: string): Promise<void> {
  let cursor = "0";
  const stats: Array<{ key: string; bytes: number }> = [];
 
  do {
    const [nextCursor, keys] = await redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
    cursor = nextCursor;
 
    for (const key of keys) {
      const bytes = await redis.memory("USAGE", key);
      if (bytes) {
        stats.push({ key, bytes: bytes as number });
      }
    }
  } while (cursor !== "0");
 
  // 크기 내림차순 정렬
  stats.sort((a, b) => b.bytes - a.bytes);
 
  console.log("메모리 사용량 상위 20개 키:");
  for (const { key, bytes } of stats.slice(0, 20)) {
    const mb = (bytes / 1024 / 1024).toFixed(2);
    console.log(`  ${key}: ${mb} MB`);
  }
}

# redis.conf 또는 CONFIG SET으로
maxmemory 512mb
maxmemory-policy allkeys-lru

// lib/cache.ts
import Redis from "ioredis";
 
const redis = new Redis({
  host: process.env.REDIS_HOST || "127.0.0.1",
  port: Number(process.env.REDIS_PORT) || 6379,
  password: process.env.REDIS_PASSWORD || undefined,
  maxRetriesPerRequest: 3,
  retryStrategy(times) {
    return Math.min(times * 200, 5000);
  },
});
 
// TTL 계층
const TTL = {
  STATIC: 86400,
  MODERATE: 1800,
  VOLATILE: 300,
  EPHEMERAL: 60,
  NOT_FOUND: 120,
} as const;
 
type TTLTier = keyof typeof TTL;
 
function ttlWithJitter(base: number, jitter = 0.1): number {
  const offset = base * jitter * (Math.random() * 2 - 1);
  return Math.max(1, Math.round(base + offset));
}
 
// 스탬피드 보호가 있는 핵심 cache-aside
async function get<T>(
  key: string,
  fetcher: () => Promise<T>,
  options: {
    tier?: TTLTier;
    ttl?: number;
    tags?: string[];
    swr?: { freshTtl: number; staleTtl: number };
  } = {},
): Promise<T> {
  const { tier = "MODERATE", tags } = options;
  const baseTtl = options.ttl ?? TTL[tier];
  const cacheKey = `c:${key}`;
 
  // 캐시 확인
  const cached = await redis.get(cacheKey);
 
  if (cached !== null) {
    try {
      const parsed = JSON.parse(cached);
      recordHit();
      return parsed as T;
    } catch {
      await redis.del(cacheKey);
    }
  }
 
  recordMiss();
 
  // 스탬피드 방지를 위한 락 획득
  const lockKey = `lock:${key}`;
  const acquired = await redis.set(lockKey, "1", "EX", 10, "NX");
 
  if (!acquired) {
    // 다른 프로세스가 가져오는 중 — 잠시 대기 후 캐시 재시도
    await new Promise((r) => setTimeout(r, 150));
    const retried = await redis.get(cacheKey);
    if (retried) return JSON.parse(retried) as T;
  }
 
  try {
    const result = await fetcher();
    const ttl = ttlWithJitter(baseTtl);
 
    const pipeline = redis.pipeline();
    pipeline.set(cacheKey, JSON.stringify(result), "EX", ttl);
 
    // 태그 연관 저장
    if (tags) {
      for (const tag of tags) {
        pipeline.sadd(`tag:${tag}`, cacheKey);
        pipeline.expire(`tag:${tag}`, ttl + 3600);
      }
    }
 
    await pipeline.exec();
    return result;
  } finally {
    await redis.del(lockKey);
  }
}
 
// 무효화
async function invalidate(...keys: string[]): Promise<void> {
  if (keys.length === 0) return;
  await redis.del(...keys.map((k) => `c:${k}`));
}
 
async function invalidateByTag(tag: string): Promise<number> {
  const keys = await redis.smembers(`tag:${tag}`);
  if (keys.length === 0) return 0;
 
  const pipeline = redis.pipeline();
  for (const key of keys) {
    pipeline.del(key);
  }
  pipeline.del(`tag:${tag}`);
  await pipeline.exec();
  return keys.length;
}
 
// 메트릭
function recordHit(): void {
  redis.hincrby("metrics:cache", "hits", 1).catch(() => {});
}
 
function recordMiss(): void {
  redis.hincrby("metrics:cache", "misses", 1).catch(() => {});
}
 
async function stats(): Promise<{
  hits: number;
  misses: number;
  hitRate: string;
}> {
  const raw = await redis.hgetall("metrics:cache");
  const hits = parseInt(raw.hits || "0", 10);
  const misses = parseInt(raw.misses || "0", 10);
  const total = hits + misses;
 
  return {
    hits,
    misses,
    hitRate: total > 0 ? ((hits / total) * 100).toFixed(1) + "%" : "N/A",
  };
}
 
export const cache = {
  get,
  invalidate,
  invalidateByTag,
  stats,
  redis,
  TTL,
};

import { cache } from "@/lib/cache";
 
// 단순 cache-aside
const products = await cache.get("products:featured", fetchFeaturedProducts, {
  tier: "VOLATILE",
  tags: ["entity:products"],
});
 
// 커스텀 TTL
const config = await cache.get("app:config", fetchAppConfig, {
  ttl: 43200, // 12시간
});
 
// 상품 업데이트 후
await cache.invalidateByTag("entity:products");
 
// 건강 확인
const metrics = await cache.stats();
console.log(`캐시 히트율: ${metrics.hitRate}`);

async function resilientGet<T>(key: string, fetcher: () => Promise<T>): Promise<T> {
  try {
    return await cache.get(key, fetcher);
  } catch (err) {
    console.error(`[Cache] Degraded mode for ${key}:`, err);
    return fetcher(); // 캐시를 완전히 우회
  }
}