Cache TTL 控制

┌─────────────────────────────────────────────────────────────┐
│                    缓存架构层级                              │
├─────────────────────────────────────────────────────────────┤
│  L1: 进程级内存缓存                                          │
│      - Provider 配置缓存 (30s TTL)                           │
│      - 系统设置缓存 (60s TTL)                                │
│      - 熔断器配置缓存 (5min TTL)                             │
├─────────────────────────────────────────────────────────────┤
│  L2: Redis 分布式缓存                                        │
│      - Session 数据 (5min TTL, 可配置)                       │
│      - 限流计数窗口 (动态 TTL)                               │
│      - 熔断器状态 (24h TTL)                                  │
│      - 并发 Session 追踪 (1h 兜底 TTL)                       │
│      - 客户端版本信息 (7d / 5min TTL)                        │
├─────────────────────────────────────────────────────────────┤
│  L3: 持久化存储 (PostgreSQL)                                 │
│      - 所有业务数据的最终持久化                              │
└─────────────────────────────────────────────────────────────┘

# .env.example

# Session TTL（秒）- 控制 Session 缓存时长
SESSION_TTL=300                         # 默认 300 秒 = 5 分钟

# 供应商进程级缓存开关
ENABLE_PROVIDER_CACHE=true              # 默认启用，30s TTL

# 限流功能开关（影响所有限流相关缓存）
ENABLE_RATE_LIMIT=true                  # 默认启用

// SessionManager 中的 TTL 定义
private static readonly SESSION_TTL = parseInt(process.env.SESSION_TTL || "300", 10);

// src/lib/session-manager.ts
private static async refreshSessionTTL(sessionId: string): Promise<void> {
  const redis = getRedisClient();
  if (!redis || redis.status !== "ready") return;

  try {
    const pipeline = redis.pipeline();

    // 刷新所有 session 相关 key 的 TTL
    pipeline.expire(`session:${sessionId}:key`, SessionManager.SESSION_TTL);
    pipeline.expire(`session:${sessionId}:provider`, SessionManager.SESSION_TTL);
    pipeline.setex(
      `session:${sessionId}:last_seen`,
      SessionManager.SESSION_TTL,
      Date.now().toString()
    );

    await pipeline.exec();
  } catch (error) {
    logger.error("SessionManager: Failed to refresh TTL", { error });
  }
}

// src/lib/session-tracker.ts
static async incrementConcurrentCount(sessionId: string): Promise<void> {
  const key = `session:${sessionId}:concurrent_count`;
  await redis.incr(key);
  await redis.expire(key, 600); // 10 分钟 TTL
}

export async function getTTLForPeriod(
  period: TimePeriod,
  resetTime = "00:00"
): Promise<number> {
  switch (period) {
    case "5h":
      return 5 * 3600; // 5 小时固定

    case "daily": {
      // 计算到下一个自定义重置时间的秒数
      const nextReset = getNextDailyResetTime(now, normalizedResetTime, timezone);
      return Math.max(1, Math.ceil((nextReset.getTime() - now.getTime()) / 1000));
    }

    case "weekly": {
      // 计算到下周一 00:00 的秒数
      const zonedNow = toZonedTime(now, timezone);
      const zonedStartOfWeek = startOfWeek(zonedNow, { weekStartsOn: 1 });
      const zonedNextWeek = addWeeks(zonedStartOfWeek, 1);
      const nextWeek = fromZonedTime(zonedNextWeek, timezone);
      return Math.ceil((nextWeek.getTime() - now.getTime()) / 1000);
    }

    case "monthly": {
      // 计算到下月 1 号 00:00 的秒数
      const zonedNow = toZonedTime(now, timezone);
      const zonedStartOfMonth = startOfMonth(zonedNow);
      const zonedNextMonth = addMonths(zonedStartOfMonth, 1);
      const nextMonth = fromZonedTime(zonedNextMonth, timezone);
      return Math.ceil((nextMonth.getTime() - now.getTime()) / 1000);
    }
  }
}

-- TRACK_COST_5H_ROLLING_WINDOW
-- 设置兜底 TTL（6 小时，防止数据永久堆积）
redis.call('EXPIRE', key, 21600)

-- TRACK_COST_DAILY_ROLLING_WINDOW
-- 设置兜底 TTL（25 小时，防止数据永久堆积）
redis.call('EXPIRE', key, 90000)

// src/lib/rate-limit/service.ts
await redis
  .pipeline()
  .zadd(key, now, `${now}:${Math.random()}`)
  .expire(key, 120) // 2 分钟 TTL
  .exec();

// State TTL: 24 hours (cleanup old states)
const STATE_TTL_SECONDS = 86400;

export async function saveCircuitState(
  providerId: number,
  state: CircuitBreakerState
): Promise<void> {
  const key = getStateKey(providerId); // circuit_breaker:state:{providerId}
  await redis.hset(key, data);
  await redis.expire(key, STATE_TTL_SECONDS);
}

