Mastering Application Insights: Logging using NLOG, log4net and serilog

Install-Package NLog.Web.AspNetCore

var builder = WebApplication.CreateBuilder(args);

// NLog configuration
builder.Logging.ClearProviders();
builder.Host.UseNLog();

var app = builder.Build();

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      autoReload="true"
      throwConfigExceptions="true"
      internalLogLevel="Info"
      internalLogFile="internal-nlog.txt">

  <!-- Define where the logs are written -->
  <targets>
    <!-- Write logs to file -->
    <target xsi:type="File" name="logfile" fileName="${basedir}/logs/logfile-${shortdate}.txt"
            layout="${longdate} | ${level:uppercase=true} | ${logger} | ${message} ${exception:format=toString,Data}" />

    <!-- Write logs to console -->
    <target xsi:type="Console" name="logconsole"
            layout="${date:format=HH\:mm\:ss} ${level} ${message}" />
  </targets>

  <!-- Rules for mapping loggers to targets -->
  <rules>
    <!-- All logs, including from Microsoft.*, will be sent to "logconsole" -->
    <logger name="*" minlevel="Debug" writeTo="logconsole" />

    <!-- Skip Microsoft logs and only write them to "logfile" -->
    <logger name="Microsoft.*" minlevel="Info" writeTo="logfile" final="true" />

    <!-- All other logs from application will be written to both "logfile" and "logconsole" -->
    <logger name="*" minlevel="Debug" writeTo="logfile,logconsole" />
  </rules>
</nlog>

"NLog": {
  "autoReload": true,
  "throwConfigExceptions": true,
  "internalLogLevel": "Warn",
  "internalLogFile": "internal-nlog.txt",
  "targets": {
    "logfile": {
      "type": "File",
      "fileName": "${currentdir}/logs/nlog-${shortdate}.log",
      "layout": "${longdate} ${uppercase:${level}} ${message} ${exception:format=toString}"
    },
    "console": {
      "type": "Console"
    }
  },
  "rules": [
    {
      "logger": "*",
      "minLevel": "Debug",
      "writeTo": "logfile,console"
    }
  ]
}

// Adding NLog to ASP.NET Core
builder.Logging.ClearProviders();
builder.Logging.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
builder.Host.UseNLog(); // This configures NLog using NLog's own section in appsettings.json

NLog.LogManager.Setup().LoadConfiguration(builder => {
   builder.ForLogger().WriteToConsole()
});

NLog.LogManager.Setup().LoadConfiguration(builder => {
   builder.ForLogger().FilterMinLevel(LogLevel.Info).WriteToConsole();
   builder.ForLogger().FilterMinLevel(LogLevel.Debug).WriteToFile(fileName: "App_${shortdate}.txt");
});

NLog.LogManager.Setup().LoadConfiguration(builder => {
   builder.ForLogger().FilterMinLevel(LogLevel.Info).WriteTo(new MyCustomTarget() { Layout = "${message}" });
});

NLog.LogManager.Setup().LoadConfiguration(builder => {
   builder.ForLogger("Microsoft.*").WriteToNil(finalMinLevel: LogLevel.Warn);
   builder.ForLogger().FilterMinLevel(LogLevel.Info).WriteToConsole();
});

public class HomeController : Controller
{
    private readonly ILogger<HomeController> _logger;

    public HomeController(ILogger<HomeController> logger)
    {
        _logger = logger;
    }

    public IActionResult Index()
    {
        _logger.LogInformation("Homepage visited");
        _logger.LogWarning("This is a warning");
        _logger.LogError("This is an error");
        return View();
    }
}

Install-Package Microsoft.Extensions.Logging.Log4Net.AspNetCore

var builder = WebApplication.CreateBuilder(args);

// log4net configuration
builder.Logging.AddLog4Net("log4net.config");

var app = builder.Build();

