ref(redis): Configure min_idle for the Redis pool

relay-config/src/config.rs

@@ -2285,12 +2285,20 @@ impl Config {
 
  let redis = self.values.processing.redis.as_ref()?;
 
+ let max_connections = redis
+ .options
+ .max_connections
+ .unwrap_or(cpu_concurrency as u32 * 2)
+ .max(crate::redis::DEFAULT_MIN_MAX_CONNECTIONS);
+
+ let min_idle = redis
+ .options
+ .min_idle
+ .unwrap_or_else(|| max_connections.div_ceil(crate::redis::DEFAULT_MIN_IDLE_RATIO));
+
  let options = RedisConfigOptions {
- max_connections: redis
- .options
- .max_connections
- .unwrap_or(cpu_concurrency as u32 * 2)
- .min(crate::redis::DEFAULT_MIN_MAX_CONNECTIONS),
+ max_connections,
+ min_idle: Some(min_idle),
  connection_timeout: redis.options.connection_timeout,
  max_lifetime: redis.options.max_lifetime,
  idle_timeout: redis.options.idle_timeout,

relay-config/src/redis.rs

@@ -4,6 +4,13 @@ use serde::{Deserialize, Serialize};
 /// In this case, we fall back to the old default.
 pub(crate) const DEFAULT_MIN_MAX_CONNECTIONS: u32 = 24;
 
+/// By default the `min_idle` count of the Redis pool is set to the calculated
+/// amount of max connections divided by this value and rounded up.
+///
+/// To express this value as a percentage of max connections,
+/// use this formula: `100 / DEFAULT_MIN_IDLE_RATIO`.
+pub(crate) const DEFAULT_MIN_IDLE_RATIO: u32 = 5;
+
 /// Additional configuration options for a redis client.
 #[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
 #[serde(default)]
@@ -13,6 +20,11 @@ pub struct PartialRedisConfigOptions {
  /// Defaults to 2x `limits.max_thread_count` or a minimum of 24.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub max_connections: Option<u32>,
+ /// Minimum amount of idle connections kept alive in the pool.
+ ///
+ /// If not set it will default to 20% of [`Self::max_connections`].
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub min_idle: Option<u32>,
  /// Sets the connection timeout used by the pool, in seconds.
  ///
  /// Calls to `Pool::get` will wait this long for a connection to become available before returning an error.
@@ -31,6 +43,7 @@ impl Default for PartialRedisConfigOptions {
  fn default() -> Self {
  Self {
  max_connections: None,
+ min_idle: None,
  connection_timeout: 5,
  max_lifetime: 300,
  idle_timeout: 60,

relay-redis/src/config.rs

@@ -5,6 +5,10 @@ use serde::{Deserialize, Serialize};
 pub struct RedisConfigOptions {
  /// Maximum number of connections managed by the pool.
  pub max_connections: u32,
+ /// Minimum amount of idle connections kept alive in the pool.
+ ///
+ /// If not set it will default to [`Self::max_connections`].
+ pub min_idle: Option<u32>,
  /// Sets the connection timeout used by the pool, in seconds.
  ///
  /// Calls to `Pool::get` will wait this long for a connection to become available before returning an error.
@@ -23,6 +27,7 @@ impl Default for RedisConfigOptions {
  fn default() -> Self {
  Self {
  max_connections: 24,
+ min_idle: None,
  connection_timeout: 5,
  max_lifetime: 300,
  idle_timeout: 60,

relay-redis/src/real.rs

@@ -151,6 +151,7 @@ impl RedisPool {
  ) -> Result<Self, RedisError> {
  let pool = Pool::builder()
  .max_size(opts.max_connections)
+ .min_idle(opts.min_idle)
  .test_on_check_out(false)
  .max_lifetime(Some(Duration::from_secs(opts.max_lifetime)))
  .idle_timeout(Some(Duration::from_secs(opts.idle_timeout)))
@@ -166,6 +167,7 @@ impl RedisPool {
  pub fn single(server: &str, opts: RedisConfigOptions) -> Result<Self, RedisError> {
  let pool = Pool::builder()
  .max_size(opts.max_connections)
+ .min_idle(opts.min_idle)
  .test_on_check_out(false)
  .max_lifetime(Some(Duration::from_secs(opts.max_lifetime)))
  .idle_timeout(Some(Duration::from_secs(opts.idle_timeout)))