Revize d7aeccba

re #9570 Added code documentation to logger classes and properties

ld_client/LDClient/utils/loggers/ALogger.cs

@@ -2 +2 @@
 
 namespace LDClient.utils.loggers {
 
+    /// <summary>
+    /// This class implements all abstract functions of the logger.
+    /// It contains all functions (error, info, debug) that are present in any other standard logger.
+    /// Class is used as singleton design pattern
+    /// </summary>
     public abstract class ALogger : IDisposable {
 
+        /// <summary>
+        /// Logger verbosity type identifies how much information should be actually logged
+        /// </summary>
         private readonly LogVerbosity _verbosity;
+
+        /// <summary>
+        /// Current type of logger
+        /// </summary>
         private readonly LogFlow _logFlow;
 
+        /// <summary>
+        /// Queue of all not yet logged messages
+        /// </summary>
         private readonly Queue<Action> _queue = new();
+
+        /// <summary>
+        /// Synchronization prime used to identify if the is anything new in the queue 
+        /// </summary>
         private readonly ManualResetEvent _hasNewItems = new(false);
+        /// <summary>
+        /// Synchronization prime used to identify if the logger should be terminated
+        /// </summary>
         private readonly ManualResetEvent _terminate = new(false);
+        /// <summary>
+        /// Synchronization prime used to identify if the current thread is waiting
+        /// </summary>
         private readonly ManualResetEvent _waiting = new(false);
+
+        /// <summary>
+        /// Thread instance of logging thread
+        /// </summary>
         private readonly Thread _loggingThread;
 
+        /// <summary>
+        /// Instance of the default logger initialized with the lazy binding mechanism
+        /// </summary>
         private static readonly Lazy<ALogger> LazyLog = new(()
             => {
                 switch (Program.Config.LogFlowType) {
@@ -26 +58 @@
             }
         );
 
+        /// <summary>
+        /// Instance of the current logger type
+        /// </summary>
         public static ALogger Current => LazyLog.Value;
 
+        /// <summary>
+        /// Singleton constructor that initialized and starts the logger with arguments parsed by the config loader
+        /// </summary>
         protected ALogger() {
             _verbosity = Program.Config.LogVerbosityType;
             _logFlow = Program.Config.LogFlowType;
@@ -35 +73 @@
             _loggingThread.Start();
         }
 
+        /// <summary>
+        /// Creates new log with Info identifier
+        /// </summary>
+        /// <param name="message">Desired message to be logged</param>
         public void Info(string message) {
             Log(message, LogType.Info);
         }
 
+        /// <summary>
+        /// Creates new log with Debug identifier
+        /// </summary>
+        /// <param name="message">Desired message to be logged</param>
         public void Debug(string message) {
             Log(message, LogType.Debug);
         }
 
+        /// <summary>
+        /// Creates new log with Error identifier
+        /// </summary>
+        /// <param name="message">Desired message to be logged</param>
         public void Error(string message) {
             Log(message, LogType.Error);
         }
 
+        /// <summary>
+        /// Creates new log from the catched exception
+        /// </summary>
+        /// <param name="e">catched exception tha should be logged</param>
         public void Error(Exception e) {
             if (_verbosity != LogVerbosity.None) {
                 Log(UnwrapExceptionMessages(e), LogType.Error);
             }
         }
 
+        /// <summary>
+        /// Creates new string info about current logger configuration
+        /// </summary>
+        /// <returns></returns>
         public override string ToString() => $"Logger settings: [Type: {this.GetType().Name}, Verbosity: {_verbosity}, ";
-
+        
         protected abstract void CreateLog(string message);
 
+        /// <summary>
+        /// Waits for the logger to finish the logging
+        /// </summary>
         public void Flush() => _waiting.WaitOne();
 
+        /// <summary>
+        /// Function stops the logger thread
+        /// </summary>
         public void Dispose() {
             _terminate.Set();
             _loggingThread.Join();
         }
 
+        /// <summary>
+        /// Composes the log with actual timestamp, log type and its main message
+        /// </summary>
+        /// <param name="message">main message of the log</param>
+        /// <param name="logType">Type of the logged message</param>
+        /// <returns></returns>
         protected virtual string ComposeLogRow(string message, LogType logType) =>
             $"[{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss,fff", CultureInfo.InvariantCulture)} - {logType}] - {message}";
 
+        /// <summary>
+        /// Function creates log from the catched exception
+        /// </summary>
+        /// <param name="ex">catched exception tha should be logged</param>
+        /// <returns></returns>
         protected virtual string UnwrapExceptionMessages(Exception? ex) =>
             ex == null ? string.Empty : $"{ex}, Inner exception: {UnwrapExceptionMessages(ex.InnerException)} ";
         
-
+        /// <summary>
+        /// Function that periodically processes message queue
+        /// </summary>
         private void ProcessQueue() {
             while (true) {
                 _waiting.Set();
+                //wait until there is new item in the queue or until termination invoked
                 var i = WaitHandle.WaitAny(new WaitHandle[] { _hasNewItems, _terminate });
+                //was the termination invoked?
                 if (i == 1) return;
                 _hasNewItems.Reset();
                 _waiting.Reset();
@@ -91 +170 @@
             }
         }
 
+        /// <summary>
+        /// Creates new log string from the current timestamp 
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="logType"></param>
         private void Log(string message, LogType logType) {
             if (string.IsNullOrEmpty(message))
                 return;