#缓存监控与指标

// Caffeine 缓存统计
Cache<String, Object> cache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .recordStats()
    .build();

CacheStats stats = cache.stats();
System.out.println("命中率: " + String.format("%.2f%%", stats.hitRate() * 100));
System.out.println("未命中率: " + String.format("%.2f%%", stats.missRate() * 100));

@Configuration
public class CacheMetricsConfig {

    @Autowired
    private Cache<String, ProductDetail> productCache;

    @Bean
    public MeterRegistry meterRegistry(MeterRegistry registry) {
        // 缓存命中率
        Gauge.builder("cache_hit_rate", productCache, cache -> {
            CacheStats stats = cache.stats();
            return stats.hitRate();
        }).tag("cache", "product").register(registry);

        // 缓存条目数
        Gauge.builder("cache_size", productCache, Cache::estimatedSize)
            .tag("cache", "product").register(registry);

        // 缓存淘汰数
        Counter.builder("cache_eviction_total")
            .tag("cache", "product")
            .register(registry);

        return registry;
    }
}

@Service
public class CacheHitRateMonitor {

    private static final Logger log = LoggerFactory.getLogger(CacheHitRateMonitor.class);

    @Autowired
    private StringRedisTemplate redisTemplate;

    private AtomicLong totalRequests = new AtomicLong(0);
    private AtomicLong cacheHits = new AtomicLong(0);

    public void recordHit() {
        totalRequests.incrementAndGet();
        cacheHits.incrementAndGet();
    }

    public void recordMiss() {
        totalRequests.incrementAndGet();
    }

    public double getHitRate() {
        long total = totalRequests.get();
        if (total == 0) {
            return 0;
        }
        return (double) cacheHits.get() / total;
    }

    @Scheduled(fixedRate = 60000)  // 每分钟打印
    public void reportHitRate() {
        long total = totalRequests.getAndSet(0);
        long hits = cacheHits.getAndSet(0);

        if (total > 0) {
            double rate = (double) hits / total;
            log.info("缓存命中率报告: 命中={}, 总请求={}, 命中率={:.2f}%",
                hits, total, rate * 100);

            // 发送指标到监控系统
            metricsService.recordGauge("cache.hit_rate", rate);
        }
    }
}

@Service
public class RedisMemoryMonitor {

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Scheduled(fixedRate = 60000)
    public void checkMemoryUsage() {
        Properties info = redisTemplate.getConnectionFactory()
            .getConnection().serverCommands().info("memory");

        if (info != null) {
            String usedMemory = info.getProperty("used_memory");
            String maxMemory = info.getProperty("maxmemory");

            if (usedMemory != null && maxMemory != null) {
                double used = Double.parseDouble(usedMemory);
                double max = Double.parseDouble(maxMemory);
                double usageRate = used / max;

                log.info("Redis 内存使用率: {:.2f}%", usageRate * 100);

                // 告警
                if (usageRate > 0.9) {
                    alertService.sendAlert("Redis 内存使用率超过 90%");
                }
            }
        }
    }
}

@Service
public class RedisBigKeyMonitor {

    @Autowired
    private StringRedisTemplate redisTemplate;

    private static final long BIG_KEY_THRESHOLD = 10 * 1024 * 1024;  // 10MB

    /**
     * 扫描大 Key（生产环境慎用，会阻塞 Redis）
     */
    public void scanBigKeys() {
        Set<byte[]> keys = redisTemplate.getConnectionFactory()
            .getConnection().scan(ScanOptions.scanOptions().count(100).build());

        List<String> bigKeys = new ArrayList<>();

        for (byte[] key : keys) {
            long size = getKeySize(key);
            if (size > BIG_KEY_THRESHOLD) {
                bigKeys.add(new String(key) + " (" + formatSize(size) + ")");
            }
        }

        if (!bigKeys.isEmpty()) {
            log.warn("发现大 Key: {}", bigKeys);
            alertService.sendAlert("发现 " + bigKeys.size() + " 个大 Key");
        }
    }

    private long getKeySize(byte[] key) {
        return redisTemplate.getConnectionFactory()
            .getConnection().type(key).toString().equals("string")
            ? redisTemplate.opsForValue().getOperations().get(key).toString().length()
            : 0;
    }

    private String formatSize(long bytes) {
        if (bytes < 1024) return bytes + "B";
        if (bytes < 1024 * 1024) return String.format("%.2fKB", bytes / 1024.0);
        if (bytes < 1024 * 1024 * 1024) return String.format("%.2fMB", bytes / 1024.0 / 1024.0);
        return String.format("%.2fGB", bytes / 1024.0 / 1024.0 / 1024.0);
    }
}

@Service
public class CacheHealthIndicator implements HealthIndicator {

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Override
    public Health health() {
        try {
            // Ping Redis
            String result = redisTemplate.execute((RedisCallback<String>) connection -> {
                return connection.ping();
            });

            if ("PONG".equals(result)) {
                // 获取状态信息
                Properties info = redisTemplate.getConnectionFactory()
                    .getConnection().serverCommands().info("server");

                return Health.up()
                    .withDetail("redis", "connected")
                    .withDetail("version", info.getProperty("redis_version"))
                    .build();
            } else {
                return Health.down().withDetail("error", "ping failed").build();
            }
        } catch (Exception e) {
            return Health.down().withDetail("error", e.getMessage()).build();
        }
    }
}