How to fix TimeoutError: Timeout reading from socket (redis-py) in Redis

import redis

# Set socket_timeout to 5 seconds (default is often too low)
r = redis.Redis(
    host="localhost",
    port=6379,
    socket_timeout=5,  # seconds
    socket_connect_timeout=5,  # connection timeout
    decode_responses=True
)

try:
    result = r.get("mykey")
except redis.TimeoutError:
    print("Command timed out")

import redis

r = redis.Redis(
    host="localhost",
    port=6379,
    socket_timeout=5,
    socket_keepalive=True,
    socket_keepalive_options={
        1: 1,  # TCP_KEEPIDLE: start keep-alive after 1 second
        2: 1,  # TCP_KEEPINTVL: send keep-alive probes every 1 second
        3: 2,  # TCP_KEEPCNT: close after 2 failed probes
    },
    decode_responses=True
)

import redis
from redis.retry import Retry
from redis.backoff import ExponentialBackoff
from redis.exceptions import TimeoutError, ConnectionError

r = redis.Redis(
    host="localhost",
    port=6379,
    socket_timeout=5,
    retry=Retry(
        ExponentialBackoff(cap=10, base=1), 
        retries=25  # retry up to 25 times
    ),
    retry_on_error=[
        ConnectionError,
        TimeoutError,
        ConnectionResetError,
    ],
    health_check_interval=1,
    decode_responses=True
)

# Automatically retries with exponential backoff on timeout
result = r.get("mykey")

import redis

r = redis.Redis(
    host="localhost",
    port=6379,
    socket_timeout=30,  # socket timeout: 30 seconds
    decode_responses=True
)

# Command timeout (20s) is shorter than socket_timeout (30s)
# This prevents TimeoutError from socket_timeout firing during blocking wait
result = r.blpop("myqueue", timeout=20)

# Check Redis response time and memory usage
redis-cli --latency
redis-cli info stats | grep total_commands_processed
redis-cli info memory | grep used_memory_human

# In Python, measure Redis latency
import redis
import time

r = redis.Redis(host="localhost", port=6379)

start = time.time()
for _ in range(1000):
    r.ping()
latency = (time.time() - start) / 1000
print(f"Average latency: {latency*1000:.2f}ms")

import redis

# Main client for non-blocking operations
r = redis.Redis(
    host="localhost",
    port=6379,
    socket_timeout=5,  # short timeout
    decode_responses=True
)

# Dedicated client for blocking operations (no timeout)
blocking_r = redis.Redis(
    host="localhost",
    port=6379,
    socket_timeout=None,  # no socket timeout
    decode_responses=True
)

# Non-blocking commands
value = r.get("key")

# Blocking commands (won't be interrupted by socket timeout)
result = blocking_r.blpop("queue", timeout=300)