How to fix MaxRetriesPerRequestError: Reached the max retries per request limit (which is 20). Refer to "maxRetriesPerRequest" option for details. in Redis

# Test Redis connectivity
redis-cli -h your-redis-host -p 6379 ping

# Should return: PONG

# Check if Redis is running (local)
sudo systemctl status redis

# Or check Redis logs
sudo tail -f /var/log/redis/redis-server.log

# Start Redis service
sudo systemctl start redis

# Or if using Docker
docker start redis-container

# Test TCP connection to Redis port
telnet your-redis-host 6379

# Or use nc (netcat)
nc -zv your-redis-host 6379

# Check if firewall is blocking the port
sudo ufw status
sudo iptables -L -n | grep 6379

import Redis from 'ioredis';

const redis = new Redis({
  host: 'your-redis-host',
  port: 6379,
  maxRetriesPerRequest: 50, // Increased from default 20
  retryStrategy(times) {
    const delay = Math.min(times * 200, 2000);
    return delay;
  },
});

import Redis from 'ioredis';

const redis = new Redis({
  host: 'your-redis-host',
  port: 6379,
  maxRetriesPerRequest: null, // Wait forever until connection restored
  retryStrategy(times) {
    const delay = Math.min(times * 200, 2000);
    return delay;
  },
});

import Redis from 'ioredis';

const redis = new Redis({
  host: 'your-redis-host',
  port: 6379,
  maxRetriesPerRequest: 20,
});

async function setWithRetry(key: string, value: string, maxAttempts = 3) {
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      await redis.set(key, value);
      return; // Success
    } catch (error) {
      if (error.name === 'MaxRetriesPerRequestError') {
        console.error(`Attempt ${attempt}/${maxAttempts} failed: Redis unavailable`);

        if (attempt === maxAttempts) {
          // Final attempt failed - log to monitoring, use fallback
          throw new Error('Redis persistently unavailable');
        }

        // Wait before retrying
        await new Promise(resolve => setTimeout(resolve, 2000 * attempt));
      } else {
        throw error; // Re-throw non-retry errors
      }
    }
  }
}

import Redis from 'ioredis';

const redis = new Redis({
  host: 'your-redis-host',
  port: 6379,
  maxRetriesPerRequest: 30,
  retryStrategy(times) {
    // Stop retrying after 100 total connection attempts
    if (times > 100) {
      console.error('Max connection retries exceeded');
      return null; // Stop retrying
    }

    // Exponential backoff: 200ms, 400ms, 800ms, max 5000ms
    const delay = Math.min(times * 200, 5000);
    console.log(`Retry attempt ${times}, waiting ${delay}ms`);
    return delay;
  },
});

// Listen to connection events
redis.on('connect', () => console.log('Redis connected'));
redis.on('ready', () => console.log('Redis ready to accept commands'));
redis.on('error', (err) => console.error('Redis error:', err));
redis.on('close', () => console.log('Redis connection closed'));
redis.on('reconnecting', (delay) => console.log(`Reconnecting in ${delay}ms`));

import Redis, { Cluster } from 'ioredis';

// For Redis Cluster
const cluster = new Cluster(
  [
    { host: 'redis-node-1', port: 6379 },
    { host: 'redis-node-2', port: 6379 },
  ],
  {
    redisOptions: {
      maxRetriesPerRequest: 20,
    },
    clusterRetryStrategy(times) {
      return Math.min(100 * times, 2000);
    },
  }
);

// For single Redis with connection pooling
class RedisPool {
  private connections: Redis[] = [];
  private poolSize: number;

  constructor(config: any, poolSize = 10) {
    this.poolSize = poolSize;
    for (let i = 0; i < poolSize; i++) {
      this.connections.push(new Redis(config));
    }
  }

  getConnection(): Redis {
    return this.connections[Math.floor(Math.random() * this.poolSize)];
  }
}

const pool = new RedisPool({
  host: 'your-redis-host',
  port: 6379,
  maxRetriesPerRequest: 20,
}, 10);