Implement maximum connection idle time (MaxConnIdleTime) for pgxpool.

If a connection has been idle for longer than maxConnIdleTime, the health check will destroy it.

pgxpool/pool.go

@@ -14,6 +14,7 @@ import (
 
 var defaultMaxConns = int32(4)
 var defaultMaxConnLifetime = time.Hour
+var defaultMaxConnIdleTime = time.Minute * 30
 var defaultHealthCheckPeriod = time.Minute
 
 type connResource struct {
@@ -71,6 +72,7 @@ type Pool struct {
 	beforeAcquire     func(context.Context, *pgx.Conn) bool
 	afterRelease      func(*pgx.Conn) bool
 	maxConnLifetime   time.Duration
+	maxConnIdleTime   time.Duration
 	healthCheckPeriod time.Duration
 	closeChan         chan struct{}
 }
@@ -92,9 +94,12 @@ type Config struct {
 	// return the connection to the pool or false to destroy the connection.
 	AfterRelease func(*pgx.Conn) bool
 
-	// MaxConnLifetime is the duration after which a connection will be automatically closed.
+	// MaxConnLifetime is the duration since creation after which a connection will be automatically closed.
 	MaxConnLifetime time.Duration
 
+	// MaxConnIdleTime is the duration after which an idle connection will be automatically closed by the health check.
+	MaxConnIdleTime time.Duration
+
 	// MaxConns is the maximum size of the pool.
 	MaxConns int32
 
@@ -129,6 +134,7 @@ func ConnectConfig(ctx context.Context, config *Config) (*Pool, error) {
 		beforeAcquire:     config.BeforeAcquire,
 		afterRelease:      config.AfterRelease,
 		maxConnLifetime:   config.MaxConnLifetime,
+		maxConnIdleTime:   config.MaxConnIdleTime,
 		healthCheckPeriod: config.HealthCheckPeriod,
 		closeChan:         make(chan struct{}),
 	}
@@ -233,6 +239,17 @@ func ParseConfig(connString string) (*Config, error) {
 		config.MaxConnLifetime = defaultMaxConnLifetime
 	}
 
+	if s, ok := config.ConnConfig.Config.RuntimeParams["pool_max_conn_idle_time"]; ok {
+		delete(connConfig.Config.RuntimeParams, "pool_max_conn_idle_time")
+		d, err := time.ParseDuration(s)
+		if err != nil {
+			return nil, errors.Errorf("invalid pool_max_conn_idle_time: %w", err)
+		}
+		config.MaxConnIdleTime = d
+	} else {
+		config.MaxConnIdleTime = defaultMaxConnIdleTime
+	}
+
 	if s, ok := config.ConnConfig.Config.RuntimeParams["pool_health_check_period"]; ok {
 		delete(connConfig.Config.RuntimeParams, "pool_health_check_period")
 		d, err := time.ParseDuration(s)
@@ -275,8 +292,10 @@ func (p *Pool) checkIdleConnsHealth() {
 	for _, res := range resources {
 		if now.Sub(res.CreationTime()) > p.maxConnLifetime {
 			res.Destroy()
+		} else if res.IdleDuration() > p.maxConnIdleTime {
+			res.Destroy()
 		} else {
-			res.Release()
+			res.ReleaseUnused()
 		}
 	}
 }

pgxpool/pool_test.go

@@ -253,6 +253,29 @@ func TestPoolBackgroundChecksMaxConnLifetime(t *testing.T) {
 	assert.EqualValues(t, 0, stats.TotalConns())
 }
 
+func TestPoolBackgroundChecksMaxConnIdleTime(t *testing.T) {
+	t.Parallel()
+
+	config, err := pgxpool.ParseConfig(os.Getenv("PGX_TEST_DATABASE"))
+	require.NoError(t, err)
+
+	config.MaxConnLifetime = 1 * time.Minute
+	config.MaxConnIdleTime = 100 * time.Millisecond
+	config.HealthCheckPeriod = 150 * time.Millisecond
+
+	db, err := pgxpool.ConnectConfig(context.Background(), config)
+	require.NoError(t, err)
+	defer db.Close()
+
+	c, err := db.Acquire(context.Background())
+	require.NoError(t, err)
+	c.Release()
+	time.Sleep(config.HealthCheckPeriod + 50*time.Millisecond)
+
+	stats := db.Stat()
+	assert.EqualValues(t, 0, stats.TotalConns())
+}
+
 func TestPoolExec(t *testing.T) {
 	t.Parallel()