Replace DiagnosticAbstration with Microsoft.Extensions.Logging.Abstractions

docfx/logging.md

@@ -1,7 +1,7 @@
 Logging
 =================
 
-SSH.NET uses the `Microsoft.Extensions.Logging` API to log diagnostic messages. In order to access the log messages of SSH.NET in your own application for diagnosis, register your own `ILoggerFactory` before using the SSH.NET APIs, for example:
+SSH.NET uses the [Microsoft.Extensions.Logging](https://learn.microsoft.com/dotnet/core/extensions/logging) API to log diagnostic messages. In order to access the log messages of SSH.NET in your own application for diagnosis, register your own `ILoggerFactory` before using the SSH.NET APIs, for example:
 
 ```cs
 ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>

src/Renci.SshNet/Common/Extensions.cs

@@ -351,5 +351,12 @@ internal static bool IsConnected(this Socket socket)
 
             return socket.Connected;
         }
+
+        internal static string Join(this IEnumerable<string> values, string separator)
+        {
+            // Used to avoid analyzers asking to "use an overload with a char parameter"
+            // which is not available on all targets.
+            return string.Join(separator, values);
+        }
     }
 }

src/Renci.SshNet/Security/KeyExchange.cs

@@ -78,12 +78,23 @@ public virtual void Start(Session session, KeyExchangeInitMessage message, bool
                 SendMessage(session.ClientInitMessage);
             }
 
-            // Determine encryption algorithm
+            // Determine client encryption algorithm
             var clientEncryptionAlgorithmName = (from b in session.ConnectionInfo.Encryptions.Keys
                                                  from a in message.EncryptionAlgorithmsClientToServer
                                                  where a == b
                                                  select a).FirstOrDefault();
 
+            if (_logger.IsEnabled(LogLevel.Trace))
+            {
+                _logger.LogTrace("[{SessionId}] Encryption client to server: we offer {WeOffer}",
+                    Session.SessionIdHex,
+                    session.ConnectionInfo.Encryptions.Keys.Join(","));
+
+                _logger.LogTrace("[{SessionId}] Encryption client to server: they offer {TheyOffer}",
+                    Session.SessionIdHex,
+                    message.EncryptionAlgorithmsClientToServer.Join(","));
+            }
+
             if (string.IsNullOrEmpty(clientEncryptionAlgorithmName))
             {
                 throw new SshConnectionException("Client encryption algorithm not found", DisconnectReason.KeyExchangeFailed);
@@ -92,11 +103,23 @@ from a in message.EncryptionAlgorithmsClientToServer
             session.ConnectionInfo.CurrentClientEncryption = clientEncryptionAlgorithmName;
             _clientCipherInfo = session.ConnectionInfo.Encryptions[clientEncryptionAlgorithmName];
 
-            // Determine encryption algorithm
+            // Determine server encryption algorithm
             var serverDecryptionAlgorithmName = (from b in session.ConnectionInfo.Encryptions.Keys
                                                  from a in message.EncryptionAlgorithmsServerToClient
                                                  where a == b
                                                  select a).FirstOrDefault();
+
+            if (_logger.IsEnabled(LogLevel.Trace))
+            {
+                _logger.LogTrace("[{SessionId}] Encryption server to client: we offer {WeOffer}",
+                    Session.SessionIdHex,
+                    session.ConnectionInfo.Encryptions.Keys.Join(","));
+
+                _logger.LogTrace("[{SessionId}] Encryption server to client: they offer {TheyOffer}",
+                    Session.SessionIdHex,
+                    message.EncryptionAlgorithmsServerToClient.Join(","));
+            }
+
             if (string.IsNullOrEmpty(serverDecryptionAlgorithmName))
             {
                 throw new SshConnectionException("Server decryption algorithm not found", DisconnectReason.KeyExchangeFailed);
@@ -112,6 +135,18 @@ from a in message.EncryptionAlgorithmsServerToClient
                                                from a in message.MacAlgorithmsClientToServer
                                                where a == b
                                                select a).FirstOrDefault();
+
+                if (_logger.IsEnabled(LogLevel.Trace))
+                {
+                    _logger.LogTrace("[{SessionId}] MAC client to server: we offer {WeOffer}",
+                        Session.SessionIdHex,
+                        session.ConnectionInfo.HmacAlgorithms.Keys.Join(","));
+
+                    _logger.LogTrace("[{SessionId}] MAC client to server: they offer {TheyOffer}",
+                        Session.SessionIdHex,
+                        message.MacAlgorithmsClientToServer.Join(","));
+                }
+
                 if (string.IsNullOrEmpty(clientHmacAlgorithmName))
                 {
                     throw new SshConnectionException("Client HMAC algorithm not found", DisconnectReason.KeyExchangeFailed);
@@ -128,6 +163,18 @@ from a in message.MacAlgorithmsClientToServer
                                                from a in message.MacAlgorithmsServerToClient
                                                where a == b
                                                select a).FirstOrDefault();
+
+                if (_logger.IsEnabled(LogLevel.Trace))
+                {
+                    _logger.LogTrace("[{SessionId}] MAC server to client: we offer {WeOffer}",
+                        Session.SessionIdHex,
+                        session.ConnectionInfo.HmacAlgorithms.Keys.Join(","));
+
+                    _logger.LogTrace("[{SessionId}] MAC server to client: they offer {TheyOffer}",
+                        Session.SessionIdHex,
+                        message.MacAlgorithmsServerToClient.Join(","));
+                }
+
                 if (string.IsNullOrEmpty(serverHmacAlgorithmName))
                 {
                     throw new SshConnectionException("Server HMAC algorithm not found", DisconnectReason.KeyExchangeFailed);
@@ -142,6 +189,18 @@ from a in message.MacAlgorithmsServerToClient
                                             from a in message.CompressionAlgorithmsClientToServer
                                             where a == b
                                             select a).FirstOrDefault();
+
+            if (_logger.IsEnabled(LogLevel.Trace))
+            {
+                _logger.LogTrace("[{SessionId}] Compression client to server: we offer {WeOffer}",
+                    Session.SessionIdHex,
+                    session.ConnectionInfo.CompressionAlgorithms.Keys.Join(","));
+
+                _logger.LogTrace("[{SessionId}] Compression client to server: they offer {TheyOffer}",
+                    Session.SessionIdHex,
+                    message.CompressionAlgorithmsClientToServer.Join(","));
+            }
+
             if (string.IsNullOrEmpty(compressionAlgorithmName))
             {
                 throw new SshConnectionException("Compression algorithm not found", DisconnectReason.KeyExchangeFailed);
@@ -155,6 +214,18 @@ from a in message.CompressionAlgorithmsClientToServer
                                               from a in message.CompressionAlgorithmsServerToClient
                                               where a == b
                                               select a).FirstOrDefault();
+
+            if (_logger.IsEnabled(LogLevel.Trace))
+            {
+                _logger.LogTrace("[{SessionId}] Compression server to client: we offer {WeOffer}",
+                    Session.SessionIdHex,
+                    session.ConnectionInfo.CompressionAlgorithms.Keys.Join(","));
+
+                _logger.LogTrace("[{SessionId}] Compression server to client: they offer {TheyOffer}",
+                    Session.SessionIdHex,
+                    message.CompressionAlgorithmsServerToClient.Join(","));
+            }
+
             if (string.IsNullOrEmpty(decompressionAlgorithmName))
             {
                 throw new SshConnectionException("Decompression algorithm not found", DisconnectReason.KeyExchangeFailed);

src/Renci.SshNet/Session.cs

@@ -1047,9 +1047,9 @@ internal void SendMessage(Message message)
                 WaitOnHandle(_keyExchangeCompletedWaitHandle.WaitHandle);
             }
 
-            if (_logger.IsEnabled(LogLevel.Debug))
+            if (_logger.IsEnabled(LogLevel.Trace))
             {
-                _logger.LogDebug("[{SessionId}] Sending message '{MessageType}' to server: '{Message}'.", SessionIdHex, message.GetType().Name, message);
+                _logger.LogTrace("[{SessionId}] Sending message {MessageName}({MessageNumber}) to server: '{Message}'.", SessionIdHex, message.MessageName, message.MessageNumber, message.ToString());
             }
 
             var paddingMultiplier = _clientCipher is null ? (byte)8 : Math.Max((byte)8, _clientCipher.MinimumSize);
@@ -1189,12 +1189,12 @@ private bool TrySendMessage(Message message)
             }
             catch (SshException ex)
             {
-                _logger.LogInformation(ex, "Failure sending message '{MessageType}' to server: '{Message}'", message.GetType().Name, message);
+                _logger.LogInformation(ex, "Failure sending message {MessageName}({MessageNumber}) to server: '{Message}'", message.MessageName, message.MessageNumber, message.ToString());
                 return false;
             }
             catch (SocketException ex)
             {
-                _logger.LogInformation(ex, "Failure sending message '{MessageType}' to server: '{Message}'", message.GetType().Name, message);
+                _logger.LogInformation(ex, "Failure sending message {MessageName}({MessageNumber}) to server: '{Message}'", message.MessageName, message.MessageNumber, message.ToString());
                 return false;
             }
         }
@@ -1831,9 +1831,9 @@ private Message LoadMessage(byte[] data, int offset, int count)
             var message = _sshMessageFactory.Create(messageType);
             message.Load(data, offset + 1, count - 1);
 
-            if (_logger.IsEnabled(LogLevel.Debug))
+            if (_logger.IsEnabled(LogLevel.Trace))
             {
-                _logger.LogDebug("[{SessionId}] Received message '{MessageType}' from server: '{Message}'.", SessionIdHex, message.GetType().Name, message);
+                _logger.LogTrace("[{SessionId}] Received message {MessageName}({MessageNumber}) from server: '{Message}'.", SessionIdHex, message.MessageName, message.MessageNumber, message.ToString());
             }
 
             return message;

test/Renci.SshNet.IntegrationTests/TestsFixtures/InfrastructureFixture.cs

@@ -2,23 +2,27 @@
 using DotNet.Testcontainers.Containers;
 using DotNet.Testcontainers.Images;
 
+using Microsoft.Extensions.Logging;
+
 namespace Renci.SshNet.IntegrationTests.TestsFixtures
 {
     public sealed class InfrastructureFixture : IDisposable
     {
         private InfrastructureFixture()
         {
+            _loggerFactory = LoggerFactory.Create(builder =>
+            {
+                builder.SetMinimumLevel(LogLevel.Debug);
+                builder.AddFilter("testcontainers", LogLevel.Information);
+                builder.AddConsole();
+            });
+
+            SshNetLoggingConfiguration.InitializeLogging(_loggerFactory);
         }
 
-        private static readonly Lazy<InfrastructureFixture> InstanceLazy = new Lazy<InfrastructureFixture>(() => new InfrastructureFixture());
+        public static InfrastructureFixture Instance { get; } = new InfrastructureFixture();
 
-        public static InfrastructureFixture Instance
-        {
-            get
-            {
-                return InstanceLazy.Value;
-            }
-        }
+        private readonly ILoggerFactory _loggerFactory;
 
         private IContainer _sshServer;
 
@@ -34,11 +38,14 @@ public static InfrastructureFixture Instance
 
         public async Task InitializeAsync()
         {
+            var containerLogger = _loggerFactory.CreateLogger("testcontainers");
+
             _sshServerImage = new ImageFromDockerfileBuilder()
                 .WithName("renci-ssh-tests-server-image")
                 .WithDockerfileDirectory(CommonDirectoryPath.GetSolutionDirectory(), Path.Combine("test", "Renci.SshNet.IntegrationTests"))
                 .WithDockerfile("Dockerfile.TestServer")
                 .WithDeleteIfExists(true)
+                .WithLogger(containerLogger)
                 .Build();
 
             await _sshServerImage.CreateAsync();
@@ -47,6 +54,7 @@ public async Task InitializeAsync()
                 .WithHostname("renci-ssh-tests-server")
                 .WithImage(_sshServerImage)
                 .WithPortBinding(22, true)
+                .WithLogger(containerLogger)
                 .Build();
 
             await _sshServer.StartAsync();

test/Renci.SshNet.IntegrationTests/TestsFixtures/IntegrationTestBase.cs

@@ -8,6 +8,7 @@ namespace Renci.SshNet.IntegrationTests.TestsFixtures
     public abstract class IntegrationTestBase
     {
         private readonly InfrastructureFixture _infrastructureFixture;
+        private readonly ILogger _logger;
 
         /// <summary>
         /// The SSH Server host name.
@@ -56,24 +57,10 @@ public SshUser User
         protected IntegrationTestBase()
         {
             _infrastructureFixture = InfrastructureFixture.Instance;
-            ShowInfrastructureInformation();
-        }
-
-        static IntegrationTestBase()
-        {
-            ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
-            {
-                builder.SetMinimumLevel(LogLevel.Information);
-                builder.AddConsole();
-            });
-
-            SshNetLoggingConfiguration.InitializeLogging(loggerFactory);
-        }
-
-        private void ShowInfrastructureInformation()
-        {
-            Console.WriteLine($"SSH Server host name: {_infrastructureFixture.SshServerHostName}");
-            Console.WriteLine($"SSH Server port: {_infrastructureFixture.SshServerPort}");
+            _logger = SshNetLoggingConfiguration.LoggerFactory.CreateLogger(GetType());
+            _logger.LogDebug("SSH Server: {Host}:{Port}",
+                _infrastructureFixture.SshServerHostName,
+                _infrastructureFixture.SshServerPort);
         }
 
         /// <summary>