fix #1108 - introduce LogProxy as an intermediary between the TextWriter; move the sync to there - allows safe detach from the logging (#1116)

mgravell · web-flow · commit bb981525a992 · 2019-04-08T09:13:33.000+01:00
diff --git a/src/StackExchange.Redis/ConfigurationOptions.cs b/src/StackExchange.Redis/ConfigurationOptions.cs
@@ -9,6 +9,7 @@
 using System.Security.Cryptography.X509Certificates;
 using System.Text;
 using System.Threading.Tasks;
+using static StackExchange.Redis.ConnectionMultiplexer;
 
 namespace StackExchange.Redis
 {
@@ -523,7 +524,7 @@ internal bool HasDnsEndPoints()
             return false;
         }
 
-        internal async Task ResolveEndPointsAsync(ConnectionMultiplexer multiplexer, TextWriter log)
+        internal async Task ResolveEndPointsAsync(ConnectionMultiplexer multiplexer, LogProxy log)
         {
             var cache = new Dictionary<string, IPAddress>(StringComparer.OrdinalIgnoreCase);
             for (int i = 0; i < EndPoints.Count; i++)
@@ -542,12 +543,12 @@ internal async Task ResolveEndPointsAsync(ConnectionMultiplexer multiplexer, Tex
                         }
                         else
                         {
-                            multiplexer.LogLocked(log, "Using DNS to resolve '{0}'...", dns.Host);
+                            log?.WriteLine($"Using DNS to resolve '{dns.Host}'...");
                             var ips = await Dns.GetHostAddressesAsync(dns.Host).ObserveErrors().ForAwait();
                             if (ips.Length == 1)
                             {
                                 ip = ips[0];
-                                multiplexer.LogLocked(log, "'{0}' => {1}", dns.Host, ip);
+                                log?.WriteLine($"'{dns.Host}' => {ip}");
                                 cache[dns.Host] = ip;
                                 EndPoints[i] = new IPEndPoint(ip, dns.Port);
                             }
@@ -556,7 +557,7 @@ internal async Task ResolveEndPointsAsync(ConnectionMultiplexer multiplexer, Tex
                     catch (Exception ex)
                     {
                         multiplexer.OnInternalError(ex);
-                        multiplexer.LogLocked(log, ex.Message);
+                        log?.WriteLine(ex.Message);
                     }
                 }
             }
diff --git a/src/StackExchange.Redis/ConnectionMultiplexer.cs b/src/StackExchange.Redis/ConnectionMultiplexer.cs
diff --git a/src/StackExchange.Redis/DebuggingAids.cs b/src/StackExchange.Redis/DebuggingAids.cs
@@ -20,7 +20,7 @@ static partial void OnTraceWithoutContext(string message, string category)
             Debug.WriteLine(message, Environment.CurrentManagedThreadId + " ~ " + category);
         }
 
