Logging Utilities and Helper Methods

Readme.md

1. Serilog (Create Logger and File Text Write) (Serilog.Textfilewriter.cs)
2. sdfsf
3. Microsoft.Extensions.Logging (Factory Instance Create - Manual)
4. CustomLogger.cs

CustomLogger.cs

using System;

namespace CoreApp
{
    public class CustomLogger
    {
        private static object lockObject = new object();

        private string _baseFolderForLogs = string.Empty;
        private string _baseFileNameForLogs = string.Empty;
        private bool _requireTimeStamp = false;
        public CustomLogger(string folderName = null, string fileName = null, bool requireTimeStamp = false)
        {
            _requireTimeStamp = requireTimeStamp;
            if (string.IsNullOrWhiteSpace(folderName))
            {
                folderName = "Logs";
            }

            if (string.IsNullOrWhiteSpace(fileName))
            {
                _baseFileNameForLogs = "CustomLoggerLogs-" + System.DateTime.Now.ToString("yyyy-MM-dd") + ".txt";
            }

            _baseFolderForLogs = System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, folderName);
            if (!System.IO.Directory.Exists(_baseFolderForLogs)) System.IO.Directory.CreateDirectory(_baseFolderForLogs);
            _baseFileNameForLogs = System.IO.Path.Combine(_baseFolderForLogs, _baseFileNameForLogs);
        }

        public void Information(string info,object obj = null)
        {
            log(info, obj);
        }

        public void Error(Exception Ex, string info = null)
        {
            LogException(Ex, info);
        }

        public void Error(string info)
        {
            log(info);
        }

        public void log(string message, object obj = null, bool? requireTimeStamp = null)
        {
            requireTimeStamp = requireTimeStamp.HasValue ? requireTimeStamp.Value : _requireTimeStamp;

            if (requireTimeStamp.Value == true)
            {
                message = DateTime.Now.ToString("dd/MM/yyyy HH:MM:ss", System.Globalization.CultureInfo.InvariantCulture)
                    + ": " + message;
            }
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            sb.AppendLine(message);

            if (obj != null && obj.GetType().IsClass == true)
            {
                try
                {
                    sb.AppendLine(Newtonsoft.Json.JsonConvert.SerializeObject(obj, Newtonsoft.Json.Formatting.Indented));
                }
                catch (Exception Ex)
                {
                    sb.AppendLine("Failed to Deserialzed Object named " + obj.GetType().FullName
                        + Environment.NewLine + Ex.Message + Environment.NewLine
                        + Ex.StackTrace);
                }
            }
            else if (obj != null && obj.GetType().GetType() == typeof(string))
            {
                sb.AppendLine(obj.ToString());
            }

            WriteFile(sb.ToString(), _baseFileNameForLogs);
        }

        public void LogException(Exception exception, string info = null)
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder("***ERROR Starts***");
            if (!string.IsNullOrWhiteSpace(info))
            {
                sb.AppendLine(info);
            }
            do
            {
                sb.AppendLine("\t" + exception.Source + " - " + exception.Message);
                sb.AppendLine("\t" + exception.StackTrace);
                exception = exception.InnerException;
            } while (exception != null);
            sb.AppendLine("******Error Ends***********");
            log(sb.ToString(), null, true);
        }

        public static void WriteFile(string message, string filePath, bool printWriteLine = true)
        {
            lock (lockObject)
            {
                using (System.IO.StreamWriter sw = new System.IO.StreamWriter(filePath, true))
                {
                    if (printWriteLine)
                    {
                        sw.WriteLine(message);
                    }
                    else
                    {
                        sw.Write(message);
                    }
                }
            }
        }

    }
}

ILoggerFactory.cs

//Ref https://learn.microsoft.com/en-us/dotnet/core/extensions/logging?tabs=command-line#non-host-console-app
using var loggerFactory = LoggerFactory.Create(builder =>
{
    builder
        .AddFilter("Microsoft", LogLevel.Warning)
        .AddFilter("System", LogLevel.Warning)
        .AddFilter("LoggingConsoleApp.Program", LogLevel.Debug)
        .AddConsole();
});

//More Slim Way - LoggerFactory.Create(builder => builder.AddConsole());

ILogger logger = loggerFactory.CreateLogger<Program>();
logger.LogInformation("Example log message");

Serilog.Textfilewriter.cs

 string folderPath = string.Empty;
folderPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "logs");
if (!Directory.Exists(folderPath))
{
    Directory.CreateDirectory(folderPath);
}
var filePath = Path.Combine(folderPath, "log.txt");
_logger = Log.Logger =
    new LoggerConfiguration().WriteTo.File(filePath, rollingInterval: RollingInterval.Day)
    .CreateLogger();
_utils = new Utils(_logger);


 public static class SerilogHelper
    {
        /// <summary>
        /// By Default Log Writers will be created in /logs folder in root app
        /// </summary>
        /// <param name="absoluteFolderPath">Leave this null if not sure</param>
        /// <returns></returns>
        public static ILogger GetSerilogTextWriter(string absoluteFolderPath = null)
        {
            if (Log.Logger != null && Log.Logger.GetType().Name != "SilentLogger")
            {                
                return Log.Logger;                
            }

            string filePath;
            if (string.IsNullOrEmpty(absoluteFolderPath) == false)
            {
                filePath = Path.Combine(absoluteFolderPath, "log.txt");
            }
            else
            {
                filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "logs", "log.txt");
            }

            return new LoggerConfiguration().WriteTo.File(filePath, rollingInterval: RollingInterval.Day).CreateLogger();            
        }
    }