# Pass the password through an environment variable to avoid plaintext exposure
export REDISCLI_AUTH='<password>'

# Inspect Big Keys: Output the Key with the most elements by data type
redis-cli -h <instance address> -p <port> --bigkeys

# Inspect Hot Keys: Output high-frequency keys based on LFU access frequency statistics
redis-cli -h <instance address> -p <port> --hotkeys

import redis.clients.jedis.Jedis;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

public class HotKeyDetector {

    // Key → access count
    private static final ConcurrentHashMap<String, AtomicLong> KEY_COUNT = new ConcurrentHashMap<>();
    // Key → cumulative latency (nanoseconds)
    private static final ConcurrentHashMap<String, AtomicLong> KEY_TIME = new ConcurrentHashMap<>();

    /**
     * Wraps the Jedis get operation to automatically collect the access count and latency of each Key.
     */
    public static String get(Jedis jedis, String key) {
        long start = System.nanoTime();
        try {
            return jedis.get(key);
        } finally {
            record(key, System.nanoTime() - start);
        }
    }

    private static void record(String key, long nanos) {
        KEY_COUNT.computeIfAbsent(key, k -> new AtomicLong()).incrementAndGet();
        KEY_TIME.computeIfAbsent(key, k -> new AtomicLong()).addAndGet(nanos);
    }

    /**
     * Prints the top N hot keys. It is recommended to call it through a scheduled task (for example, every 60 seconds).
     */
    public static void printTopN(int n) {
        System.out.println("===== Top " + n + " Hot Keys =====");
        KEY_COUNT.entrySet().stream()
            .sorted((a, b) -> Long.compare(b.getValue().get(), a.getValue().get()))
            .limit(n)
            .forEach(e -> {
                String key = e.getKey();
                long count = e.getValue().get();
                long totalNs = KEY_TIME.getOrDefault(key, new AtomicLong()).get();
                double avgMs = count > 0 ? (totalNs / 1_000_000.0) / count : 0;
                System.out.printf("Key: %s | Count: %d | Avg: %.2f ms%n",
                    key, count, avgMs);
            });
    }

    /**
     * Resets the statistics. Call it after each print to avoid data accumulation.
     */
    public static void reset() {
        KEY_COUNT.clear();
        KEY_TIME.clear();
    }
}

# Hash: Use HSCAN + HDEL to progressively delete expired members, looping until cleanup is complete.
HSCAN key cursor COUNT 100
HDEL key field1 field2 ...

# List: Use LTRIM to trim in batches, keeping only the first 1,000 entries.
LTRIM key 0 999

# Redis 4.0+: Use UNLINK to asynchronously delete the entire big Key to avoid blocking.
UNLINK large_key

// Write: Store the data in binary format after compression.
// You can implement gzipCompress / gzipDecompress based on java.util.zip.GZIPOutputStream.
byte[] compressed = gzipCompress(rawJsonString);
jedis.set(key.getBytes(), compressed);

// Read: Retrieve the binary data and then decompress it to restore the original content.
byte[] data = jedis.get(key.getBytes());
String rawJson = gzipDecompress(data);

# Before Splitting
user:profile:1001 → 2MB JSON

# After Splitting (Grouped by Field)
user:profile:1001:basic    → Basic information
user:profile:1001:extend   → Extended information
user:profile:1001:settings → Settings information

# Hash Splitting: Apply Hash modulo to the Field and distribute it across N sub-Hashes.
# Shard ID = hash(field) % N. Both writes and reads use the same rule for locating the shard.
user:cart:1001:shard_0   → Stores fields whose modulo result is 0.
user:cart:1001:shard_1   → Stores fields whose modulo result is 1.
...

# Before Offloading
file:report:2025-q4 → 15MB PDF BLOB

# After Offloading
file:report:2025-q4:url → "https://bucket.cos.region.myqcloud.com/report-2025-q4.pdf"
file:report:2025-q4:meta → {"size": 15728640, "md5": "abc123..."}

// Cache hot data locally with Caffeine
private static final LoadingCache<String, String> HOT_KEY_CACHE = Caffeine.newBuilder()
    .maximumSize(1000)                            // Maximum number of cached entries
    .expireAfterWrite(50, TimeUnit.MILLISECONDS)  // Expiration time, which controls the data inconsistency window
    .build(key -> {
        // On a cache miss, fetch from Redis and obtain a connection from the connection pool.
        try (Jedis jedis = JEDIS_POOL.getResource()) {
            return jedis.get(key);
        }
    });

# Original Hot Key
hot:product:1001

# Split into Multiple Replicas
hot:product:1001:0 → replica 0
hot:product:1001:1 → replica 1
hot:product:1001:2 → replica 2

// During reads, randomly select a replica to distribute requests across different shards.
int index = ThreadLocalRandom.current().nextInt(REPLICA_COUNT);
String key = "hot:product:" + productId + ":" + index;
try (Jedis jedis = JEDIS_POOL.getResource()) {
    String value = jedis.get(key);
}

User request → Nginx local cache → application local cache (Caffeine) → Redis → database