Move to Microsoft.Extensions.Logging

AcceptanceTest/ATApplication.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using Microsoft.Extensions.Logging;
 using QuickFix;
 
 namespace AcceptanceTest
@@ -169,7 +170,8 @@ public void FromApp(Message message, SessionID sessionId)
             }
             catch (System.Exception e)
             {
-                Session.LookupSession(sessionId)?.Log.OnEvent($"Exception during FromApp: {e}\n while processing msg ({message})");
+                Session.LookupSession(sessionId)?.Log.Log(LogLevel.Error, e,
+                    "Exception during FromApp: {Error}\n while processing msg ({Message})", e, message);
             }
         }
 

AcceptanceTest/AcceptanceTest.csproj

@@ -19,6 +19,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.1" />
   </ItemGroup>
 
   <ItemGroup>

AcceptanceTest/TestBase.cs

@@ -2,6 +2,7 @@
 using QuickFix;
 using System.IO;
 using System.Net;
+using Microsoft.Extensions.Logging;
 using QuickFix.Logger;
 using QuickFix.Store;
 
@@ -23,11 +24,17 @@ public void Setup()
         var testApp = new ATApplication();
         var storeFactory = new MemoryStoreFactory();
 
-        ILogFactory? logFactory = settings.Get().Has("Verbose") && settings.Get().GetBool("Verbose")
-            ? new FileLogFactory(settings)
-            : new NullLogFactory();
-
-        _acceptor = new ThreadedSocketAcceptor(testApp, storeFactory, settings, logFactory);
+        var loggerFactory = new LoggerFactory();
+        if (settings.Get().Has("Verbose") && settings.Get().GetBool("Verbose"))
+        {
+            loggerFactory.AddProvider(new FileLoggerProvider(settings));
+        }
+        else
+        {
+            loggerFactory.AddProvider(new NullLoggerProvider());
+        }
+
+        _acceptor = new ThreadedSocketAcceptor(testApp, storeFactory, settings, loggerFactory);
 
         _acceptor.Start();
     }

Examples/Executor/Examples.Executor.csproj

@@ -40,4 +40,8 @@
     </None>
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.1" />
+  </ItemGroup>
+
 </Project>

Examples/Executor/Program.cs

@@ -1,4 +1,5 @@
 using System;
+using Microsoft.Extensions.Logging;
 using QuickFix;
 using QuickFix.Logger;
 using QuickFix.Store;
@@ -27,9 +28,14 @@ static void Main(string[] args)
                 SessionSettings settings = new SessionSettings(args[0]);
                 IApplication executorApp = new Executor();
                 IMessageStoreFactory storeFactory = new FileStoreFactory(settings);
-                ILogFactory logFactory = new ScreenLogFactory(settings);
-                //ILogFactory logFactory = new FileLogFactory(settings);
-                ThreadedSocketAcceptor acceptor = new ThreadedSocketAcceptor(executorApp, storeFactory, settings, logFactory);
+                var loggerFactory = LoggerFactory.Create(builder =>
+                {
+                    builder.SetMinimumLevel(LogLevel.Trace);
+                    builder.AddProvider(new ScreenLoggerProvider(settings));
+                    builder.AddProvider(new FileLoggerProvider(settings));
+                });
+                ThreadedSocketAcceptor acceptor =
+                    new ThreadedSocketAcceptor(executorApp, storeFactory, settings, loggerFactory);
                 HttpServer srv = new HttpServer(HttpServerPrefix, settings);
 
                 acceptor.Start();

Examples/SimpleAcceptor/Examples.SimpleAcceptor.csproj

@@ -34,4 +34,8 @@
     </None>
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.1" />
+  </ItemGroup>
+
 </Project>

Examples/SimpleAcceptor/Program.cs

@@ -1,4 +1,5 @@
 using System;
+using Microsoft.Extensions.Logging;
 using QuickFix;
 using QuickFix.Logger;
 using QuickFix.Store;
@@ -30,8 +31,11 @@ static void Main(string[] args)
                 SessionSettings settings = new SessionSettings(args[0]);
                 IApplication app = new SimpleAcceptorApp();
                 IMessageStoreFactory storeFactory = new FileStoreFactory(settings);
-                ILogFactory logFactory = new FileLogFactory(settings);
-                IAcceptor acceptor = new ThreadedSocketAcceptor(app, storeFactory, settings, logFactory);
+                var loggerFactory = LoggerFactory.Create(builder =>
+                {
+                    builder.AddProvider(new FileLoggerProvider(settings));
+                });
+                IAcceptor acceptor = new ThreadedSocketAcceptor(app, storeFactory, settings, loggerFactory);
 
                 acceptor.Start();
                 Console.WriteLine("press <enter> to quit");

Examples/TradeClient/Examples.TradeClient.csproj

@@ -35,4 +35,8 @@
     </None>
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.1" />
+  </ItemGroup>
+
 </Project>

Examples/TradeClient/Program.cs

@@ -1,4 +1,5 @@
 using System;
+using Microsoft.Extensions.Logging;
 using QuickFix.Logger;
 using QuickFix.Store;
 
@@ -31,9 +32,12 @@ static void Main(string[] args)
                 QuickFix.SessionSettings settings = new QuickFix.SessionSettings(file);
                 TradeClientApp application = new TradeClientApp();
                 IMessageStoreFactory storeFactory = new FileStoreFactory(settings);
-                ILogFactory logFactory = new ScreenLogFactory(settings);
-                //ILogFactory logFactory = new FileLogFactory(settings);
-                QuickFix.Transport.SocketInitiator initiator = new QuickFix.Transport.SocketInitiator(application, storeFactory, settings, logFactory);
+                var loggerFactory = LoggerFactory.Create(builder =>
+                {
+                    builder.AddProvider(new ScreenLoggerProvider(settings));
+                    // builder.AddProvider(new FileLogProvider(settings));
+                });
+                QuickFix.Transport.SocketInitiator initiator = new QuickFix.Transport.SocketInitiator(application, storeFactory, settings, loggerFactory);
 
                 // this is a developer-test kludge.  do not emulate.
                 application.MyInitiator = initiator;

QuickFIXn/AbstractInitiator.cs

@@ -1,6 +1,8 @@
 using System.Threading;
 using System.Collections.Generic;
 using System;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using QuickFix.Logger;
 using QuickFix.Store;
 
@@ -20,22 +22,43 @@ public abstract class AbstractInitiator : IInitiator
         private readonly SessionFactory _sessionFactory;
         private Thread? _thread;
 
-        protected readonly NonSessionLog _nonSessionLog;
+        protected readonly ILogger _nonSessionLog;
 
         public bool IsStopped { get; private set; } = true;
 
