How to fix ERR timeout reading from client in Redis

# Connect to Redis:
redis-cli

# View recent slow commands:
SLOWLOG GET 10

# Output format:
1) 1) "13547312"
   2) "1698765432"
   3) "5234000"  # Execution time in microseconds
   4) "EVAL"
   5) "..."

# Check the slowlog threshold:
CONFIG GET slowlog-max-len
CONFIG GET slowlog-log-slower-than

# If needed, lower the threshold to catch more slow commands:
CONFIG SET slowlog-log-slower-than 1000  # Log commands slower than 1ms

import { createClient } from 'redis';

const client = createClient({
  host: 'localhost',
  port: 6379,
  socket: {
    connectTimeout: 5000,  // 5 seconds
    timeout: 30000,        // 30 seconds read timeout
  }
});

import redis

client = redis.Redis(
    host='localhost',
    port=6379,
    socket_connect_timeout=5,
    socket_timeout=30  # 30 seconds
)

RedisURI uri = RedisURI.builder()
    .withHost("localhost")
    .withPort(6379)
    .build();
uri.setTimeout(Duration.ofSeconds(30));

-- BEFORE: Slow script that iterates many times
local result = {}
for i = 1, 10000 do
  redis.call('SET', KEYS[1] .. ':' .. i, ARGV[i])
end
return result

-- AFTER: Use pipelining and fewer iterations
local pipeline = {}
for i = 1, 100 do  -- Reduced iterations
  table.insert(pipeline, {'SET', KEYS[1] .. ':' .. i, ARGV[i]})
end
-- Alternatively, move bulk operations to client side

# View current setting:
redis-cli CONFIG GET lua-time-limit
# Default: 5000 (5 seconds)

# Increase to 30 seconds:
redis-cli CONFIG SET lua-time-limit 30000

# To persist across restarts, add to redis.conf:
echo 'lua-time-limit 30000' >> /etc/redis/redis.conf

# Restart Redis:
sudo systemctl restart redis-server

// Node.js example:
async function executeWithRetry(command, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await client.sendCommand(command);
    } catch (error) {
      if (error.message.includes('timeout') && i < maxRetries - 1) {
        const backoff = Math.pow(2, i) * 1000; // 1s, 2s, 4s
        await new Promise(resolve => setTimeout(resolve, backoff));
        continue;
      }
      throw error;
    }
  }
}

// Usage:
try {
  const result = await executeWithRetry(['SET', key, value]);
} catch (error) {
  console.error('Failed after retries:', error);
}

# Check latency from the client:
redis-cli --latency-history  # Run from the Redis server host

# Or use ping to measure round-trip time:
redis-cli PING

# Check for packet loss:
ping -c 100 <redis-host>  # Look for % packet loss

# Monitor network on Redis server:
sudo netstat -an | grep 6379
sudo ss -tuln | grep 6379

# Check for connection timeouts:
sudo iptables -L -n  # Verify firewall rules allow Redis port

# Test from client host:
telnet <redis-host> 6379

# Check if BGSAVE or BGREWRITEAOF are running:
redis-cli INFO persistence

# Look for:
# rdb_bgsave_in_progress:0  (1 = bgsave running)
# aof_rewrite_in_progress:0 (1 = aof rewrite running)

# Check SLOWLOG for persistence-related delays
redis-cli SLOWLOG GET 5

# If snapshots are too frequent, adjust in redis.conf:
# save 900 1      # Save every 15 minutes if 1 key changed
# save 300 10     # Save every 5 minutes if 10 keys changed
# save 60 10000   # Save every 1 minute if 10k keys changed

# Or disable RDB entirely (if using AOF only):
# save ""  # Remove all save lines