-        partial void OnTraceLog(TextWriter log, string caller)
+        partial void OnTraceLog(LogProxy log, string caller)
         {
             lock (UniqueId)
             {
diff --git a/src/StackExchange.Redis/Message.cs b/src/StackExchange.Redis/Message.cs
@@ -8,20 +8,21 @@
 using System.Threading;
 using System.Threading.Tasks;
 using StackExchange.Redis.Profiling;
+using static StackExchange.Redis.ConnectionMultiplexer;
 
 namespace StackExchange.Redis
 {
     internal sealed class LoggingMessage : Message
     {
-        public readonly TextWriter log;
+        public readonly LogProxy log;
         private readonly Message tail;
 
-        public static Message Create(TextWriter log, Message tail)
+        public static Message Create(LogProxy log, Message tail)
         {
             return log == null ? tail : new LoggingMessage(log, tail);
         }
 
-        private LoggingMessage(TextWriter log, Message tail) : base(tail.Db, tail.Flags, tail.Command)
+        private LoggingMessage(LogProxy log, Message tail) : base(tail.Db, tail.Flags, tail.Command)
         {
             this.log = log;
             this.tail = tail;
@@ -39,14 +40,14 @@ protected override void WriteImpl(PhysicalConnection physical)
             try
             {
                 var bridge = physical.BridgeCouldBeNull;
-                bridge?.Multiplexer?.LogLocked(log, "Writing to {0}: {1}", bridge, tail.CommandAndKey);
+                log?.WriteLine($"Writing to {bridge}: {tail.CommandAndKey}");
             }
             catch { }
             tail.WriteTo(physical);
         }
         public override int ArgCount => tail.ArgCount;
 
-        public TextWriter Log => log;
+        public LogProxy Log => log;
     }
 
     internal abstract class Message : ICompletable
diff --git a/src/StackExchange.Redis/PhysicalBridge.cs b/src/StackExchange.Redis/PhysicalBridge.cs
@@ -10,6 +10,7 @@
 using Pipelines.Sockets.Unofficial;
 using Pipelines.Sockets.Unofficial.Threading;
 using static Pipelines.Sockets.Unofficial.Threading.MutexSlim;
+using static StackExchange.Redis.ConnectionMultiplexer;
 using PendingSubscriptionState = global::StackExchange.Redis.ConnectionMultiplexer.Subscription.PendingSubscriptionState;
 
 namespace StackExchange.Redis
@@ -129,7 +130,7 @@ public void ReportNextFailure()
 
         public override string ToString() => ConnectionType + "/" + Format.ToString(ServerEndPoint.EndPoint);
 
-        public void TryConnect(TextWriter log) => GetConnection(log);
+        public void TryConnect(LogProxy log) => GetConnection(log);
 
         private WriteResult QueueOrFailMessage(Message message)
         {
@@ -380,7 +381,7 @@ internal void KeepAlive()
             }
         }
 
-        internal async Task OnConnectedAsync(PhysicalConnection connection, TextWriter log)
+        internal async Task OnConnectedAsync(PhysicalConnection connection, LogProxy log)
         {
             Trace("OnConnected");
             if (physical == connection && !isDisposed && ChangeState(State.Connecting, State.ConnectedEstablishing))
@@ -1097,15 +1098,15 @@ private bool ChangeState(State oldState, State newState)
             return result;
         }
 
-        private PhysicalConnection GetConnection(TextWriter log)
+        private PhysicalConnection GetConnection(LogProxy log)
         {
             if (state == (int)State.Disconnected)
             {
                 try
                 {
                     if (!Multiplexer.IsDisposed)
                     {
-                        Multiplexer.LogLocked(log, "Connecting {0}...", Name);
+                        log?.WriteLine($"Connecting {Name}...");
                         Multiplexer.Trace("Connecting...", Name);
                         if (ChangeState(State.Disconnected, State.Connecting))
                         {
@@ -1122,7 +1123,7 @@ private PhysicalConnection GetConnection(TextWriter log)
                 }
                 catch (Exception ex)
                 {
-                    Multiplexer.LogLocked(log, "Connect {0} failed: {1}", Name, ex.Message);
+                    log?.WriteLine($"Connect {Name} failed: {ex.Message}");
                     Multiplexer.Trace("Connect failed: " + ex.Message, Name);
                     ChangeState(State.Disconnected);
                     OnInternalError(ex);
diff --git a/src/StackExchange.Redis/PhysicalConnection.cs b/src/StackExchange.Redis/PhysicalConnection.cs
@@ -18,6 +18,7 @@
 using System.Threading.Tasks;
 using Pipelines.Sockets.Unofficial;
 using Pipelines.Sockets.Unofficial.Arenas;
+using static StackExchange.Redis.ConnectionMultiplexer;
 
 namespace StackExchange.Redis
 {
@@ -85,7 +86,7 @@ public PhysicalConnection(PhysicalBridge bridge)
             OnCreateEcho();
         }
 
-        internal async Task BeginConnectAsync(TextWriter log)
+        internal async Task BeginConnectAsync(LogProxy log)
         {
             var bridge = BridgeCouldBeNull;
             var endpoint = bridge?.ServerEndPoint?.EndPoint;
@@ -97,7 +98,7 @@ internal async Task BeginConnectAsync(TextWriter log)
             Trace("Connecting...");
             _socket = SocketManager.CreateSocket(endpoint);
             bridge.Multiplexer.OnConnecting(endpoint, bridge.ConnectionType);
-            bridge.Multiplexer.LogLocked(log, "BeginConnect: {0}", Format.ToString(endpoint));
+            log?.WriteLine($"BeginConnect: {Format.ToString(endpoint)}");
 
             CancellationTokenSource timeoutSource = null;
             try
@@ -141,7 +142,7 @@ internal async Task BeginConnectAsync(TextWriter log)
                         }
                         else if (await ConnectedAsync(x, log, bridge.Multiplexer.SocketManager).ForAwait())
                         {
-                            bridge.Multiplexer.LogLocked(log, "Starting read");
+                            log?.WriteLine("Starting read");
                             try
                             {
                                 StartReading();
@@ -161,7 +162,7 @@ internal async Task BeginConnectAsync(TextWriter log)
                     }
                     catch (ObjectDisposedException)
                     {
-                        bridge.Multiplexer.LogLocked(log, "(socket shutdown)");
+                        log?.WriteLine("(socket shutdown)");
                         try { RecordConnectionFailed(ConnectionFailureType.UnableToConnect, isInitialConnect: true); }
                         catch (Exception inner)
                         {
@@ -1251,7 +1252,7 @@ private static LocalCertificateSelectionCallback GetAmbientClientCertificateCall
             return null;
         }
 
-        internal async ValueTask<bool> ConnectedAsync(Socket socket, TextWriter log, SocketManager manager)
+        internal async ValueTask<bool> ConnectedAsync(Socket socket, LogProxy log, SocketManager manager)
         {
             var bridge = BridgeCouldBeNull;
             if (bridge == null) return false;
@@ -1270,7 +1271,7 @@ internal async ValueTask<bool> ConnectedAsync(Socket socket, TextWriter log, Soc
 
                 if (config.Ssl)
                 {
-                    bridge.Multiplexer.LogLocked(log, "Configuring SSL");
+                    log?.WriteLine("Configuring TLS");
                     var host = config.SslHost;
                     if (string.IsNullOrWhiteSpace(host)) host = Format.ToStringHostOnly(bridge.ServerEndPoint.EndPoint);
 
@@ -1290,7 +1291,7 @@ internal async ValueTask<bool> ConnectedAsync(Socket socket, TextWriter log, Soc
                             bridge.Multiplexer?.SetAuthSuspect();
                             throw;
                         }
-                        bridge.Multiplexer.LogLocked(log, $"SSL connection established successfully using protocol: {ssl.SslProtocol}");
+                        log?.WriteLine($"TLS connection established successfully using protocol: {ssl.SslProtocol}");
                     }
                     catch (AuthenticationException authexception)
                     {
@@ -1308,7 +1309,7 @@ internal async ValueTask<bool> ConnectedAsync(Socket socket, TextWriter log, Soc
 
                 _ioPipe = pipe;
 
-                bridge.Multiplexer.LogLocked(log, "Connected {0}", bridge);
+                log?.WriteLine($"Connected {bridge}");
 
                 await bridge.OnConnectedAsync(this, log).ForAwait();
                 return true;
diff --git a/src/StackExchange.Redis/RedisServer.cs b/src/StackExchange.Redis/RedisServer.cs
@@ -6,6 +6,7 @@
 using System.Security.Cryptography;
 using System.Text;
 using System.Threading.Tasks;
+using static StackExchange.Redis.ConnectionMultiplexer;
 
 #pragma warning disable RCS1231 // Make parameter ref read-only.
 
@@ -320,7 +321,10 @@ public Task<DateTime> LastSaveAsync(CommandFlags flags = CommandFlags.None)
 
         public void MakeMaster(ReplicationChangeOptions options, TextWriter log = null)
         {
-            multiplexer.MakeMaster(server, options, log);
+            using (var proxy = LogProxy.TryCreate(log))
+            {
+                multiplexer.MakeMaster(server, options, proxy);
+            }
         }
 
         public void Save(SaveType type, CommandFlags flags = CommandFlags.None)
diff --git a/src/StackExchange.Redis/ResultProcessor.cs b/src/StackExchange.Redis/ResultProcessor.cs
@@ -175,7 +175,7 @@ public virtual bool SetResult(PhysicalConnection connection, Message message, in
             {
                 try
                 {
-                    bridge?.Multiplexer?.LogLocked(logging.Log, "Response from {0} / {1}: {2}", bridge, message.CommandAndKey, result);
+                    logging.Log?.WriteLine($"Response from {bridge} / {message.CommandAndKey}: {result}");
                 }
                 catch { }
             }
diff --git a/src/StackExchange.Redis/ServerEndPoint.cs b/src/StackExchange.Redis/ServerEndPoint.cs
@@ -9,6 +9,7 @@
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
+using static StackExchange.Redis.ConnectionMultiplexer;
 using static StackExchange.Redis.PhysicalBridge;
 
 namespace StackExchange.Redis
@@ -155,7 +156,7 @@ public void Dispose()
             tmp?.Dispose();
         }
 
-        public PhysicalBridge GetBridge(ConnectionType type, bool create = true, TextWriter log = null)
+        public PhysicalBridge GetBridge(ConnectionType type, bool create = true, LogProxy log = null)
         {
             if (isDisposed) return null;
             switch (type)
@@ -237,7 +238,7 @@ public void SetUnselectable(UnselectableFlags flags)
 
         public ValueTask<WriteResult> TryWriteAsync(Message message) => GetBridge(message.Command)?.TryWriteAsync(message, isSlave) ?? new ValueTask<WriteResult>(WriteResult.NoConnectionAvailable);
 
-        internal void Activate(ConnectionType type, TextWriter log)
+        internal void Activate(ConnectionType type, LogProxy log)
         {
             GetBridge(type, true, log);
         }
@@ -467,7 +468,7 @@ internal bool IsSelectable(RedisCommand command, bool allowDisconnected = false)
             return bridge != null && (allowDisconnected || bridge.IsConnected);
         }
 
-        internal Task OnEstablishingAsync(PhysicalConnection connection, TextWriter log)
+        internal Task OnEstablishingAsync(PhysicalConnection connection, LogProxy log)
         {
             try
             {
@@ -624,7 +625,7 @@ internal void ReportNextFailure()
             subscription?.ReportNextFailure();
         }
 
-        internal Task<bool> SendTracer(TextWriter log = null)
+        internal Task<bool> SendTracer(LogProxy log = null)
         {
             var msg = GetTracerMessage(false);
             msg = LoggingMessage.Create(log, msg);
@@ -727,7 +728,7 @@ internal void WriteDirectOrQueueFireAndForgetSync<T>(PhysicalConnection connecti
             }
         }
 
-        private PhysicalBridge CreateBridge(ConnectionType type, TextWriter log)
+        private PhysicalBridge CreateBridge(ConnectionType type, LogProxy log)
         {
             if (Multiplexer.IsDisposed) return null;
             Multiplexer.Trace(type.ToString());
@@ -736,9 +737,9 @@ private PhysicalBridge CreateBridge(ConnectionType type, TextWriter log)
             return bridge;
         }
 
-        private async Task HandshakeAsync(PhysicalConnection connection, TextWriter log)
+        private async Task HandshakeAsync(PhysicalConnection connection, LogProxy log)
         {
-            Multiplexer.LogLocked(log, "Server handshake");
+            log?.WriteLine("Server handshake");
             if (connection == null)
             {
                 Multiplexer.Trace("No connection!?");
@@ -748,7 +749,7 @@ private async Task HandshakeAsync(PhysicalConnection connection, TextWriter log)
             string password = Multiplexer.RawConfig.Password;
             if (!string.IsNullOrWhiteSpace(password))
             {
-                Multiplexer.LogLocked(log, "Authenticating (password)");
+                log?.WriteLine("Authenticating (password)");
                 msg = Message.Create(-1, CommandFlags.FireAndForget, RedisCommand.AUTH, (RedisValue)password);
                 msg.SetInternalCall();
                 await WriteDirectOrQueueFireAndForgetAsync(connection, msg, ResultProcessor.DemandOK).ForAwait();
@@ -762,7 +763,7 @@ private async Task HandshakeAsync(PhysicalConnection connection, TextWriter log)
                     name = nameSanitizer.Replace(name, "");
                     if (!string.IsNullOrWhiteSpace(name))
                     {
-                        Multiplexer.LogLocked(log, "Setting client name: {0}", name);
+                        log?.WriteLine($"Setting client name: {name}");
                         msg = Message.Create(-1, CommandFlags.FireAndForget, RedisCommand.CLIENT, RedisLiterals.SETNAME, (RedisValue)name);
                         msg.SetInternalCall();
                         await WriteDirectOrQueueFireAndForgetAsync(connection, msg, ResultProcessor.DemandOK).ForAwait();
@@ -779,10 +780,10 @@ private async Task HandshakeAsync(PhysicalConnection connection, TextWriter log)
 
             if (connType == ConnectionType.Interactive)
             {
-                Multiplexer.LogLocked(log, "Auto-configure...");
+                log?.WriteLine("Auto-configure...");
                 AutoConfigure(connection);
             }
-            Multiplexer.LogLocked(log, "Sending critical tracer: {0}", bridge);
+            log?.WriteLine($"Sending critical tracer: {bridge}");
             var tracer = GetTracerMessage(true);
             tracer = LoggingMessage.Create(log, tracer);
             await WriteDirectOrQueueFireAndForgetAsync(connection, tracer, ResultProcessor.EstablishConnection).ForAwait();
@@ -798,7 +799,7 @@ private async Task HandshakeAsync(PhysicalConnection connection, TextWriter log)
                     await WriteDirectOrQueueFireAndForgetAsync(connection, msg, ResultProcessor.TrackSubscriptions).ForAwait();
                 }
             }
-            Multiplexer.LogLocked(log, "Flushing outbound buffer");
+            log?.WriteLine("Flushing outbound buffer");
             await connection.FlushAsync().ForAwait();
         }
 

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`using System.Security.Cryptography.X509Certificates;`
`10`	`10`	`using System.Text;`
`11`	`11`	`using System.Threading.Tasks;`
	`12`	`+using static StackExchange.Redis.ConnectionMultiplexer;`
`12`	`13`
`13`	`14`	`namespace StackExchange.Redis`
`14`	`15`	`{`
`@@ -523,7 +524,7 @@ internal bool HasDnsEndPoints()`
`523`	`524`	`return false;`
`524`	`525`	`}`
`525`	`526`
`526`		`- internal async Task ResolveEndPointsAsync(ConnectionMultiplexer multiplexer, TextWriter log)`
	`527`	`+ internal async Task ResolveEndPointsAsync(ConnectionMultiplexer multiplexer, LogProxy log)`
`527`	`528`	`{`
`528`	`529`	`var cache = new Dictionary<string, IPAddress>(StringComparer.OrdinalIgnoreCase);`
`529`	`530`	`for (int i = 0; i < EndPoints.Count; i++)`
`@@ -542,12 +543,12 @@ internal async Task ResolveEndPointsAsync(ConnectionMultiplexer multiplexer, Tex`
`542`	`543`	`}`
`543`	`544`	`else`
`544`	`545`	`{`
`545`		`- multiplexer.LogLocked(log, "Using DNS to resolve '{0}'...", dns.Host);`
	`546`	`+ log?.WriteLine($"Using DNS to resolve '{dns.Host}'...");`
`546`	`547`	`var ips = await Dns.GetHostAddressesAsync(dns.Host).ObserveErrors().ForAwait();`
`547`	`548`	`if (ips.Length == 1)`
`548`	`549`	`{`
`549`	`550`	`ip = ips[0];`
`550`		`- multiplexer.LogLocked(log, "'{0}' => {1}", dns.Host, ip);`
	`551`	`+ log?.WriteLine($"'{dns.Host}' => {ip}");`
`551`	`552`	`cache[dns.Host] = ip;`
`552`	`553`	`EndPoints[i] = new IPEndPoint(ip, dns.Port);`
`553`	`554`	`}`
`@@ -556,7 +557,7 @@ internal async Task ResolveEndPointsAsync(ConnectionMultiplexer multiplexer, Tex`
`556`	`557`	`catch (Exception ex)`
`557`	`558`	`{`
`558`	`559`	`multiplexer.OnInternalError(ex);`
`559`		`- multiplexer.LogLocked(log, ex.Message);`
	`560`	`+ log?.WriteLine(ex.Message);`
`560`	`561`	`}`
`561`	`562`	`}`
`562`	`563`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ static partial void OnTraceWithoutContext(string message, string category)`
`20`	`20`	`Debug.WriteLine(message, Environment.CurrentManagedThreadId + " ~ " + category);`
`21`	`21`	`}`
`22`	`22`
`23`		`- partial void OnTraceLog(TextWriter log, string caller)`
	`23`	`+ partial void OnTraceLog(LogProxy log, string caller)`
`24`	`24`	`{`
`25`	`25`	`lock (UniqueId)`
`26`	`26`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,20 +8,21 @@`
`8`	`8`	`using System.Threading;`
`9`	`9`	`using System.Threading.Tasks;`
`10`	`10`	`using StackExchange.Redis.Profiling;`
	`11`	`+using static StackExchange.Redis.ConnectionMultiplexer;`
`11`	`12`
`12`	`13`	`namespace StackExchange.Redis`
`13`	`14`	`{`
`14`	`15`	`internal sealed class LoggingMessage : Message`
`15`	`16`	`{`
`16`		`- public readonly TextWriter log;`
	`17`	`+ public readonly LogProxy log;`
`17`	`18`	`private readonly Message tail;`
`18`	`19`
`19`		`- public static Message Create(TextWriter log, Message tail)`
	`20`	`+ public static Message Create(LogProxy log, Message tail)`
`20`	`21`	`{`
`21`	`22`	`return log == null ? tail : new LoggingMessage(log, tail);`
`22`	`23`	`}`
`23`	`24`
`24`		`- private LoggingMessage(TextWriter log, Message tail) : base(tail.Db, tail.Flags, tail.Command)`
	`25`	`+ private LoggingMessage(LogProxy log, Message tail) : base(tail.Db, tail.Flags, tail.Command)`
`25`	`26`	`{`
`26`	`27`	`this.log = log;`
`27`	`28`	`this.tail = tail;`
`@@ -39,14 +40,14 @@ protected override void WriteImpl(PhysicalConnection physical)`
`39`	`40`	`try`
`40`	`41`	`{`
`41`	`42`	`var bridge = physical.BridgeCouldBeNull;`
`42`		`- bridge?.Multiplexer?.LogLocked(log, "Writing to {0}: {1}", bridge, tail.CommandAndKey);`
	`43`	`+ log?.WriteLine($"Writing to {bridge}: {tail.CommandAndKey}");`
`43`	`44`	`}`
`44`	`45`	`catch { }`
`45`	`46`	`tail.WriteTo(physical);`
`46`	`47`	`}`
`47`	`48`	`public override int ArgCount => tail.ArgCount;`
`48`	`49`
`49`		`- public TextWriter Log => log;`
	`50`	`+ public LogProxy Log => log;`
`50`	`51`	`}`
`51`	`52`
`52`	`53`	`internal abstract class Message : ICompletable`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@`
`10`	`10`	`using Pipelines.Sockets.Unofficial;`
`11`	`11`	`using Pipelines.Sockets.Unofficial.Threading;`
`12`	`12`	`using static Pipelines.Sockets.Unofficial.Threading.MutexSlim;`
	`13`	`+using static StackExchange.Redis.ConnectionMultiplexer;`
`13`	`14`	`using PendingSubscriptionState = global::StackExchange.Redis.ConnectionMultiplexer.Subscription.PendingSubscriptionState;`
`14`	`15`
`15`	`16`	`namespace StackExchange.Redis`
`@@ -129,7 +130,7 @@ public void ReportNextFailure()`
`129`	`130`
`130`	`131`	`public override string ToString() => ConnectionType + "/" + Format.ToString(ServerEndPoint.EndPoint);`
`131`	`132`
`132`		`- public void TryConnect(TextWriter log) => GetConnection(log);`
	`133`	`+ public void TryConnect(LogProxy log) => GetConnection(log);`
`133`	`134`
`134`	`135`	`private WriteResult QueueOrFailMessage(Message message)`
`135`	`136`	`{`
`@@ -380,7 +381,7 @@ internal void KeepAlive()`
`380`	`381`	`}`
`381`	`382`	`}`
`382`	`383`
`383`		`- internal async Task OnConnectedAsync(PhysicalConnection connection, TextWriter log)`
	`384`	`+ internal async Task OnConnectedAsync(PhysicalConnection connection, LogProxy log)`
`384`	`385`	`{`
`385`	`386`	`Trace("OnConnected");`
`386`	`387`	`if (physical == connection && !isDisposed && ChangeState(State.Connecting, State.ConnectedEstablishing))`
`@@ -1097,15 +1098,15 @@ private bool ChangeState(State oldState, State newState)`
`1097`	`1098`	`return result;`
`1098`	`1099`	`}`
`1099`	`1100`
`1100`		`- private PhysicalConnection GetConnection(TextWriter log)`
	`1101`	`+ private PhysicalConnection GetConnection(LogProxy log)`
`1101`	`1102`	`{`
`1102`	`1103`	`if (state == (int)State.Disconnected)`
`1103`	`1104`	`{`
`1104`	`1105`	`try`
`1105`	`1106`	`{`
`1106`	`1107`	`if (!Multiplexer.IsDisposed)`
`1107`	`1108`	`{`
`1108`		`- Multiplexer.LogLocked(log, "Connecting {0}...", Name);`
	`1109`	`+ log?.WriteLine($"Connecting {Name}...");`
`1109`	`1110`	`Multiplexer.Trace("Connecting...", Name);`
`1110`	`1111`	`if (ChangeState(State.Disconnected, State.Connecting))`
`1111`	`1112`	`{`
`@@ -1122,7 +1123,7 @@ private PhysicalConnection GetConnection(TextWriter log)`
`1122`	`1123`	`}`
`1123`	`1124`	`catch (Exception ex)`
`1124`	`1125`	`{`
`1125`		`- Multiplexer.LogLocked(log, "Connect {0} failed: {1}", Name, ex.Message);`
	`1126`	`+ log?.WriteLine($"Connect {Name} failed: {ex.Message}");`
`1126`	`1127`	`Multiplexer.Trace("Connect failed: " + ex.Message, Name);`
`1127`	`1128`	`ChangeState(State.Disconnected);`
`1128`	`1129`	`OnInternalError(ex);`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@`
`18`	`18`	`using System.Threading.Tasks;`
`19`	`19`	`using Pipelines.Sockets.Unofficial;`
`20`	`20`	`using Pipelines.Sockets.Unofficial.Arenas;`
	`21`	`+using static StackExchange.Redis.ConnectionMultiplexer;`
`21`	`22`
`22`	`23`	`namespace StackExchange.Redis`
`23`	`24`	`{`
`@@ -85,7 +86,7 @@ public PhysicalConnection(PhysicalBridge bridge)`
`85`	`86`	`OnCreateEcho();`
`86`	`87`	`}`
`87`	`88`
`88`		`- internal async Task BeginConnectAsync(TextWriter log)`
	`89`	`+ internal async Task BeginConnectAsync(LogProxy log)`
`89`	`90`	`{`
`90`	`91`	`var bridge = BridgeCouldBeNull;`
`91`	`92`	`var endpoint = bridge?.ServerEndPoint?.EndPoint;`
`@@ -97,7 +98,7 @@ internal async Task BeginConnectAsync(TextWriter log)`
`97`	`98`	`Trace("Connecting...");`
`98`	`99`	`_socket = SocketManager.CreateSocket(endpoint);`
`99`	`100`	`bridge.Multiplexer.OnConnecting(endpoint, bridge.ConnectionType);`
`100`		`- bridge.Multiplexer.LogLocked(log, "BeginConnect: {0}", Format.ToString(endpoint));`
	`101`	`+ log?.WriteLine($"BeginConnect: {Format.ToString(endpoint)}");`
`101`	`102`
`102`	`103`	`CancellationTokenSource timeoutSource = null;`
`103`	`104`	`try`
`@@ -141,7 +142,7 @@ internal async Task BeginConnectAsync(TextWriter log)`
`141`	`142`	`}`
`142`	`143`	`else if (await ConnectedAsync(x, log, bridge.Multiplexer.SocketManager).ForAwait())`
`143`	`144`	`{`
`144`		`- bridge.Multiplexer.LogLocked(log, "Starting read");`
	`145`	`+ log?.WriteLine("Starting read");`
`145`	`146`	`try`
`146`	`147`	`{`
`147`	`148`	`StartReading();`
`@@ -161,7 +162,7 @@ internal async Task BeginConnectAsync(TextWriter log)`
`161`	`162`	`}`
`162`	`163`	`catch (ObjectDisposedException)`
`163`	`164`	`{`
`164`		`- bridge.Multiplexer.LogLocked(log, "(socket shutdown)");`
	`165`	`+ log?.WriteLine("(socket shutdown)");`
`165`	`166`	`try { RecordConnectionFailed(ConnectionFailureType.UnableToConnect, isInitialConnect: true); }`
`166`	`167`	`catch (Exception inner)`
`167`	`168`	`{`
`@@ -1251,7 +1252,7 @@ private static LocalCertificateSelectionCallback GetAmbientClientCertificateCall`
`1251`	`1252`	`return null;`
`1252`	`1253`	`}`
`1253`	`1254`
`1254`		`- internal async ValueTask<bool> ConnectedAsync(Socket socket, TextWriter log, SocketManager manager)`
	`1255`	`+ internal async ValueTask<bool> ConnectedAsync(Socket socket, LogProxy log, SocketManager manager)`
`1255`	`1256`	`{`
`1256`	`1257`	`var bridge = BridgeCouldBeNull;`
`1257`	`1258`	`if (bridge == null) return false;`
`@@ -1270,7 +1271,7 @@ internal async ValueTask<bool> ConnectedAsync(Socket socket, TextWriter log, Soc`
`1270`	`1271`
`1271`	`1272`	`if (config.Ssl)`
`1272`	`1273`	`{`
`1273`		`- bridge.Multiplexer.LogLocked(log, "Configuring SSL");`
	`1274`	`+ log?.WriteLine("Configuring TLS");`
`1274`	`1275`	`var host = config.SslHost;`
`1275`	`1276`	`if (string.IsNullOrWhiteSpace(host)) host = Format.ToStringHostOnly(bridge.ServerEndPoint.EndPoint);`
`1276`	`1277`
`@@ -1290,7 +1291,7 @@ internal async ValueTask<bool> ConnectedAsync(Socket socket, TextWriter log, Soc`
`1290`	`1291`	`bridge.Multiplexer?.SetAuthSuspect();`
`1291`	`1292`	`throw;`
`1292`	`1293`	`}`
`1293`		`- bridge.Multiplexer.LogLocked(log, $"SSL connection established successfully using protocol: {ssl.SslProtocol}");`
	`1294`	`+ log?.WriteLine($"TLS connection established successfully using protocol: {ssl.SslProtocol}");`
`1294`	`1295`	`}`
`1295`	`1296`	`catch (AuthenticationException authexception)`
`1296`	`1297`	`{`
`@@ -1308,7 +1309,7 @@ internal async ValueTask<bool> ConnectedAsync(Socket socket, TextWriter log, Soc`
`1308`	`1309`
`1309`	`1310`	`_ioPipe = pipe;`
`1310`	`1311`
`1311`		`- bridge.Multiplexer.LogLocked(log, "Connected {0}", bridge);`
	`1312`	`+ log?.WriteLine($"Connected {bridge}");`
`1312`	`1313`
`1313`	`1314`	`await bridge.OnConnectedAsync(this, log).ForAwait();`
`1314`	`1315`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -175,7 +175,7 @@ public virtual bool SetResult(PhysicalConnection connection, Message message, in`
`175`	`175`	`{`
`176`	`176`	`try`
`177`	`177`	`{`
`178`		`- bridge?.Multiplexer?.LogLocked(logging.Log, "Response from {0} / {1}: {2}", bridge, message.CommandAndKey, result);`
	`178`	`+ logging.Log?.WriteLine($"Response from {bridge} / {message.CommandAndKey}: {result}");`
`179`	`179`	`}`
`180`	`180`	`catch { }`
`181`	`181`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`using System.Text.RegularExpressions;`
`10`	`10`	`using System.Threading;`
`11`	`11`	`using System.Threading.Tasks;`
	`12`	`+using static StackExchange.Redis.ConnectionMultiplexer;`
`12`	`13`	`using static StackExchange.Redis.PhysicalBridge;`
`13`	`14`
`14`	`15`	`namespace StackExchange.Redis`
`@@ -155,7 +156,7 @@ public void Dispose()`
`155`	`156`	`tmp?.Dispose();`
`156`	`157`	`}`
`157`	`158`
`158`		`- public PhysicalBridge GetBridge(ConnectionType type, bool create = true, TextWriter log = null)`
	`159`	`+ public PhysicalBridge GetBridge(ConnectionType type, bool create = true, LogProxy log = null)`
`159`	`160`	`{`
`160`	`161`	`if (isDisposed) return null;`
`161`	`162`	`switch (type)`
`@@ -237,7 +238,7 @@ public void SetUnselectable(UnselectableFlags flags)`
`237`	`238`
`238`	`239`	`public ValueTask<WriteResult> TryWriteAsync(Message message) => GetBridge(message.Command)?.TryWriteAsync(message, isSlave) ?? new ValueTask<WriteResult>(WriteResult.NoConnectionAvailable);`
`239`	`240`
`240`		`- internal void Activate(ConnectionType type, TextWriter log)`
	`241`	`+ internal void Activate(ConnectionType type, LogProxy log)`
`241`	`242`	`{`
`242`	`243`	`GetBridge(type, true, log);`
`243`	`244`	`}`
`@@ -467,7 +468,7 @@ internal bool IsSelectable(RedisCommand command, bool allowDisconnected = false)`
`467`	`468`	`return bridge != null && (allowDisconnected \|\| bridge.IsConnected);`
`468`	`469`	`}`
`469`	`470`
`470`		`- internal Task OnEstablishingAsync(PhysicalConnection connection, TextWriter log)`
	`471`	`+ internal Task OnEstablishingAsync(PhysicalConnection connection, LogProxy log)`
`471`	`472`	`{`
`472`	`473`	`try`
`473`	`474`	`{`
`@@ -624,7 +625,7 @@ internal void ReportNextFailure()`
`624`	`625`	`subscription?.ReportNextFailure();`
`625`	`626`	`}`
`626`	`627`
`627`		`- internal Task<bool> SendTracer(TextWriter log = null)`
	`628`	`+ internal Task<bool> SendTracer(LogProxy log = null)`
`628`	`629`	`{`
`629`	`630`	`var msg = GetTracerMessage(false);`
`630`	`631`	`msg = LoggingMessage.Create(log, msg);`
`@@ -727,7 +728,7 @@ internal void WriteDirectOrQueueFireAndForgetSync<T>(PhysicalConnection connecti`
`727`	`728`	`}`
`728`	`729`	`}`
`729`	`730`
`730`		`- private PhysicalBridge CreateBridge(ConnectionType type, TextWriter log)`
	`731`	`+ private PhysicalBridge CreateBridge(ConnectionType type, LogProxy log)`
`731`	`732`	`{`
`732`	`733`	`if (Multiplexer.IsDisposed) return null;`
`733`	`734`	`Multiplexer.Trace(type.ToString());`
`@@ -736,9 +737,9 @@ private PhysicalBridge CreateBridge(ConnectionType type, TextWriter log)`
`736`	`737`	`return bridge;`
`737`	`738`	`}`
`738`	`739`
`739`		`- private async Task HandshakeAsync(PhysicalConnection connection, TextWriter log)`
	`740`	`+ private async Task HandshakeAsync(PhysicalConnection connection, LogProxy log)`
`740`	`741`	`{`
`741`		`- Multiplexer.LogLocked(log, "Server handshake");`
	`742`	`+ log?.WriteLine("Server handshake");`
`742`	`743`	`if (connection == null)`
`743`	`744`	`{`
`744`	`745`	`Multiplexer.Trace("No connection!?");`
`@@ -748,7 +749,7 @@ private async Task HandshakeAsync(PhysicalConnection connection, TextWriter log)`
`748`	`749`	`string password = Multiplexer.RawConfig.Password;`
`749`	`750`	`if (!string.IsNullOrWhiteSpace(password))`
`750`	`751`	`{`
`751`		`- Multiplexer.LogLocked(log, "Authenticating (password)");`
	`752`	`+ log?.WriteLine("Authenticating (password)");`
`752`	`753`	`msg = Message.Create(-1, CommandFlags.FireAndForget, RedisCommand.AUTH, (RedisValue)password);`
`753`	`754`	`msg.SetInternalCall();`
`754`	`755`	`await WriteDirectOrQueueFireAndForgetAsync(connection, msg, ResultProcessor.DemandOK).ForAwait();`
`@@ -762,7 +763,7 @@ private async Task HandshakeAsync(PhysicalConnection connection, TextWriter log)`
`762`	`763`	`name = nameSanitizer.Replace(name, "");`
`763`	`764`	`if (!string.IsNullOrWhiteSpace(name))`
`764`	`765`	`{`
`765`		`- Multiplexer.LogLocked(log, "Setting client name: {0}", name);`
	`766`	`+ log?.WriteLine($"Setting client name: {name}");`
`766`	`767`	`msg = Message.Create(-1, CommandFlags.FireAndForget, RedisCommand.CLIENT, RedisLiterals.SETNAME, (RedisValue)name);`
`767`	`768`	`msg.SetInternalCall();`
`768`	`769`	`await WriteDirectOrQueueFireAndForgetAsync(connection, msg, ResultProcessor.DemandOK).ForAwait();`
`@@ -779,10 +780,10 @@ private async Task HandshakeAsync(PhysicalConnection connection, TextWriter log)`
`779`	`780`
`780`	`781`	`if (connType == ConnectionType.Interactive)`
`781`	`782`	`{`
`782`		`- Multiplexer.LogLocked(log, "Auto-configure...");`
	`783`	`+ log?.WriteLine("Auto-configure...");`
`783`	`784`	`AutoConfigure(connection);`
`784`	`785`	`}`
`785`		`- Multiplexer.LogLocked(log, "Sending critical tracer: {0}", bridge);`
	`786`	`+ log?.WriteLine($"Sending critical tracer: {bridge}");`
`786`	`787`	`var tracer = GetTracerMessage(true);`
`787`	`788`	`tracer = LoggingMessage.Create(log, tracer);`
`788`	`789`	`await WriteDirectOrQueueFireAndForgetAsync(connection, tracer, ResultProcessor.EstablishConnection).ForAwait();`
`@@ -798,7 +799,7 @@ private async Task HandshakeAsync(PhysicalConnection connection, TextWriter log)`
`798`	`799`	`await WriteDirectOrQueueFireAndForgetAsync(connection, msg, ResultProcessor.TrackSubscriptions).ForAwait();`
`799`	`800`	`}`
`800`	`801`	`}`
`801`		`- Multiplexer.LogLocked(log, "Flushing outbound buffer");`
	`802`	`+ log?.WriteLine("Flushing outbound buffer");`
`802`	`803`	`await connection.FlushAsync().ForAwait();`
`803`	`804`	`}`
`804`	`805`