Statistics

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.stats.CacheStats;

Cache<String, User> cache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .recordStats()
    .build();

// Perform operations
cache.put("user1", user1);
User user = cache.getIfPresent("user1");

// Retrieve statistics
CacheStats stats = cache.stats();
System.out.println(stats);

import com.github.benmanes.caffeine.cache.stats.StatsCounter;
import com.github.benmanes.caffeine.cache.stats.ConcurrentStatsCounter;
import java.util.function.Supplier;

Supplier<StatsCounter> statsSupplier = () -> new ConcurrentStatsCounter();

Cache<String, User> cache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .recordStats(statsSupplier)
    .build();

CacheStats stats = cache.stats();

System.out.printf("Requests: %d%n", stats.requestCount());
System.out.printf("Hits: %d (%.2f%%)%n", 
    stats.hitCount(), stats.hitRate() * 100);
System.out.printf("Misses: %d (%.2f%%)%n", 
    stats.missCount(), stats.missRate() * 100);

CacheStats stats = cache.stats();

System.out.printf("Load success: %d%n", stats.loadSuccessCount());
System.out.printf("Load failures: %d (%.2f%%)%n",
    stats.loadFailureCount(), stats.loadFailureRate() * 100);
System.out.printf("Average load time: %.2f ms%n",
    stats.averageLoadPenalty() / 1_000_000.0);

CacheStats stats = cache.stats();

System.out.printf("Evictions: %d%n", stats.evictionCount());

if (cache.policy().isRecordingStats()) {
    System.out.printf("Eviction weight: %d%n", stats.evictionWeight());
}

CacheStats stats = cache.stats();

// Check load failure rate
if (stats.loadFailureRate() > 0.01) {
    logger.error("High load failure rate: {}%",
        stats.loadFailureRate() * 100);
}

// Check load time
double avgLoadMs = stats.averageLoadPenalty() / 1_000_000.0;
if (avgLoadMs > 100) {
    logger.warn("Slow load operations: {} ms average", avgLoadMs);
}

// Check if caching is beneficial
double hitRate = stats.hitRate();
if (hitRate > 0 && avgLoadMs > 1) {
    double savedMs = stats.hitCount() * avgLoadMs;
    logger.info("Cache saved approximately {} ms", savedMs);
}

CacheStats stats = cache.stats();

// Calculate eviction rate
double evictionRate = (double) stats.evictionCount() / 
    (stats.loadSuccessCount() + stats.hitCount());

if (evictionRate > 0.50) {
    logger.warn("High eviction rate: {}% - consider increasing cache size",
        evictionRate * 100);
}

// For weighted caches
if (cache.policy().eviction().isPresent()) {
    long evictedWeight = stats.evictionWeight();
    long totalWeight = cache.policy().eviction().get()
        .weightedSize().orElse(0L);
    logger.info("Evicted weight: {} of total {}", 
        evictedWeight, totalWeight);
}

import com.github.benmanes.caffeine.cache.stats.CacheStats;

// Take initial snapshot
CacheStats initial = cache.stats();

// ... perform operations ...

// Take second snapshot
CacheStats current = cache.stats();

// Calculate delta
CacheStats delta = current.minus(initial);

System.out.printf("Requests in period: %d%n", delta.requestCount());
System.out.printf("Hit rate in period: %.2f%%%n", 
    delta.hitRate() * 100);

CacheStats cache1Stats = cache1.stats();
CacheStats cache2Stats = cache2.stats();

// Aggregate
CacheStats combined = cache1Stats.plus(cache2Stats);

System.out.printf("Total requests: %d%n", combined.requestCount());
System.out.printf("Combined hit rate: %.2f%%%n", 
    combined.hitRate() * 100);

import io.prometheus.client.Gauge;

// Define metrics
Gauge cacheHitRate = Gauge.build()
    .name("cache_hit_rate")
    .help("Cache hit rate")
    .register();

Gauge cacheSize = Gauge.build()
    .name("cache_size")
    .help("Number of entries in cache")
    .register();

// Update periodically
ScheduledExecutorService executor = 
    Executors.newScheduledThreadPool(1);

executor.scheduleAtFixedRate(() -> {
    CacheStats stats = cache.stats();
    cacheHitRate.set(stats.hitRate());
    cacheSize.set(cache.estimatedSize());
}, 0, 10, TimeUnit.SECONDS);

import com.github.benmanes.caffeine.cache.stats.StatsCounter;

class MonitoringStatsCounter implements StatsCounter {
    private final MetricsRegistry metrics;
    private final ConcurrentStatsCounter delegate;
    
    MonitoringStatsCounter(MetricsRegistry metrics) {
        this.metrics = metrics;
        this.delegate = new ConcurrentStatsCounter();
    }
    
    @Override
    public void recordHits(int count) {
        delegate.recordHits(count);
        metrics.incrementCounter("cache.hits", count);
    }
    
    @Override
    public void recordMisses(int count) {
        delegate.recordMisses(count);
        metrics.incrementCounter("cache.misses", count);
    }
    
    @Override
    public void recordLoadSuccess(long loadTime) {
        delegate.recordLoadSuccess(loadTime);
        metrics.recordTimer("cache.load.success", loadTime);
    }
    
    @Override
    public void recordLoadFailure(long loadTime) {
        delegate.recordLoadFailure(loadTime);
        metrics.recordTimer("cache.load.failure", loadTime);
    }
    
    @Override
    public void recordEviction(int weight, RemovalCause cause) {
        delegate.recordEviction(weight, cause);
        metrics.incrementCounter("cache.evictions", 1);
        metrics.incrementCounter("cache.evictions." + cause.name(), 1);
    }
    
    @Override
    public CacheStats snapshot() {
        return delegate.snapshot();
    }
}

// Use custom counter
Cache<String, User> cache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .recordStats(() -> new MonitoringStatsCounter(metricsRegistry))
    .build();