Method removeConnInternal

internal/pool/pool.go:1410–1453

removeConnInternal is the internal implementation of Remove that optionally frees a turn.

(ctx context.Context, cn *Conn, reason error, freeTurn bool)

// removeConnInternal is the internal implementation of Remove that optionally frees a turn.
func (p *ConnPool) removeConnInternal(ctx context.Context, cn *Conn, reason error, freeTurn bool) {
	// Lock-free atomic read - no mutex overhead!
	hookManager := p.hookManager.Load()

	if hookManager != nil {
		hookManager.ProcessOnRemove(ctx, cn, reason)
	}

	removed := p.removeConnWithLock(cn)

	if freeTurn {
		p.freeTurn()
	}

	// Only emit metric decrements if we actually removed the connection from the map.
	// If removed is false, Close() already removed it and emitted the -1 delta.
	if removed {
		// Notify metrics: connection removed (assume from used state)
		if cb := getMetricConnectionStateChangeCallback(); cb != nil {
			cb(ctx, cn, MetricStateUsed, "")
		}
		// Record connection count decrement (connection removed, assume from used state)
		if cb := getMetricConnectionCountCallback(); cb != nil {
			cb(ctx, -1, cn, "used", false)
		}
	}

	// Only emit connection closed if we actually owned the removal.
	// If removed is false, Close() already emitted connectionClosed for this conn.
	if removed {
		if cb := getMetricConnectionClosedCallback(); cb != nil {
			reasonStr := "unknown"
			if reason != nil {
				reasonStr = reason.Error()
			}
			cb(ctx, cn, reasonStr, reason)
		}
	}

	_ = p.closeConn(cn)

	// Check if we need to create new idle connections to maintain MinIdleConns
	p.checkMinIdleConns()
}

// CloseConn closes a connection and records metrics.
// Parameters: