Hi, node-redis DOES support sentinel, im using it! With the old cache handler we did have to use ioredis , this is not the case anymore!
here is my example, grab it if you wish, but i can add my old iroedis solution to #154 too in case you rather use that.

Anyway my first iteration with sentinel (i'm sharing some of my other custom functions too):

import fs from 'fs';
import path from 'path';
import { createSentinel, createClient as createRedisClient } from 'redis';

const isProduction = process.env.NODE_ENV === 'production';

export const getBuildId = () => {
	if (!isProduction) {
		return '';
	}
	const buildIdPath = path.join(process.cwd(), '.next', 'BUILD_ID');
	return fs.readFileSync(buildIdPath, 'utf8').trim();
};

export const keyPrefix = process.env.APP_NAME + ':' + getBuildId() + ':';
const sharedTagsKey = '__custom_sharedTags__';


/**
 * @fortedigital uses Single Connection Mode, but we cannot for sentinel setups:
 * Single Connection Mode assumes the client stays valid forever.
 * If Sentinel switches the master, that connection becomes stale,
 * and you never reconnect unless you manually reset global state.
 * Sentinel = dynamic master → Single Connection Mode is fragile.
 * So we use reconnect logic in createClient function.
 */
let client;
let reconnecting = false;

export const createClient = async () => {
	try {
		if (!client) {
			if (process.env.CACHE_DRIVER === 'redis-sentinel-cache') {
				// Sentinel configuration
				client = createSentinel({
					name: 'mymaster', // The name of your Redis master
					sentinelRootNodes: [{ host: process.env.REDIS_HOST, port: Number(process.env.REDIS_PORT) }],
					nodeClientOptions: {
						database: process.env.REDIS_CACHE_DATABASE,
						// Ping interval to keep the connection alive
						pingInterval: 10000,
					},
				});
			} else {
				// Standard Redis configuration
				client = createRedisClient({
					socket: {
						host: process.env.REDIS_HOST,
						port: Number(process.env.REDIS_PORT),
					},
					database: process.env.REDIS_CACHE_DATABASE,
					// Ping interval to keep the connection alive
					pingInterval: 10000,
				});
			}

			client.on('error', (error) => {
				if (process.env.NEXT_PRIVATE_DEBUG_CACHE !== undefined) {
					console.error('Redis client error:', error);
				}
			});

			client.on('end', async () => {
				if (!reconnecting) {
					reconnecting = true;
					console.warn('Redis connection ended. Attempting to reconnect...');
					try {
						await connectWithRetry();
					} catch (err) {
						console.error('Redis reconnection failed:', err);
					} finally {
						reconnecting = false;
					}
				}
			});

			client.on('ready', () => {
				console.info('Redis client is ready.');
			});
			console.info('Connecting Redis client...');
			await connectWithRetry();
		} else {
			if (!client.isReady) {
				console.info('Reconnecting Redis client...');
				await connectWithRetry();
			}
		}
	} catch (error) {
		console.warn('Failed to connect Redis client:', error);
		if (client) {
			try {
				client.destroy();
			} catch (error) {
				console.error('Failed to quit the Redis client after failing to connect.', error);
			}
		}
	}
	return client;
};

async function connectWithRetry(maxRetries = 5, delay = 1000) {
	if (client.isReady) {
		return;
	}

	// Check if already connecting
	if (client?.isOpen) {
		console.log('Redis client socket already open, waiting for ready state...');
		// Wait for ready state
		for (let i = 0; i < 10; i++) {
			if (client.isReady) return;
			await new Promise((res) => setTimeout(res, 500));
		}
		throw new Error('Client opened but never became ready');
	}

	for (let attempt = 1; attempt <= maxRetries; attempt++) {
		try {
			await client.connect();
			await client.ping(); // sanity check
			return;
		} catch (err) {
			console.warn(`Redis reconnect attempt ${attempt} failed:`, err);
			if (attempt === maxRetries) throw err;
			await new Promise((res) => setTimeout(res, delay * attempt)); // exponential backoff
		}
	}
}

function assertClientIsReady(client) {
	if (!client || !client.isReady) {
		throw new Error('Redis client is not ready yet or connection is lost. Keep trying...');
	}
}

// expireAt is in seconds
export const setData = async (key, value, expireAt, tags = []) => {
	try {
		const client = await createClient();
		assertClientIsReady(client);
		const setOperation = client.set(keyPrefix + key, JSON.stringify(value));
		const expireOperation = expireAt ? client.expireAt(keyPrefix + key, Math.floor((Date.now() + expireAt * 1000) / 1000)) : undefined;
		const setTagsOperation = tags.length > 0 ? client.hSet(keyPrefix + sharedTagsKey, key, JSON.stringify(tags)) : undefined;
		await Promise.all([setOperation, expireOperation, setTagsOperation]);
		return { message: 'Data saved successfully: key: ' + key + ' value: ' + value };
	} catch (error) {
		console.error('Error saving data:', error);
		return { errorRsp: 'Error saving data.' };
	}
};

export const getData = async (key) => {
	try {
		const client = await createClient();
		assertClientIsReady(client);
		const result = await client.get(keyPrefix + key);
		if (!result) {
			return null;
		}
		return JSON.parse(result);
	} catch (error) {
		console.error('Error retrieving data:', error);
		return null;
	}
};

export const dataExists = async (key) => {
	try {
		const client = await createClient();
		assertClientIsReady(client);
		const exists = await client.exists(keyPrefix + key);
		return exists === 1;
	} catch (error) {
		console.error('Error checking key existence:', error);
		return false;
	}
};

export const deleteData = async (key) => {
	try {
		const client = await createClient();
		assertClientIsReady(client);
		const result = await client.unlink(keyPrefix + key);
		if (result === 0) {
			console.log('Key not found');
			return false;
		}
		console.log('Data deleted successfully');
		return true;
	} catch (error) {
		console.error('Error deleting datae:', error);
		return false;
	}
};

Support createSentinel #51

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions