JonCole · October 29, 2024 17:54 · danlarson · May 21, 2020 · JonCole · May 21, 2020
diff --git a/Redis-BestPractices-General.md b/Redis-BestPractices-General.md
diff --git a/Redis-BestPractices-Java-Jedis.md b/Redis-BestPractices-Java-Jedis.md
diff --git a/Redis-BestPractices-Node-js.md b/Redis-BestPractices-Node-js.md
diff --git a/Redis-BestPractices-PHP.md b/Redis-BestPractices-PHP.md
diff --git a/Redis-BestPractices-Session-State-Provider.md b/Redis-BestPractices-Session-State-Provider.md
diff --git a/Redis-BestPractices-StackExchange-Redis.md b/Redis-BestPractices-StackExchange-Redis.md
diff --git a/Redis-LazyReconnect.cs b/Redis-LazyReconnect.cs
 using System;
 using System.Threading;
 using StackExchange.Redis;

 // Source Code Usage License: https://gist.github.com/JonCole/34ca1d2698da7a1aa65ff781c37ecdea
 static class Redis
 {
    static long lastReconnectTicks = DateTimeOffset.MinValue.UtcTicks;
    static DateTimeOffset firstError = DateTimeOffset.MinValue;
    static DateTimeOffset previousError = DateTimeOffset.MinValue;

    static object reconnectLock = new object();

    // In general, let StackExchange.Redis handle most reconnects, 
    // so limit the frequency of how often this will actually reconnect.
    public static TimeSpan ReconnectMinFrequency = TimeSpan.FromSeconds(60);

    // if errors continue for longer than the below threshold, then the 
    // multiplexer seems to not be reconnecting, so re-create the multiplexer
    public static TimeSpan ReconnectErrorThreshold = TimeSpan.FromSeconds(30);

    static string connectionString = "TODO: CALL InitializeConnectionString() method with connection string";
    static Lazy<ConnectionMultiplexer> multiplexer = CreateMultiplexer();

    public static ConnectionMultiplexer Connection { get { return multiplexer.Value; } }

    public static void InitializeConnectionString(string cnxString)
    {
        if (string.IsNullOrWhiteSpace(cnxString))
            throw new ArgumentNullException(nameof(cnxString));

        connectionString = cnxString;
    }

    /// <summary>
    /// Force a new ConnectionMultiplexer to be created.  
    /// NOTES: 
    ///     1. Users of the ConnectionMultiplexer MUST handle ObjectDisposedExceptions, which can now happen as a result of calling ForceReconnect()
    ///     2. Don't call ForceReconnect for Timeouts, just for RedisConnectionExceptions or SocketExceptions
    ///     3. Call this method every time you see a connection exception, the code will wait to reconnect:
    ///         a. for at least the "ReconnectErrorThreshold" time of repeated errors before actually reconnecting
    ///         b. not reconnect more frequently than configured in "ReconnectMinFrequency"

    /// </summary>    
    public static void ForceReconnect()
    {
        var utcNow = DateTimeOffset.UtcNow;
        var previousTicks = Interlocked.Read(ref lastReconnectTicks);
        var previousReconnect = new DateTimeOffset(previousTicks, TimeSpan.Zero);
        var elapsedSinceLastReconnect = utcNow - previousReconnect;

        // If mulitple threads call ForceReconnect at the same time, we only want to honor one of them.
        if (elapsedSinceLastReconnect > ReconnectMinFrequency)
        {
            lock (reconnectLock)
            {
                utcNow = DateTimeOffset.UtcNow;
                elapsedSinceLastReconnect = utcNow - previousReconnect;

                if (firstError == DateTimeOffset.MinValue)
                {
                    // We haven't seen an error since last reconnect, so set initial values.
                    firstError = utcNow;
                    previousError = utcNow;
                    return;
                }

                if (elapsedSinceLastReconnect < ReconnectMinFrequency)
                    return; // Some other thread made it through the check and the lock, so nothing to do.

                var elapsedSinceFirstError = utcNow - firstError;
                var elapsedSinceMostRecentError = utcNow - previousError;

                var shouldReconnect =
                    elapsedSinceFirstError >= ReconnectErrorThreshold   // make sure we gave the multiplexer enough time to reconnect on its own if it can
                    && elapsedSinceMostRecentError <= ReconnectErrorThreshold; //make sure we aren't working on stale data (e.g. if there was a gap in errors, don't reconnect yet).

                // Update the previousError timestamp to be now (e.g. this reconnect request)
                previousError = utcNow;

                if (shouldReconnect)
                {
                    firstError = DateTimeOffset.MinValue;
                    previousError = DateTimeOffset.MinValue;

                    var oldMultiplexer = multiplexer;
                    CloseMultiplexer(oldMultiplexer);
                    multiplexer = CreateMultiplexer();
                    Interlocked.Exchange(ref lastReconnectTicks, utcNow.UtcTicks);
                }
            }
        }
    }

    private static Lazy<ConnectionMultiplexer> CreateMultiplexer()
    {
        return new Lazy<ConnectionMultiplexer>(() => ConnectionMultiplexer.Connect(connectionString));
    }

    private static void CloseMultiplexer(Lazy<ConnectionMultiplexer> oldMultiplexer)
    {
        if (oldMultiplexer != null)
        {
            try
            {
                oldMultiplexer.Value.Close();
            }
            catch (Exception)
            {
                // Example error condition: if accessing old.Value causes a connection attempt and that fails.
            }
        }
    }
 }
diff --git a/Redis-SampleCode-Java-JedisPool.java b/Redis-SampleCode-Java-JedisPool.java
 import javax.net.ssl.HostnameVerifier;
 import javax.net.ssl.SSLPeerUnverifiedException;
 import javax.net.ssl.SSLSession;
 import redis.clients.jedis.*;
 import javax.net.ssl.*;

 // Source Code Usage License: https://gist.github.com/JonCole/34ca1d2698da7a1aa65ff781c37ecdea
 public class Redis {
    private static Object staticLock = new Object();
    private static JedisPool pool;
    private static String host;
    private static int port; // 6379 for NonSSL, 6380 for SSL
    private static int connectTimeout; //milliseconds
    private static int operationTimeout; //milliseconds
    private static String password;
    private static JedisPoolConfig config;

    // Should be called exactly once during App Startup logic.
    public static void initializeSettings(String host, int port, String password, int connectTimeout, int operationTimeout) {
        Redis.host = host;
        Redis.port = port;
        Redis.password = password;
        Redis.connectTimeout = connectTimeout;
        Redis.operationTimeout = operationTimeout;
    }

    // MAKE SURE to call the initializeSettings method first
    public static JedisPool getPoolInstance() {
        if (pool == null) { // avoid synchronization lock if initialization has already happened
            synchronized(staticLock) {
                if (pool == null) { // don't re-initialize if another thread beat us to it.
                    JedisPoolConfig poolConfig = getPoolConfig();
                    boolean useSsl = port == 6380 ? true : false;
                    int db = 0;
                    String clientName = "MyClientName"; // null means use default
                    SSLSocketFactory sslSocketFactory = null; // null means use default
                    SSLParameters sslParameters = null; // null means use default
                    HostnameVerifier hostnameVerifier = new SimpleHostNameVerifier(host);
                    pool = new JedisPool(poolConfig, host, port, connectTimeout,operationTimeout,password, db,
                            clientName, useSsl, sslSocketFactory, sslParameters, hostnameVerifier);
                }
            }
        }
        return pool;
    }

    public static JedisPoolConfig getPoolConfig() {
        if (config == null) {
            JedisPoolConfig poolConfig = new JedisPoolConfig();

            // Each thread trying to access Redis needs its own Jedis instance from the pool.
            // Using too small a value here can lead to performance problems, too big and you have wasted resources.
            int maxConnections = 200;
            poolConfig.setMaxTotal(maxConnections);
            poolConfig.setMaxIdle(maxConnections);

            // Using "false" here will make it easier to debug when your maxTotal/minIdle/etc settings need adjusting.
            // Setting it to "true" will result better behavior when unexpected load hits in production
            poolConfig.setBlockWhenExhausted(true);

            // How long to wait before throwing when pool is exhausted
            poolConfig.setMaxWaitMillis(operationTimeout);

            // This controls the number of connections that should be maintained for bursts of load.
            // Increase this value when you see pool.getResource() taking a long time to complete under burst scenarios
            poolConfig.setMinIdle(50);

            Redis.config = poolConfig;
        }

        return config;
    }

    public static String getPoolCurrentUsage()
    {
        JedisPool jedisPool = getPoolInstance();
        JedisPoolConfig poolConfig = getPoolConfig();

        int active = jedisPool.getNumActive();
        int idle = jedisPool.getNumIdle();
        int total = active + idle;
        String log = String.format(
                "JedisPool: Active=%d, Idle=%d, Waiters=%d, total=%d, maxTotal=%d, minIdle=%d, maxIdle=%d",
                active,
                idle,
                jedisPool.getNumWaiters(),
                total,
                poolConfig.getMaxTotal(),
                poolConfig.getMinIdle(),
                poolConfig.getMaxIdle()
        );

        return log;
    }

    private static class SimpleHostNameVerifier implements HostnameVerifier {

        private String exactCN;
        private String wildCardCN;
        public SimpleHostNameVerifier(String cacheHostname)
        {
            exactCN = "CN=" + cacheHostname;
            wildCardCN = "CN=*" + cacheHostname.substring(cacheHostname.indexOf('.'));
        }

        public boolean verify(String s, SSLSession sslSession) {
            try {
                String cn = sslSession.getPeerPrincipal().getName();
                return cn.equalsIgnoreCase(wildCardCN) || cn.equalsIgnoreCase(exactCN);
            } catch (SSLPeerUnverifiedException ex) {
                return false;
            }
        }
    }
 }
Setting	Description
connectTimeout	How long to allow for new connections to be established (in milliseconds). In general, this should be at least 5000ms. If your client application tends to have high spikes CPU usage, setting this to 15000ms or 20000ms would be a good idea.
soTimeout	This configures the socket timeout (in milliseconds) for the underlying connection. You can basically think of this as the operation timeout (how long you are willing to wait for a response from Redis). Think about this one in terms of worst case, not best case. Setting this too low can cause you to get timeout errors due to unexpected bursts in load. I typically recommend 1000ms as a good value for most customers.
port	In Azure, 6379 is non-ssl and 6380 is SSL/TLS. Important Note: 6379 is disabled by default - you have to explicitly enable this insecure port if you wish to use it.
Setting	Description
maxTotal	This setting controls the max number of connections that can be created at a given time. Given that Jedis connections cannot be shared across threads, this setting affects the amount of concurrency your application can have when talking to Redis. Note that each connection does have some memory and CPU overhead, so setting this to a very high value may have negative side effects. If not set, the default value is 8, which is probably too low for most applications. When chosing a value, consider how many concurrent calls into Redis you think you will have under load.
maxIdle	This is the max number of connections that can be idle in the pool without being immediately evicted (closed). If not set, the default value is 8. I would recommend that this setting be configured the same as maxTotal to help avoid connection ramp-up costs when your application has many bursts of load in a short period of time. If a connection is idle for a long time, it will still be evicted until the idle connection count hits minIdle (described below).
minIdle	This is the number of "warm" connections (e.g. ready for immediate use) that remain in the pool even when load has reduced. If not set, the default is 0. When choosing a value, consider your steady-state concurrent requests to Redis. For instance, if your application is calling into Redis from 10 threads simultaneously, then you should set this to at least 10 (probably a bit higher to give you some room.
blockWhenExhausted	This controls behavior when a thread asks for a connection, but there aren't any that are free and the pool can't create more (due to maxTotal). If set to true, the calling thread will block for maxWaitMillis before throwing an exception. The default is true and I recommend true for production environments. You could set it to false in testing environments to help you more easily discover what value to use for maxTotal.
maxWaitMillis	How long to wait in milliseconds if calling JedisPool.getResource() will block. The default is -1, which means block indefinitely. I would set this to the same as the socketTimeout configured. Related to blockWhenExhausted.
TestOnBorrow	Controls whether or not the connection is tested before it is returned from the pool. The default is false. Setting to true may increase resilience to connection blips but may also have a performance cost when taking connections from the pool. In my quick testing, I saw a noticable increase in the 50th percentile latencies, but no significant increase in 98th percentile latencies.
minEvictableIdleTimeMillis	This specifies the minimum amount of time an connection may sit idle in the pool before it is eligible for eviction due to idle time. The default value is 60 seconds for `JedisPoolConfig`, and 30 minutes if you construct a configuration with `GenericObjectPoolConfig`. Azure Redis currently has 10 minute idle timeout for connections, so this should be set to less than 10 minutes
	using System;
	using System.Threading;
	using StackExchange.Redis;

	// Source Code Usage License: https://gist.github.com/JonCole/34ca1d2698da7a1aa65ff781c37ecdea
	static class Redis
	{
	static long lastReconnectTicks = DateTimeOffset.MinValue.UtcTicks;
	static DateTimeOffset firstError = DateTimeOffset.MinValue;
	static DateTimeOffset previousError = DateTimeOffset.MinValue;

	static object reconnectLock = new object();

	// In general, let StackExchange.Redis handle most reconnects,
	// so limit the frequency of how often this will actually reconnect.
	public static TimeSpan ReconnectMinFrequency = TimeSpan.FromSeconds(60);

	// if errors continue for longer than the below threshold, then the
	// multiplexer seems to not be reconnecting, so re-create the multiplexer
	public static TimeSpan ReconnectErrorThreshold = TimeSpan.FromSeconds(30);

	static string connectionString = "TODO: CALL InitializeConnectionString() method with connection string";
	static Lazy<ConnectionMultiplexer> multiplexer = CreateMultiplexer();

	public static ConnectionMultiplexer Connection { get { return multiplexer.Value; } }

	public static void InitializeConnectionString(string cnxString)
	{
	if (string.IsNullOrWhiteSpace(cnxString))
	throw new ArgumentNullException(nameof(cnxString));

	connectionString = cnxString;
	}

	/// <summary>
	/// Force a new ConnectionMultiplexer to be created.
	/// NOTES:
	/// 1. Users of the ConnectionMultiplexer MUST handle ObjectDisposedExceptions, which can now happen as a result of calling ForceReconnect()
	/// 2. Don't call ForceReconnect for Timeouts, just for RedisConnectionExceptions or SocketExceptions
	/// 3. Call this method every time you see a connection exception, the code will wait to reconnect:
	/// a. for at least the "ReconnectErrorThreshold" time of repeated errors before actually reconnecting
	/// b. not reconnect more frequently than configured in "ReconnectMinFrequency"

	/// </summary>
	public static void ForceReconnect()
	{
	var utcNow = DateTimeOffset.UtcNow;
	var previousTicks = Interlocked.Read(ref lastReconnectTicks);
	var previousReconnect = new DateTimeOffset(previousTicks, TimeSpan.Zero);
	var elapsedSinceLastReconnect = utcNow - previousReconnect;

	// If mulitple threads call ForceReconnect at the same time, we only want to honor one of them.
	if (elapsedSinceLastReconnect > ReconnectMinFrequency)
	{
	lock (reconnectLock)
	{
	utcNow = DateTimeOffset.UtcNow;
	elapsedSinceLastReconnect = utcNow - previousReconnect;

	if (firstError == DateTimeOffset.MinValue)
	{
	// We haven't seen an error since last reconnect, so set initial values.
	firstError = utcNow;
	previousError = utcNow;
	return;
	}

	if (elapsedSinceLastReconnect < ReconnectMinFrequency)
	return; // Some other thread made it through the check and the lock, so nothing to do.

	var elapsedSinceFirstError = utcNow - firstError;
	var elapsedSinceMostRecentError = utcNow - previousError;

	var shouldReconnect =
	elapsedSinceFirstError >= ReconnectErrorThreshold // make sure we gave the multiplexer enough time to reconnect on its own if it can
	&& elapsedSinceMostRecentError <= ReconnectErrorThreshold; //make sure we aren't working on stale data (e.g. if there was a gap in errors, don't reconnect yet).

	// Update the previousError timestamp to be now (e.g. this reconnect request)
	previousError = utcNow;

	if (shouldReconnect)
	{
	firstError = DateTimeOffset.MinValue;
	previousError = DateTimeOffset.MinValue;

	var oldMultiplexer = multiplexer;
	CloseMultiplexer(oldMultiplexer);
	multiplexer = CreateMultiplexer();
	Interlocked.Exchange(ref lastReconnectTicks, utcNow.UtcTicks);
	}
	}
	}
	}

	private static Lazy<ConnectionMultiplexer> CreateMultiplexer()
	{
	return new Lazy<ConnectionMultiplexer>(() => ConnectionMultiplexer.Connect(connectionString));
	}

	private static void CloseMultiplexer(Lazy<ConnectionMultiplexer> oldMultiplexer)
	{
	if (oldMultiplexer != null)
	{
	try
	{
	oldMultiplexer.Value.Close();
	}
	catch (Exception)
	{
	// Example error condition: if accessing old.Value causes a connection attempt and that fails.
	}
	}
	}
	}
	import javax.net.ssl.HostnameVerifier;
	import javax.net.ssl.SSLPeerUnverifiedException;
	import javax.net.ssl.SSLSession;
	import redis.clients.jedis.*;
	import javax.net.ssl.*;

	// Source Code Usage License: https://gist.github.com/JonCole/34ca1d2698da7a1aa65ff781c37ecdea
	public class Redis {
	private static Object staticLock = new Object();
	private static JedisPool pool;
	private static String host;
	private static int port; // 6379 for NonSSL, 6380 for SSL
	private static int connectTimeout; //milliseconds
	private static int operationTimeout; //milliseconds
	private static String password;
	private static JedisPoolConfig config;

	// Should be called exactly once during App Startup logic.
	public static void initializeSettings(String host, int port, String password, int connectTimeout, int operationTimeout) {
	Redis.host = host;
	Redis.port = port;
	Redis.password = password;
	Redis.connectTimeout = connectTimeout;
	Redis.operationTimeout = operationTimeout;
	}

	// MAKE SURE to call the initializeSettings method first
	public static JedisPool getPoolInstance() {
	if (pool == null) { // avoid synchronization lock if initialization has already happened
	synchronized(staticLock) {
	if (pool == null) { // don't re-initialize if another thread beat us to it.
	JedisPoolConfig poolConfig = getPoolConfig();
	boolean useSsl = port == 6380 ? true : false;
	int db = 0;
	String clientName = "MyClientName"; // null means use default
	SSLSocketFactory sslSocketFactory = null; // null means use default
	SSLParameters sslParameters = null; // null means use default
	HostnameVerifier hostnameVerifier = new SimpleHostNameVerifier(host);
	pool = new JedisPool(poolConfig, host, port, connectTimeout,operationTimeout,password, db,
	clientName, useSsl, sslSocketFactory, sslParameters, hostnameVerifier);
	}
	}
	}
	return pool;
	}

	public static JedisPoolConfig getPoolConfig() {
	if (config == null) {
	JedisPoolConfig poolConfig = new JedisPoolConfig();

	// Each thread trying to access Redis needs its own Jedis instance from the pool.
	// Using too small a value here can lead to performance problems, too big and you have wasted resources.
	int maxConnections = 200;
	poolConfig.setMaxTotal(maxConnections);
	poolConfig.setMaxIdle(maxConnections);

	// Using "false" here will make it easier to debug when your maxTotal/minIdle/etc settings need adjusting.
	// Setting it to "true" will result better behavior when unexpected load hits in production
	poolConfig.setBlockWhenExhausted(true);

	// How long to wait before throwing when pool is exhausted
	poolConfig.setMaxWaitMillis(operationTimeout);

	// This controls the number of connections that should be maintained for bursts of load.
	// Increase this value when you see pool.getResource() taking a long time to complete under burst scenarios
	poolConfig.setMinIdle(50);

	Redis.config = poolConfig;
	}

	return config;
	}

	public static String getPoolCurrentUsage()
	{
	JedisPool jedisPool = getPoolInstance();
	JedisPoolConfig poolConfig = getPoolConfig();

	int active = jedisPool.getNumActive();
	int idle = jedisPool.getNumIdle();
	int total = active + idle;
	String log = String.format(
	"JedisPool: Active=%d, Idle=%d, Waiters=%d, total=%d, maxTotal=%d, minIdle=%d, maxIdle=%d",
	active,
	idle,
	jedisPool.getNumWaiters(),
	total,
	poolConfig.getMaxTotal(),
	poolConfig.getMinIdle(),
	poolConfig.getMaxIdle()
	);

	return log;
	}

	private static class SimpleHostNameVerifier implements HostnameVerifier {

	private String exactCN;
	private String wildCardCN;
	public SimpleHostNameVerifier(String cacheHostname)
	{
	exactCN = "CN=" + cacheHostname;
	wildCardCN = "CN=*" + cacheHostname.substring(cacheHostname.indexOf('.'));
	}

	public boolean verify(String s, SSLSession sslSession) {
	try {
	String cn = sslSession.getPeerPrincipal().getName();
	return cn.equalsIgnoreCase(wildCardCN) \|\| cn.equalsIgnoreCase(exactCN);
	} catch (SSLPeerUnverifiedException ex) {
	return false;
	}
	}
	}
	}