Fix review findings: logger forwarding, exception logging, degraded mode warning

- Log t.Exception (AggregateException) instead of t.Exception.InnerException
  to prevent null reference when handler throws AggregateException
- Forward ILogger<RedisDatabase> from RedisClient via LoggerFactory so
  PubSub error logging works in production deployments
- Add warning log when all pool connections are disconnected and a
  degraded-mode fallback is returned
- Replace Task.Delay(200) with signaling (TaskCompletionSource) in
  PubSub handler-throws test to eliminate timing flakiness

Author: imperugo

src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisClient.cs

@@ -1,5 +1,7 @@
 // Copyright (c) Ugo Lattanzi.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
 
+using Microsoft.Extensions.Logging;
+
 using StackExchange.Redis.Extensions.Core.Abstractions;
 using StackExchange.Redis.Extensions.Core.Configuration;
 
@@ -9,6 +11,7 @@ namespace StackExchange.Redis.Extensions.Core.Implementations;
 public class RedisClient : IRedisClient
 {
     private readonly RedisConfiguration redisConfiguration;
+    private readonly ILogger<RedisDatabase>? databaseLogger;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="RedisClient"/> class.
@@ -24,6 +27,7 @@ public RedisClient(
         ConnectionPoolManager = connectionPoolManager;
         Serializer = serializer;
         this.redisConfiguration = redisConfiguration;
+        databaseLogger = redisConfiguration.LoggerFactory?.CreateLogger<RedisDatabase>();
     }
 
     /// <inheritdoc/>
@@ -92,7 +96,8 @@ public IRedisDatabase GetDb(int dbNumber, string? keyPrefix = null)
             redisConfiguration.ServerEnumerationStrategy,
             dbNumber,
             redisConfiguration.MaxValueLength,
-            keyPrefix);
+            keyPrefix,
+            databaseLogger);
     }
 
     /// <inheritdoc/>

src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisConnectionPoolManager.cs

@@ -145,6 +145,9 @@ var nextIdx
                 throw new InvalidEnumArgumentException(nameof(redisConfiguration.ConnectionSelectionStrategy), (int)redisConfiguration.ConnectionSelectionStrategy, typeof(ConnectionSelectionStrategy));
         }
 
+        if (!connection.IsConnected() && logger.IsEnabled(LogLevel.Warning))
+            logger.LogWarning("All Redis connections are disconnected. Using connection {HashCode} in degraded mode.", connection.Connection.GetHashCode().ToString(CultureInfo.InvariantCulture));
+
         if (logger.IsEnabled(LogLevel.Debug))
             logger.LogDebug("Using connection {HashCode} with {OutStanding} outstanding!", connection.Connection.GetHashCode().ToString(CultureInfo.InvariantCulture), connection.TotalOutstanding().ToString(CultureInfo.InvariantCulture));
 

src/core/StackExchange.Redis.Extensions.Core/Implementations/RedisDatabase.PubSub.cs

@@ -43,7 +43,7 @@ void Handler(RedisChannel redisChannel, RedisValue value)
             });
 
             task.ContinueWith(
-                t => logger.LogError(t.Exception!.InnerException, "Error processing subscription message on channel {Channel}", (string?)redisChannel),
+                t => logger.LogError(t.Exception, "Error processing subscription message on channel {Channel}", (string?)redisChannel),
                 CancellationToken.None,
                 TaskContinuationOptions.OnlyOnFaulted,
                 TaskScheduler.Default);

tests/StackExchange.Redis.Extensions.Core.Tests/CacheClientTestBase.PubSub.cs

@@ -39,22 +39,30 @@ public async Task SubscribeAsync_HandlerThrows_ShouldNotCrashProcess_Async()
     {
         var channel = new RedisChannel(Guid.NewGuid().ToString(), RedisChannel.PatternMode.Literal);
         var secondMessageReceived = new TaskCompletionSource<bool>();
+        var firstHandlerCompleted = new TaskCompletionSource<bool>();
         var callCount = 0;
 
         await Sut.GetDefaultDatabase().SubscribeAsync<string>(channel, _ =>
         {
             var count = Interlocked.Increment(ref callCount);
 
             if (count == 1)
+            {
+                firstHandlerCompleted.TrySetResult(true);
                 throw new InvalidOperationException("Simulated handler failure");
+            }
 
             secondMessageReceived.TrySetResult(true);
             return Task.CompletedTask;
         });
 
         // First message — handler throws, should be logged not crash
         await Sut.GetDefaultDatabase().PublishAsync(channel, "msg1");
-        await Task.Delay(200);
+
+        // Wait for first handler to complete before sending second message
+        using var cts1 = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+        cts1.Token.Register(() => firstHandlerCompleted.TrySetCanceled());
+        await firstHandlerCompleted.Task;
 
         // Second message — handler should still be active
         await Sut.GetDefaultDatabase().PublishAsync(channel, "msg2");