How to fix JedisDataException: Command timed out in Redis

import redis.clients.jedis.JedisPooled;
import redis.clients.jedis.DefaultJedisClientConfig;
import redis.clients.jedis.HostAndPort;

// Create client with custom timeout
HostAndPort hostAndPort = new HostAndPort("localhost", 6379);

DefaultJedisClientConfig config = DefaultJedisClientConfig.builder()
    .socketTimeoutMillis(5000)      // 5 seconds for command execution
    .connectionTimeoutMillis(5000)   // 5 seconds for connection establishment
    .build();

JedisPooled jedis = new JedisPooled(hostAndPort, config);

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(20);
poolConfig.setMaxIdle(10);

JedisPool pool = new JedisPool(
    poolConfig,
    "localhost",
    6379,
    5000,  // socketTimeout in milliseconds
    5000   // connectionTimeout in milliseconds
);

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

JedisPoolConfig poolConfig = new JedisPoolConfig();

// Maximum number of connections in pool (default: 8)
poolConfig.setMaxTotal(50);

// Maximum idle connections (default: 8)
poolConfig.setMaxIdle(20);

// Minimum idle connections (default: 0)
poolConfig.setMinIdle(5);

// Maximum wait time when pool is exhausted (milliseconds, default: -1 infinite)
poolConfig.setMaxWaitMillis(3000);

// Test connection before borrowing
poolConfig.setTestOnBorrow(true);

// Test idle connections
poolConfig.setTestWhileIdle(true);

JedisPool pool = new JedisPool(poolConfig, "localhost", 6379, 5000);

// Always use try-with-resources to return connections
try (Jedis jedis = pool.getResource()) {
    String value = jedis.get("key");
}

System.out.println("Active: " + pool.getNumActive());
System.out.println("Idle: " + pool.getNumIdle());
System.out.println("Waiters: " + pool.getNumWaiters());

# Connect to Redis CLI
redis-cli -h localhost -p 6379

# Check slow queries (commands taking longer than threshold)
SLOWLOG GET 10

# View current slowlog configuration
CONFIG GET slowlog-log-slower-than
CONFIG GET slowlog-max-len

# Check server statistics
INFO stats
INFO commandstats

# Check memory usage
INFO memory

# Monitor commands in real-time (use sparingly in production)
MONITOR

try (Jedis jedis = pool.getResource()) {
    // Get slow log entries
    List<Slowlog> slowlogs = jedis.slowlogGet(10);
    for (Slowlog log : slowlogs) {
        System.out.println("Command: " + log.getArgs());
        System.out.println("Duration: " + log.getExecutionTime() + " microseconds");
    }

    // Get server info
    String info = jedis.info("stats");
    System.out.println(info);
}

// BAD: KEYS blocks Redis and scans entire keyspace
Set<String> keys = jedis.keys("user:*");  // Avoid in production!

// GOOD: SCAN doesn't block Redis
ScanParams scanParams = new ScanParams()
    .match("user:*")
    .count(100);

String cursor = ScanParams.SCAN_POINTER_START;
List<String> allKeys = new ArrayList<>();

do {
    ScanResult<String> scanResult = jedis.scan(cursor, scanParams);
    allKeys.addAll(scanResult.getResult());
    cursor = scanResult.getCursor();
} while (!cursor.equals(ScanParams.SCAN_POINTER_START));

System.out.println("Found keys: " + allKeys.size());

// BAD: SMEMBERS returns entire set (can timeout on large sets)
Set<String> members = jedis.smembers("large_set");

// GOOD: SSCAN iterates without blocking
ScanParams params = new ScanParams().count(100);
String cursor = ScanParams.SCAN_POINTER_START;
List<String> allMembers = new ArrayList<>();

do {
    ScanResult<String> result = jedis.sscan("large_set", cursor, params);
    allMembers.addAll(result.getResult());
    cursor = result.getCursor();
} while (!cursor.equals(ScanParams.SCAN_POINTER_START));

Pipeline pipeline = jedis.pipelined();
for (int i = 0; i < 1000; i++) {
    pipeline.set("key" + i, "value" + i);
}
pipeline.sync();  // Execute all at once

import redis.clients.jedis.exceptions.JedisDataException;

public class RedisHelper {
    private final JedisPool pool;
    private final int maxRetries = 3;
    private final int retryDelayMs = 100;

    public RedisHelper(JedisPool pool) {
        this.pool = pool;
    }

    public String getWithRetry(String key) throws Exception {
        int attempt = 0;
        Exception lastException = null;

        while (attempt < maxRetries) {
            try (Jedis jedis = pool.getResource()) {
                return jedis.get(key);
            } catch (JedisDataException e) {
                if (e.getMessage().contains("Command timed out")) {
                    lastException = e;
                    attempt++;
                    System.err.println("Timeout on attempt " + attempt + "/" + maxRetries);

                    if (attempt < maxRetries) {
                        Thread.sleep(retryDelayMs * attempt);
                    }
                } else {
                    throw e;  // Re-throw other JedisDataException types
                }
            }
        }

        throw new Exception("Failed after " + maxRetries + " retries", lastException);
    }

    // Circuit breaker pattern for production
    public Optional<String> getSafe(String key) {
        try (Jedis jedis = pool.getResource()) {
            String value = jedis.get(key);
            return Optional.ofNullable(value);
        } catch (JedisDataException e) {
            System.err.println("Redis timeout: " + e.getMessage());
            return Optional.empty();  // Fail gracefully
        }
    }
}

# Test basic connectivity
ping redis-host

# Test Redis-specific latency
redis-cli -h redis-host --latency

# Continuous latency monitoring
redis-cli -h redis-host --latency-history

# Latency distribution
redis-cli -h redis-host --latency-dist

# Network intrinsic latency (measures network + OS)
redis-cli -h redis-host --intrinsic-latency 60

try (Jedis jedis = pool.getResource()) {
    long start = System.currentTimeMillis();
    jedis.ping();
    long latency = System.currentTimeMillis() - start;
    System.out.println("Redis latency: " + latency + "ms");

    if (latency > 50) {
        System.err.println("WARNING: High latency detected");
    }
}

# Check current persistence configuration
redis-cli CONFIG GET save
redis-cli CONFIG GET appendonly
redis-cli CONFIG GET appendfsync

# View when last save occurred
redis-cli LASTSAVE
redis-cli INFO persistence

# Disable RDB snapshots
redis-cli CONFIG SET save ""

# Disable AOF
redis-cli CONFIG SET appendonly no

# RDB: Save less frequently
save 900 1
save 300 10
save 60 10000

# AOF: Use everysec instead of always
appendfsync everysec

# Don't fsync during background save/rewrite
no-appendfsync-on-rewrite yes

# Automatic AOF rewrite thresholds
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

try (Jedis jedis = pool.getResource()) {
    String info = jedis.info("persistence");
    System.out.println(info);

    // Check if background save is in progress
    if (info.contains("rdb_bgsave_in_progress:1")) {
        System.out.println("Warning: Background save in progress");
    }
}