Replace the pool when reopening.

Signed-off-by: Arthur Schreiber <[email protected]>

Author: arthurschreiber

go/pools/smartconnpool/pool.go

@@ -803,58 +803,141 @@ func (pool *ConnPool[C]) StatsJSON() map[string]any {
 	}
 }
 
-// RegisterStats registers this pool's metrics into a stats Exporter
-func (pool *ConnPool[C]) RegisterStats(stats *servenv.Exporter, name string) {
-	if stats == nil || name == "" {
-		return
-	}
+type StatsExporter[C Connection] struct {
+	// The Pool for which this exporter is exporting stats.
+	// It is an atomic pointer so that it can be updated safely.
+	// The pointer is nil if the pool has not been registered yet.
+	pool atomic.Pointer[ConnPool[C]]
+}
 
-	pool.Name = name
+func NewStatsExporter[C Connection](stats *servenv.Exporter, name string) *StatsExporter[C] {
+	se := &StatsExporter[C]{}
 
 	stats.NewGaugeFunc(name+"Capacity", "Tablet server conn pool capacity", func() int64 {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		return pool.Capacity()
 	})
 	stats.NewGaugeFunc(name+"Available", "Tablet server conn pool available", func() int64 {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		return pool.Available()
 	})
 	stats.NewGaugeFunc(name+"Active", "Tablet server conn pool active", func() int64 {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		return pool.Active()
 	})
 	stats.NewGaugeFunc(name+"InUse", "Tablet server conn pool in use", func() int64 {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		return pool.InUse()
 	})
 	stats.NewGaugeFunc(name+"MaxCap", "Tablet server conn pool max cap", func() int64 {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		// the smartconnpool doesn't have a maximum capacity
 		return pool.Capacity()
 	})
 	stats.NewGaugeFunc(name+"IdleAllowed", "Tablet server conn pool idle allowed limit", func() int64 {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		return pool.IdleCount()
 	})
 	stats.NewCounterFunc(name+"WaitCount", "Tablet server conn pool wait count", func() int64 {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		return pool.Metrics.WaitCount()
 	})
 	stats.NewCounterDurationFunc(name+"WaitTime", "Tablet server wait time", func() time.Duration {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		return pool.Metrics.WaitTime()
 	})
 	stats.NewGaugeDurationFunc(name+"IdleTimeout", "Tablet server idle timeout", func() time.Duration {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		return pool.IdleTimeout()
 	})
 	stats.NewCounterFunc(name+"IdleClosed", "Tablet server conn pool idle closed", func() int64 {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		return pool.Metrics.IdleClosed()
 	})
 	stats.NewCounterFunc(name+"MaxLifetimeClosed", "Tablet server conn pool refresh closed", func() int64 {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		return pool.Metrics.MaxLifetimeClosed()
 	})
 	stats.NewCounterFunc(name+"Get", "Tablet server conn pool get count", func() int64 {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		return pool.Metrics.GetCount()
 	})
 	stats.NewCounterFunc(name+"GetSetting", "Tablet server conn pool get with setting count", func() int64 {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		return pool.Metrics.GetSettingCount()
 	})
 	stats.NewCounterFunc(name+"DiffSetting", "Number of times pool applied different setting", func() int64 {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		return pool.Metrics.DiffSettingCount()
 	})
 	stats.NewCounterFunc(name+"ResetSetting", "Number of times pool reset the setting", func() int64 {
+		pool := se.pool.Load()
+		if pool == nil {
+			return 0
+		}
+
 		return pool.Metrics.ResetSettingCount()
 	})
+
+	return se
+}
+
+func (se *StatsExporter[C]) SetPool(pool *ConnPool[C]) {
+	se.pool.Store(pool)
 }

go/vt/dbconnpool/connection_pool.go

@@ -37,7 +37,9 @@ import (
 type ConnectionPool struct {
 	*smartconnpool.ConnPool[*DBConnection]
 
-	name string
+	config        smartconnpool.Config[*DBConnection]
+	statsExporter *smartconnpool.StatsExporter[*DBConnection]
+	name          string
 }
 
 // usedNames is for preventing expvar from panicking. Tests
@@ -55,7 +57,7 @@ func NewConnectionPool(name string, stats *servenv.Exporter, capacity int, idleT
 		MaxLifetime:     maxLifetime,
 		RefreshInterval: dnsResolutionFrequency,
 	}
-	cp := &ConnectionPool{ConnPool: smartconnpool.NewPool(&config), name: name}
+	cp := &ConnectionPool{ConnPool: smartconnpool.NewPool(&config), config: config, name: name}
 	if name == "" || usedNames[name] {
 		return cp
 	}
@@ -65,7 +67,10 @@ func NewConnectionPool(name string, stats *servenv.Exporter, capacity int, idleT
 		// This is unnamed exported so it will use the stats functions directly when adding to the expvar.
 		stats = servenv.NewExporter("", "")
 	}
-	cp.ConnPool.RegisterStats(stats, name)
+
+	cp.statsExporter = smartconnpool.NewStatsExporter[*DBConnection](stats, name)
+
+	//	cp.ConnPool.RegisterStats(stats, name)
 	return cp
 }
 
@@ -88,6 +93,12 @@ func (cp *ConnectionPool) Open(info dbconfigs.Connector) {
 	}
 
 	cp.ConnPool.Open(connect, refresh)
+	cp.statsExporter.SetPool(cp.ConnPool)
+}
+
+func (cp *ConnectionPool) Close() {
+	cp.ConnPool.Close()
+	cp.ConnPool = smartconnpool.NewPool(&cp.config)
 }
 
 func (cp *ConnectionPool) Get(ctx context.Context) (*PooledDBConnection, error) {

go/vt/vttablet/tabletserver/connpool/pool.go

@@ -49,6 +49,10 @@ type PooledConn = smartconnpool.Pooled[*Conn]
 // pool of dba connections that are used to kill connections.
 type Pool struct {
 	*smartconnpool.ConnPool[*Conn]
+
+	config        smartconnpool.Config[*Conn]
+	statsExporter *smartconnpool.StatsExporter[*Conn]
+
 	dbaPool *dbconnpool.ConnectionPool
 
 	timeout time.Duration
@@ -82,8 +86,10 @@ func NewPool(env tabletenv.Env, name string, cfg tabletenv.ConnPoolConfig) *Pool
 		cp.getConnTime = env.Exporter().NewTimings(name+"GetConnTime", "Tracks the amount of time it takes to get a connection", "Settings")
 	}
 
+	cp.config = config
+
 	cp.ConnPool = smartconnpool.NewPool(&config)
-	cp.ConnPool.RegisterStats(env.Exporter(), name)
+	cp.statsExporter = smartconnpool.NewStatsExporter[*Conn](env.Exporter(), name)
 
 	cp.dbaPool = dbconnpool.NewConnectionPool("", env.Exporter(), 1, config.IdleTimeout, config.MaxLifetime, 0)
 
@@ -104,13 +110,17 @@ func (cp *Pool) Open(appParams, dbaParams, appDebugParams dbconfigs.Connector) {
 	}
 
 	cp.ConnPool.Open(connect, refresh)
+	cp.statsExporter.SetPool(cp.ConnPool)
+
 	cp.dbaPool.Open(dbaParams)
 }
 
 // Close will close the pool and wait for connections to be returned before
 // exiting.
 func (cp *Pool) Close() {
 	cp.ConnPool.Close()
+	cp.ConnPool = smartconnpool.NewPool(&cp.config)
+
 	cp.dbaPool.Close()
 }