Track the number of live multiplexers (#3030)

* Track the number of live multiplexers, and report it in the error dump if non-trivial

* fight the CI on a CS9336 mixup

* simplify counting

Author: mgravell

src/StackExchange.Redis/ConnectionMultiplexer.Debug.cs

@@ -4,9 +4,18 @@ namespace StackExchange.Redis;
 
 public partial class ConnectionMultiplexer
 {
-    private static int _collectedWithoutDispose;
+    private static int _collectedWithoutDispose, s_DisposedCount, s_MuxerCreateCount;
     internal static int CollectedWithoutDispose => Volatile.Read(ref _collectedWithoutDispose);
 
+    internal static int GetLiveObjectCount(out int created, out int disposed, out int finalized)
+    {
+        // read destroy first, to prevent negative numbers in race conditions
+        disposed = Volatile.Read(ref s_DisposedCount);
+        created = Volatile.Read(ref s_MuxerCreateCount);
+        finalized = Volatile.Read(ref _collectedWithoutDispose);
+        return created - (disposed + finalized);
+    }
+
     /// <summary>
     /// Invoked by the garbage collector.
     /// </summary>

src/StackExchange.Redis/ConnectionMultiplexer.cs

@@ -128,6 +128,8 @@ static ConnectionMultiplexer()
 
         private ConnectionMultiplexer(ConfigurationOptions configuration, ServerType? serverType = null, EndPointCollection? endpoints = null)
         {
+            Interlocked.Increment(ref s_MuxerCreateCount);
+
             RawConfig = configuration ?? throw new ArgumentNullException(nameof(configuration));
             EndPoints = endpoints ?? RawConfig.EndPoints.Clone();
             EndPoints.SetDefaultPorts(serverType, ssl: RawConfig.Ssl);
@@ -2258,7 +2260,8 @@ ConfigurationChangedChannel is byte[] channel
         public void Dispose()
         {
             GC.SuppressFinalize(this);
-            Close(!_isDisposed);
+            if (!_isDisposed) Interlocked.Increment(ref s_DisposedCount);
+            Close(!_isDisposed); // marks disposed
             sentinelConnection?.Dispose();
             var oldTimer = Interlocked.Exchange(ref sentinelPrimaryReconnectTimer, null);
             oldTimer?.Dispose();
@@ -2270,7 +2273,8 @@ public void Dispose()
         public async ValueTask DisposeAsync()
         {
             GC.SuppressFinalize(this);
-            await CloseAsync(!_isDisposed).ForAwait();
+            if (!_isDisposed) Interlocked.Increment(ref s_DisposedCount);
+            await CloseAsync(!_isDisposed).ForAwait(); // marks disposed
             if (sentinelConnection is ConnectionMultiplexer sentinel)
             {
                 await sentinel.DisposeAsync().ForAwait();

src/StackExchange.Redis/ExceptionFactory.cs

@@ -347,6 +347,12 @@ private static void AddCommonDetail(
                 Add(data, sb, "Last-Result-Bytes", "last-in", bs.Connection.BytesLastResult.ToString());
                 Add(data, sb, "Inbound-Buffer-Bytes", "cur-in", bs.Connection.BytesInBuffer.ToString());
 
+                var liveMuxers = ConnectionMultiplexer.GetLiveObjectCount(out var created, out var disposed, out var finalized);
+                if (created > 1)
+                {
+                    Add(data, sb, "Live-Multiplexers", "lm", $"{liveMuxers}/{created}/{disposed}/{finalized}");
+                }
+
                 Add(data, sb, "Sync-Ops", "sync-ops", multiplexer.syncOps.ToString());
                 Add(data, sb, "Async-Ops", "async-ops", multiplexer.asyncOps.ToString());
 

src/StackExchange.Redis/PhysicalBridge.cs

@@ -1622,8 +1622,13 @@ private WriteResult WriteMessageToServerInsideWriteLock(PhysicalConnection conne
 
                 if (_nextHighIntegrityToken is not 0
                     && !connection.TransactionActive // validated in the UNWATCH/EXEC/DISCARD
-                    && message.Command is not RedisCommand.AUTH or RedisCommand.HELLO) // if auth fails, ECHO may also fail; avoid confusion
+                    && message.Command is not RedisCommand.AUTH // if auth fails, later commands may also fail; avoid confusion
+                    && message.Command is not RedisCommand.HELLO)
                 {
+                    // note on the Command match above: curiously, .NET 10 and .NET 11 SDKs emit *opposite* errors here
+                    // re "CS9336: The pattern is redundant." ("fixing" one "breaks" the other); possibly a fixed bool inversion
+                    // in the analyzer? to avoid pain, we'll just use the most obviously correct form
+
                     // make sure this value exists early to avoid a race condition
                     // if the response comes back super quickly
                     message.WithHighIntegrity(NextHighIntegrityTokenInsideLock());