Mark singleServerPool's connection lcActive at construction

singleServerPool's OnSuccess/OnFailure are no-ops, so a connection
placed in this pool would otherwise stay at its initial lifecycle
(typically lcUnknown / "dead") for the lifetime of the pool. Anything
that reads lifecycle state via buildConnectionMetric -- the metrics
API, test readiness gates that lens connection health into the
readiness FSM, future observers -- would then incorrectly classify
the only available connection as not-ready, even after it had served
requests successfully.

multiServerPool already does the right thing: when it constructs a
pool with initial conns it CAS's lcActive on each one (clearing
lcUnknown|lcStandby). This change applies the same transition to
singleServerPool by routing all four construction sites through a
new newSingleServerPool(conn, *metrics) helper that performs the
CAS under conn.mu before returning.

Behavior is otherwise unchanged. Existing multiServerPool->
singleServerPool demotion paths preserve their connection's
existing state (the CAS is a no-op when lcActive is already set).

Signed-off-by: Sean Chittenden <sean.chittenden@crowdstrike.com>

Author: sean-

opensearchtransport/discovery.go

@@ -871,10 +871,7 @@ func (c *Client) createOrUpdateSingleNodePool(readyConnections, deadConnections
 		metrics = existingSinglePool.metrics
 	}
 
-	return &singleServerPool{
-		connection: connection,
-		metrics:    metrics,
-	}
+	return newSingleServerPool(connection, metrics)
 }
 
 // createOrUpdateMultiNodePoolWithLock handles multi-node connection pool creation/updates.

opensearchtransport/opensearchtransport.go

@@ -890,7 +890,7 @@ func New(cfg Config) (*Client, error) {
 	} else {
 		// Use client-configured timeout settings for the main connection pool
 		if len(conns) == 1 {
-			client.mu.connectionPool = &singleServerPool{connection: conns[0]}
+			client.mu.connectionPool = newSingleServerPool(conns[0], nil)
 		} else {
 			poolCtx, poolCancel := context.WithCancel(ctx)
 			pool := &multiServerPool{
@@ -2385,10 +2385,7 @@ func (c *Client) demoteConnectionPoolWithLock() *singleServerPool {
 
 		currentPool.mu.RUnlock()
 
-		return &singleServerPool{
-			connection: connection,
-			metrics:    metrics,
-		}
+		return newSingleServerPool(connection, metrics)
 
 	case *singleServerPool:
 		// Already a singleServerPool - return unchanged

opensearchtransport/pool_multi_server.go

@@ -336,7 +336,7 @@ func (cp *multiServerPool) getWarmupParams() (int, int) {
 //nolint:unparam // public API; selector kept for backward compatibility
 func NewConnectionPool(conns []*Connection, selector Selector) ConnectionPool {
 	if len(conns) == 1 {
-		return &singleServerPool{connection: conns[0]}
+		return newSingleServerPool(conns[0], nil)
 	}
 
 	pool := &multiServerPool{

opensearchtransport/pool_single_server.go

@@ -6,7 +6,10 @@
 
 package opensearchtransport
 
-import "net/url"
+import (
+	"errors"
+	"net/url"
+)
 
 // singleServerPool is a trivial connection pool for single-node clusters.
 // All operations are no-ops except Next(), which returns the single connection.
@@ -16,6 +19,45 @@ type singleServerPool struct {
 	metrics *metrics
 }
 
+// newSingleServerPool constructs a singleServerPool and marks the connection
+// as lcActive.
+//
+// singleServerPool's OnSuccess/OnFailure are no-ops, so a connection placed
+// in this pool would otherwise stay at its initial lifecycle (typically
+// lcUnknown / "dead") for the lifetime of the pool. Observers that read
+// lifecycle state via buildConnectionMetric (test readiness gates, metric
+// consumers, etc.) would then incorrectly classify the only available
+// connection as not-ready.
+//
+// The transition mirrors what multiServerPool does for its initial conns:
+// set lcActive, clear lcUnknown|lcStandby. Construction-from-discovery
+// happens before the pool is published, but pool-demotion paths
+// (multiServerPool -> singleServerPool) reuse a connection that may
+// already be racing health-checkers; retry on errLifecycleConflict so a
+// concurrent mutation in those bits doesn't leave the connection
+// permanently classified as dead.
+func newSingleServerPool(conn *Connection, m *metrics) *singleServerPool {
+	if conn != nil {
+		conn.mu.Lock()
+		const maxRetries = 4
+		for range maxRetries {
+			err := conn.casLifecycle(conn.loadConnState(), 0, lcActive, lcUnknown|lcStandby)
+			if err == nil || errors.Is(err, errLifecycleNoop) {
+				break
+			}
+			// errLifecycleConflict: another goroutine changed the
+			// position bits between our snapshot and the CAS. Reload
+			// and try again; bounded to avoid live-lock under
+			// contention from a hot health-check goroutine.
+		}
+		conn.mu.Unlock()
+	}
+	return &singleServerPool{
+		connection: conn,
+		metrics:    m,
+	}
+}
+
 // Compile-time check that singleServerPool implements ConnectionPool.
 var _ ConnectionPool = (*singleServerPool)(nil)