+        [Obsolete("Use \"Microsoft.Extensions.Logging.ILoggerFactory\" instead of \"QuickFix.Logger.ILogFactory\".")]
         protected AbstractInitiator(
             IApplication app,
             IMessageStoreFactory storeFactory,
             SessionSettings settings,
-            ILogFactory? logFactoryNullable,
-            IMessageFactory? messageFactoryNullable)
+            ILogFactory? logFactoryNullable = null,
+            IMessageFactory? messageFactoryNullable = null)
         {
             _settings = settings;
-            var logFactory = logFactoryNullable ?? new NullLogFactory();
+            ILoggerFactory logFactory = logFactoryNullable is null
+                ? NullLoggerFactory.Instance
+                : new LogFactoryAdapter(logFactoryNullable, settings);
             var msgFactory = messageFactoryNullable ?? new DefaultMessageFactory();
             _sessionFactory = new SessionFactory(app, storeFactory, logFactory, msgFactory);
-            _nonSessionLog = new NonSessionLog(logFactory);
+            _nonSessionLog = logFactory.CreateLogger("QuickFix");
+
+            HashSet<SessionID> definedSessions = _settings.GetSessions();
+            if (0 == definedSessions.Count)
+                throw new ConfigError("No sessions defined");
+        }
+
+        protected AbstractInitiator(
+            IApplication app,
+            IMessageStoreFactory storeFactory,
+            SessionSettings settings,
+            ILoggerFactory? logFactoryNullable = null,
+            IMessageFactory? messageFactoryNullable = null)
+        {
+            _settings = settings;
+            var logFactory = logFactoryNullable ?? new NullLoggerFactory();
+            var msgFactory = messageFactoryNullable ?? new DefaultMessageFactory();
+            _sessionFactory = new SessionFactory(app, storeFactory, logFactory, msgFactory);
+            _nonSessionLog = logFactory.CreateLogger("QuickFix");
 
             HashSet<SessionID> definedSessions = _settings.GetSessions();
             if (0 == definedSessions.Count)

QuickFIXn/AcceptorSocketDescriptor.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Net;
-using QuickFix.Logger;
+using Microsoft.Extensions.Logging;
 
 namespace QuickFix
 {
@@ -15,7 +15,7 @@ internal class AcceptorSocketDescriptor
         public AcceptorSocketDescriptor(
             IPEndPoint socketEndPoint,
             SocketSettings socketSettings,
-            NonSessionLog nonSessionLog)
+            ILogger nonSessionLog)
         {
             Address = socketEndPoint;
             SocketReactor = new ThreadedSocketReactor(Address, socketSettings, this, nonSessionLog);
@@ -26,7 +26,7 @@ public AcceptorSocketDescriptor(
             IPEndPoint socketEndPoint,
             SocketSettings socketSettings,
             SettingsDictionary sessionDict,
-            NonSessionLog nonSessionLog) : this(socketEndPoint, socketSettings, nonSessionLog)
+            ILogger nonSessionLog) : this(socketEndPoint, socketSettings, nonSessionLog)
         { }
 
         internal void AcceptSession(Session session)

QuickFIXn/ClientHandlerThread.cs

@@ -1,7 +1,7 @@
 using System.Net.Sockets;
 using System.Threading;
 using System;
-using QuickFix.Logger;
+using Microsoft.Extensions.Logging;
 
 namespace QuickFix
 {
@@ -36,7 +36,7 @@ internal ClientHandlerThread(
             long clientId,
             SocketSettings socketSettings,
             AcceptorSocketDescriptor? acceptorDescriptor,
-            NonSessionLog nonSessionLog
+            ILogger nonSessionLog
         ) {
             Id = clientId;
             _socketReader = new SocketReader(tcpClient, socketSettings, this, acceptorDescriptor, nonSessionLog);

QuickFIXn/Logger/CompositeLog.cs

@@ -5,6 +5,7 @@ namespace QuickFix.Logger;
 /// <summary>
 /// File log implementation
 /// </summary>
+[Obsolete("Use Microsoft.Extensions.Logging instead.")]
 internal class CompositeLog : ILog
 {
     private readonly ILog[] _logs;

QuickFIXn/Logger/CompositeLogFactory.cs

@@ -1,11 +1,13 @@
-using System.Linq;
+using System;
+using System.Linq;
 
 namespace QuickFix.Logger;
 
 /// <summary>
 /// Allows multiple log factories to be used with QuickFIX/N.
 /// For example, you could log events to the console and also log all events and messages to a file.
 /// </summary>
+[Obsolete("Use Microsoft.Extensions.Logging instead")]
 public class CompositeLogFactory : ILogFactory
 {
     private readonly ILogFactory[] _factories;

QuickFIXn/Logger/FileLog.cs

@@ -7,6 +7,7 @@ namespace QuickFix.Logger;
 /// <summary>
 /// File log implementation
 /// </summary>
+[Obsolete("Use Microsoft.Extensions.Logging instead")]
 public class FileLog : ILog
 {
     private readonly object _sync = new();

QuickFIXn/Logger/FileLogFactory.cs

@@ -1,8 +1,11 @@
-namespace QuickFix.Logger;
+using System;
+
+namespace QuickFix.Logger;
 
 /// <summary>
 /// Creates a message store that stores messages in a file
 /// </summary>
+[Obsolete("Use Microsoft.Extensions.Logging instead")]
 public class FileLogFactory : ILogFactory
 {
     private readonly SessionSettings _settings;

QuickFIXn/Logger/FileLogger.cs

@@ -0,0 +1,97 @@
+using System;
+using Microsoft.Extensions.Logging;
+using QuickFix.Fields.Converters;
+using QuickFix.Util;
+
+namespace QuickFix.Logger;
+
+public class FileLogger : ILogger, IDisposable
+{
+    private readonly object _messagesLock = new();
+    private readonly object _eventsLock = new();
+
+    private System.IO.StreamWriter _messageLog;
+    private System.IO.StreamWriter _eventLog;
+
+    private readonly string _messageLogFileName;
+    private readonly string _eventLogFileName;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="fileLogPath">
+    /// All back or forward slashes in this path will be converted as needed to the running platform's preferred
+    /// path separator (i.e. "/" will become "\" on windows, else "\" will become "/" on all other platforms)
+    /// </param>
+    /// <param name="sessionId"></param>
+    internal FileLogger(string fileLogPath, SessionID sessionId)
+    {
+        string prefix = Prefix(sessionId);
+
+        string normalizedPath = StringUtil.FixSlashes(fileLogPath);
+
+        if (!System.IO.Directory.Exists(normalizedPath))
+            System.IO.Directory.CreateDirectory(normalizedPath);
+
+        _messageLogFileName = System.IO.Path.Combine(normalizedPath, prefix + ".messages.current.log");
+        _eventLogFileName = System.IO.Path.Combine(normalizedPath, prefix + ".event.current.log");
+
+        _messageLog = new System.IO.StreamWriter(_messageLogFileName, true);
+        _eventLog = new System.IO.StreamWriter(_eventLogFileName, true);
+
+        _messageLog.AutoFlush = true;
+        _eventLog.AutoFlush = true;
+    }
+
+    public static string Prefix(SessionID sessionId)
+    {
+        System.Text.StringBuilder prefix = new System.Text.StringBuilder(sessionId.BeginString)
+            .Append('-').Append(sessionId.SenderCompID);
+        if (SessionID.IsSet(sessionId.SenderSubID))
+            prefix.Append('_').Append(sessionId.SenderSubID);
+        if (SessionID.IsSet(sessionId.SenderLocationID))
+            prefix.Append('_').Append(sessionId.SenderLocationID);
+        prefix.Append('-').Append(sessionId.TargetCompID);
+        if (SessionID.IsSet(sessionId.TargetSubID))
+            prefix.Append('_').Append(sessionId.TargetSubID);
+        if (SessionID.IsSet(sessionId.TargetLocationID))
+            prefix.Append('_').Append(sessionId.TargetLocationID);
+
+        if (SessionID.IsSet(sessionId.SessionQualifier))
+            prefix.Append('-').Append(sessionId.SessionQualifier);
+
+        return prefix.ToString();
+    }
+
+    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception,
+        Func<TState, Exception?, string> formatter)
+    {
+        if (!IsEnabled(logLevel)) return;
+        if (eventId == LogEventIds.IncomingMessage || eventId == LogEventIds.OutgoingMessage)
+        {
+            lock (_messagesLock)
+            {
+                _messageLog.WriteLine(
+                    $"{DateTimeConverter.ToFIX(DateTime.UtcNow, TimeStampPrecision.Millisecond)} : {formatter(state, exception)}");
+            }
+        }
+        else
+        {
+            lock (_eventsLock)
+            {
+                _eventLog.WriteLine(
+                    $"{DateTimeConverter.ToFIX(DateTime.UtcNow, TimeStampPrecision.Millisecond)} : {formatter(state, exception)}");
+            }
+        }
+    }
+
+    public bool IsEnabled(LogLevel logLevel) => logLevel != LogLevel.None;
+
+    public IDisposable? BeginScope<TState>(TState state) where TState : notnull => default!;
+
+    public void Dispose()
+    {
+        _messageLog.Dispose();
+        _eventLog.Dispose();
+    }
+}