<log4net>
  <appender name="RollingFile" type="log4net.Appender.RollingFileAppender">
    <file value="logs/myapp.log" />
    <appendToFile value="true" />
    <rollingStyle value="Size" />
    <maxSizeRollBackups value="10" />
    <maximumFileSize value="10MB" />
    <staticLogFileName value="true" />
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%date [%thread] %-5level %logger - %message%newline" />
    </layout>
  </appender>
  <root>
    <level value="INFO" />
    <appender-ref ref="RollingFile" />
  </root>
</log4net>

"Log4Net": {
  "Appenders": [
    {
      "Type": "log4net.Appender.RollingFileAppender",
      "File": "Logs/myapp.log",
      "AppendToFile": true,
      "MaxSizeRollBackups": 5,
      "MaximumFileSize": "10MB",
      "RollingStyle": "Size",
      "StaticLogFileName": true,
      "Layout": {
        "Type": "log4net.Layout.PatternLayout",
        "ConversionPattern": "%date [%thread] %-5level %logger - %message%newline"
      }
    }
  ],
  "Root": {
    "Level": "DEBUG"
  }
}

ConfigureLog4Net(app.Services.GetRequiredService<IConfiguration>());

void ConfigureLog4Net(IConfiguration configuration)
{
    var loggerRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());

    var log4NetConfig = configuration.GetSection("Log4Net");
    var appendersConfig = log4NetConfig.GetSection("Appenders").GetChildren();

    foreach (var appenderConfig in appendersConfig)
    {
        var appender = CreateAppender(appenderConfig);
        if (appender != null)
        {
            ((Hierarchy)loggerRepository).Root.AddAppender(appender);
        }
    }

    var rootLogLevel = log4NetConfig.GetSection("Root:Level").Value;
    ((Hierarchy)loggerRepository).Root.Level = loggerRepository.LevelMap[rootLogLevel];
    ((Hierarchy)loggerRepository).Configured = true;
}

IAppender CreateAppender(IConfigurationSection appenderConfig)
{
    var appenderType = appenderConfig.GetValue<string>("Type");

    // Here you would create a switch or if-else chain based on the appenderType
    // For this example, let's assume it's a RollingFileAppender
    if (appenderType == "log4net.Appender.RollingFileAppender")
    {
        var appender = new RollingFileAppender
        {
            File = appenderConfig.GetValue<string>("File"),
            AppendToFile = appenderConfig.GetValue<bool>("AppendToFile"),
            RollingStyle = RollingFileAppender.RollingMode.Size,
            MaxSizeRollBackups = appenderConfig.GetValue<int>("MaxSizeRollBackups"),
            MaximumFileSize = appenderConfig.GetValue<string>("MaximumFileSize"),
            StaticLogFileName = appenderConfig.GetValue<bool>("StaticLogFileName"),
            Layout = new PatternLayout(appenderConfig.GetSection("Layout:ConversionPattern").Value)
        };
        appender.ActivateOptions(); // Important to activate the options
        return appender;
    }

    // Add other appender types as needed
    return null;
}

public class HomeController : Controller
{
    private readonly ILogger<HomeController> _logger;

    public HomeController(ILogger<HomeController> logger)
    {
        _logger = logger;
    }

    public IActionResult Index()
    {
        _logger.LogInformation("Visited the Index page");
        _logger.Warn("Warning - Check this out!");
        _logger.Error("Error occurred");
        return View();
    }
}

Install-Package Serilog.AspNetCore

var builder = WebApplication.CreateBuilder(args);

// Serilog configuration
Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .WriteTo.Console()
    .WriteTo.File("logs/myapp.txt", rollingInterval: RollingInterval.Day)
    .CreateLogger();

builder.Host.UseSerilog();

var app = builder.Build();

public class HomeController : Controller
{
    public IActionResult Index()
    {
        Log.Information("Homepage visited");
        Log.Warning("This is a warning with Serilog");
        Log.Error("This is an error with Serilog");
        return View();
    }
}