// src/lib/circuit-breaker.ts
const CONFIG_CACHE_TTL = 5 * 60 * 1000; // 5 分钟

async function getProviderConfig(providerId: number): Promise<CircuitBreakerConfig> {
  // 检查内存缓存是否有效
  if (health.config && health.configLoadedAt && 
      now - health.configLoadedAt < CONFIG_CACHE_TTL) {
    return health.config;
  }
  // 从 Redis/数据库加载配置
  const config = await loadProviderCircuitConfig(providerId);
}

const CACHE_TTL_MS = 30_000; // 30 seconds

interface ProviderCacheState {
  data: Provider[] | null;
  expiresAt: number;
  version: number; // 防止并发刷新竞态
  refreshPromise: Promise<Provider[]> | null;
}

// 失效通知频道
export const CHANNEL_PROVIDERS_UPDATED = "cch:cache:providers:updated";

// 发布失效通知（CRUD 操作后调用）
export async function publishProviderCacheInvalidation(): Promise<void> {
  invalidateCache();
  await publishCacheInvalidation(CHANNEL_PROVIDERS_UPDATED);
}

// 订阅失效通知
await subscribeCacheInvalidation(CHANNEL_PROVIDERS_UPDATED, () => {
  invalidateCache();
});

export async function getCachedProviders(fetcher: () => Promise<Provider[]>): Promise<Provider[]> {
  // 检查是否启用缓存（默认启用）
  if (!ENABLE_PROVIDER_CACHE) {
    return fetcher();
  }

  // 缓存命中且未过期
  if (cache.data && cache.expiresAt > now) {
    return cache.data;
  }

  // 需要刷新，从数据库加载
  const data = await fetcher();
  cache.data = data;
  cache.expiresAt = Date.now() + CACHE_TTL_MS;
  return data;
}

/** Cache TTL in milliseconds (1 minute) */
const CACHE_TTL_MS = 60 * 1000;

export async function getCachedSystemSettings(): Promise<SystemSettings> {
  const now = Date.now();

  // Return cached if still valid
  if (cachedSettings && now - cachedAt < CACHE_TTL_MS) {
    return cachedSettings;
  }

  // Fetch fresh settings from database
  const settings = await getSystemSettings();
  cachedSettings = settings;
  cachedAt = now;
  return settings;
}

try {
  const settings = await getSystemSettings();
  cachedSettings = settings;
  cachedAt = now;
  return settings;
} catch (error) {
  // Fail-open: return previous cached value or defaults
  if (cachedSettings) {
    return cachedSettings;
  }
  // Return minimal default settings
  return { ...DEFAULT_SETTINGS };
}

const TTL = {
  USER_VERSION: 7 * 24 * 60 * 60, // 7 天（匹配活跃窗口）
  GA_VERSION: 5 * 60,             // 5 分钟
};

const redis = getRedisClient();
if (!redis || redis.status !== "ready") {
  // 降级处理：直接查询数据库或使用默认值
  return fetcher();
}

// Pipeline 确保多个操作原子性执行
const pipeline = redis.pipeline();
pipeline.zadd("global:active_sessions", now, sessionId);
pipeline.expire("global:active_sessions", 3600);
await pipeline.exec();

// Provider 缓存预热
export async function warmupProviderCache(fetcher: () => Promise<Provider[]>): Promise<void> {
  try {
    await getCachedProviders(fetcher);
    logger.info("[ProviderCache] Cache warmed up successfully");
  } catch (error) {
    logger.warn("[ProviderCache] Cache warmup failed", { error });
  }
}

// 熔断器状态恢复
export async function loadAllCircuitStates(providerIds: number[]): Promise<Map<number, CircuitBreakerState>> {
  // 启动时从 Redis 批量加载所有熔断器状态
}

# 查看所有 Session 相关 Key
redis-cli --scan --pattern 'session:*'

# 查看特定 Session 的 TTL
redis-cli TTL session:abc123:key
redis-cli TTL session:abc123:provider

# 查看活跃 Session 集合
redis-cli ZRANGE global:active_sessions 0 -1 WITHSCORES

# 查看熔断器状态
redis-cli HGETALL circuit_breaker:state:1

# 查看内存使用
redis-cli INFO memory

# 查看 Key 数量
redis-cli DBSIZE

# 按模式统计 Key 数量
redis-cli --scan --pattern 'session:*:info' | wc -l

# Session TTL - 根据业务场景调整
# - 短对话场景：300s (5分钟)
# - 长对话场景：600s (10分钟) 或更长
SESSION_TTL=300

# 启用所有缓存
ENABLE_PROVIDER_CACHE=true
ENABLE_RATE_LIMIT=true

# Redis 配置
REDIS_URL=redis://localhost:6379