IProfiledCommand data expansion

src/StackExchange.Redis/ConnectionMultiplexer.cs

@@ -2222,9 +2222,10 @@ private bool PrepareToPushMessageToBridge<T>(Message message, ResultProcessor<T>
                 }
             }
 
+            var profilingSession = _profilingSessionProvider?.Invoke();
+
             if (server != null)
             {
-                var profilingSession = _profilingSessionProvider?.Invoke();
                 if (profilingSession != null)
                 {
                     message.SetProfileStorage(ProfiledCommand.NewWithContext(profilingSession, server));
@@ -2242,9 +2243,17 @@ private bool PrepareToPushMessageToBridge<T>(Message message, ResultProcessor<T>
                 Trace("Queueing on server: " + message);
                 return true;
             }
-            Trace("No server or server unavailable - aborting: " + message);
-            return false;
+            else
+            {
+                if (profilingSession != null)
+                {
+                    message.SetProfileStorage(ProfiledCommand.NewWithContext(profilingSession, server));
+                }
+                Trace("No server or server unavailable - aborting: " + message);
+                return false;
+            }
         }
+
         private ValueTask<WriteResult> TryPushMessageToBridgeAsync<T>(Message message, ResultProcessor<T> processor, IResultBox<T> resultBox, ref ServerEndPoint server)
             => PrepareToPushMessageToBridge(message, processor, resultBox, ref server) ? server.TryWriteAsync(message) : new ValueTask<WriteResult>(WriteResult.NoConnectionAvailable);
 
@@ -2750,16 +2759,22 @@ internal Task<T> ExecuteAsyncImpl<T>(Message message, ResultProcessor<T> process
             var write = TryPushMessageToBridgeAsync(message, processor, source, ref server);
             if (!write.IsCompletedSuccessfully) return ExecuteAsyncImpl_Awaited<T>(this, write, tcs, message, server);
 
+            var result = write.Result;
             if (tcs == null)
             {
+                if (result != WriteResult.Success && message.HasPerformance)
+                {
+                    var ex = GetException(result, message, server);
+                    message.SetExceptionAndComplete(ex, null);
+                }
                 return CompletedTask<T>.Default(null); // F+F explicitly does not get async-state
             }
             else
             {
-                var result = write.Result;
                 if (result != WriteResult.Success)
                 {
                     var ex = GetException(result, message, server);
+                    message.SetExceptionAndComplete(ex, null);
                     ThrowFailed(tcs, ex);
                 }
                 return tcs.Task;
@@ -2772,6 +2787,7 @@ private static async Task<T> ExecuteAsyncImpl_Awaited<T>(ConnectionMultiplexer @
             if (result != WriteResult.Success)
             {
                 var ex = @this.GetException(result, message, server);
+                message.SetExceptionAndComplete(ex, null);
                 ThrowFailed(tcs, ex);
             }
             return tcs == null ? default(T) : await tcs.Task.ForAwait();
@@ -2818,42 +2834,54 @@ internal T ExecuteSyncImpl<T>(Message message, ResultProcessor<T> processor, Ser
             if (message.IsFireAndForget)
             {
 #pragma warning disable CS0618
-                TryPushMessageToBridgeSync(message, processor, null, ref server);
+                var result = TryPushMessageToBridgeSync(message, processor, null, ref server);
+                if (result != WriteResult.Success && message.HasPerformance)
+                {
+                    message.SetExceptionAndComplete(GetException(result, message, server), null);
+                }
 #pragma warning restore CS0618
                 Interlocked.Increment(ref fireAndForgets);
                 return default(T);
             }
             else
             {
-                var source = SimpleResultBox<T>.Get();
-
-                lock (source)
+                try
                 {
+                    var source = SimpleResultBox<T>.Get();
+
+                    lock (source)
+                    {
 #pragma warning disable CS0618
-                    var result = TryPushMessageToBridgeSync(message, processor, source, ref server);
+                        var result = TryPushMessageToBridgeSync(message, processor, source, ref server);
 #pragma warning restore CS0618
-                    if (result != WriteResult.Success)
-                    {
-                        throw GetException(result, message, server);
-                    }
+                        if (result != WriteResult.Success)
+                        {
+                            throw GetException(result, message, server);
+                        }
 
-                    if (Monitor.Wait(source, TimeoutMilliseconds))
-                    {
-                        Trace("Timeley response to " + message);
-                    }
-                    else
-                    {
-                        Trace("Timeout performing " + message);
-                        Interlocked.Increment(ref syncTimeouts);
-                        throw ExceptionFactory.Timeout(this, null, message, server);
-                        // very important not to return "source" to the pool here
+                        if (Monitor.Wait(source, TimeoutMilliseconds))
+                        {
+                            Trace("Timeley response to " + message);
+                        }
+                        else
+                        {
+                            Trace("Timeout performing " + message);
+                            Interlocked.Increment(ref syncTimeouts);
+                            throw ExceptionFactory.Timeout(this, null, message, server);
+                            // very important not to return "source" to the pool here
+                        }
                     }
+                    // snapshot these so that we can recycle the box
+                    var val = source.GetResult(out var ex, canRecycle: true); // now that we aren't locking it...
+                    if (ex != null) throw ex;
+                    Trace(message + " received " + val);
+                    return val;
+                }
+                catch (Exception ex)
+                {
+                    message.SetExceptionAndComplete(ex, null);
+                    throw;
                 }
-                // snapshot these so that we can recycle the box
-                var  val = source.GetResult(out var ex, canRecycle: true); // now that we aren't locking it...
-                if (ex != null) throw ex;
-                Trace(message + " received " + val);
-                return val;
             }
         }
 

src/StackExchange.Redis/Interfaces/IKeysMessage.cs

@@ -0,0 +1,7 @@
+namespace StackExchange.Redis
+{
+    internal interface IKeysMessage
+    {
+        RedisKey[] Keys { get; }
+    }
+}

src/StackExchange.Redis/Interfaces/IValuesMessage.cs

@@ -0,0 +1,7 @@
+namespace StackExchange.Redis
+{
+    internal interface IValuesMessage
+    {
+        RedisValue[] Values { get; }
+    }
+}