Client Tuning And Diagnostics

import redis

pool = redis.ConnectionPool(
    host="endpoint.cache.amazonaws.com",
    port=6379,
    ssl=True,
    socket_connect_timeout=5,    # seconds, TCP + TLS handshake
    socket_timeout=2,            # seconds, per-command timeout
    retry_on_timeout=True,
    health_check_interval=15,    # seconds, sends PING on idle connections
)
r = redis.Redis(connection_pool=pool)

const Redis = require("ioredis");

const client = new Redis({
  host: "endpoint.cache.amazonaws.com",
  port: 6379,
  tls: {},
  connectTimeout: 5000,         // ms, TCP + TLS handshake
  commandTimeout: 2000,         // ms, per-command timeout
  maxRetriesPerRequest: 3,
  retryStrategy(times) {
    return Math.min(times * 200, 2000);  // ms, exponential backoff capped at 2s
  },
});

// Socket connect timeout should be lower than command timeout for Lettuce.
// Set JVM DNS cache TTL to support failover DNS changes.
java.security.Security.setProperty("networkaddress.cache.ttl", "10");

RedisURI uri = RedisURI.builder()
    .withHost("endpoint.cache.amazonaws.com")
    .withPort(6379)
    .withSsl(true)
    .withTimeout(Duration.ofMillis(2000))   // per-command timeout
    .build();

ClientResources clientResources = DefaultClientResources.builder()
    .addressResolverGroup(new DirContextDnsResolver())
    .reconnectDelay(
        Delay.fullJitter(
            Duration.ofMillis(100),
            Duration.ofSeconds(10),
            100, TimeUnit.MILLISECONDS))
    .build();

ClientOptions options = ClientOptions.builder()
    .socketOptions(SocketOptions.builder()
        .connectTimeout(Duration.ofMillis(5000))  // TCP + TLS handshake; match table guidance of 2-5s
        .keepAlive(true)
        .build())
    .timeoutOptions(TimeoutOptions.builder()
        .fixedTimeout(Duration.ofMillis(2000))
        .build())
    .build();

RedisClient client = RedisClient.create(clientResources, uri);
client.setOptions(options);

client := redis.NewClient(&redis.Options{
    Addr:         "endpoint.cache.amazonaws.com:6379",
    TLSConfig:    &tls.Config{},
    DialTimeout:  5 * time.Second,   // TCP + TLS handshake
    ReadTimeout:  2 * time.Second,   // per-command read
    WriteTimeout: 2 * time.Second,   // per-command write
    MaxRetries:   3,
    MinRetryBackoff: 100 * time.Millisecond,
    MaxRetryBackoff: 2 * time.Second,
})

pool = redis.ConnectionPool(
    host="endpoint.cache.amazonaws.com",
    port=6379,
    ssl=True,
    max_connections=50,
)
r = redis.Redis(connection_pool=pool)
# In async frameworks (FastAPI, aiohttp), use redis.asyncio.ConnectionPool instead.

// ioredis manages a single persistent connection by default.
// For cluster mode, it opens one connection per node.
// For concurrency, ioredis pipelines commands over the single connection.
// If you need multiple connections (rare), use a manual pool or ioredis Cluster.
const cluster = new Redis.Cluster(
  [{ host: "endpoint.cache.amazonaws.com", port: 6379 }],
  {
    slotsRefreshTimeout: 2000,
    dnsLookup: (address, callback) => callback(null, address),
    redisOptions: { tls: {} },
    scaleReads: "slave",  // read from replicas
  }
);

// Lettuce uses a single connection with pipelining by default.
// For thread-safe concurrent access, use StatefulRedisConnection (thread-safe)
// or GenericObjectPool for connection pooling:
GenericObjectPoolConfig<StatefulRedisConnection<String, String>> poolConfig =
    new GenericObjectPoolConfig<>();
poolConfig.setMaxTotal(50);
poolConfig.setMaxIdle(20);
poolConfig.setMinIdle(5);
poolConfig.setTestOnBorrow(true);

ClusterTopologyRefreshOptions topologyOptions = ClusterTopologyRefreshOptions.builder()
    .enableAllAdaptiveRefreshTriggers()
    .enablePeriodicRefresh()
    .dynamicRefreshSources(true)
    .build();

ClusterClientOptions clusterOptions = ClusterClientOptions.builder()
    .topologyRefreshOptions(topologyOptions)
    .nodeFilter(it ->
        !(it.is(RedisClusterNode.NodeFlag.FAIL)
        || it.is(RedisClusterNode.NodeFlag.EVENTUAL_FAIL)
        || it.is(RedisClusterNode.NodeFlag.NOADDR)))
    .validateClusterNodeMembership(false)
    .build();

RedisClusterClient clusterClient = RedisClusterClient.create(clientResources, redisUri);
clusterClient.setOptions(clusterOptions);

client := redis.NewClient(&redis.Options{
    Addr:         "endpoint.cache.amazonaws.com:6379",
    TLSConfig:    &tls.Config{},
    PoolSize:     50,           // max connections in pool
    MinIdleConns: 5,            // keep warm connections ready
    PoolTimeout:  3 * time.Second,  // wait for free connection
    ConnMaxIdleTime: 5 * time.Minute,
})

# List available metrics for a serverless cache
aws cloudwatch list-metrics \
  --namespace AWS/ElastiCache \
  --dimensions Name=ServerlessCacheName,Value=<cache-name> \
  --region <region>

# List available metrics for a node-based cache
aws cloudwatch list-metrics \
  --namespace AWS/ElastiCache \
  --dimensions Name=ReplicationGroupId,Value=<replication-group-id> \
  --region <region>