Serilog In .NET Core

As we know, logging is one of the most important topics for any kind of small or big application in software.

 

With the help of logging not only can we track what's happing behing the application, but also it helps to track any kind of exception. This exception actually comes iton application when it shows the exact method and line numnber with proper message details. So with the help of logging, developers can easily understand what the actual error is. 

 

So I have decided to write a short summary on Serilog in ASP.NET Core 3.1 and its implementations.

 

As we know that .NET Core has some basic logging features built-in which we have seen in the ILogger interface throughout the.NET Core Application.

 

But sometimes that's not enough.  So what if we want more control over how and where to log the details?

This is where Logging Frameworks comes into the picture. 

 

So Serilog is one of the most popular Libraries for ASP.NET Core Applications.

 

Here in this section I will try to cover the following topics:

1. What is Serilog?
2. Setup .NET Core Project
3. Logging with the Default Logger
4. Log Levels
5. Packages Installation
6. Console Logging.
7. File Logging.
8. Database Logging.
9. Summary

Introduction

 

What is Serilog?

 

From the official site:https://serilog.net/, "Serilog provides diagnostic logging to files, the console, and elsewhere. It is easy to set up, has a clean API, and is portable between recent .NET platforms. Unlike other logging libraries, Serilog is built with powerful structured event data in mind."

 

Setup .NET Core Project

 

For the step by step implementations we will create a simple .NET Core Web Application. I am using Visual Studio 2019. I will create a new project and then select ASP.NET Core Web Application project with an empty project template.

 

Here few default files would be  as follows, 

• appsettings.json,
• appsettings.Development.json,
• Startup.cs 
• Program.cs.

The default Program.cs file would look like this,

public class Program {
    public static void Main(string[] args) {
        CreateHostBuilder(args).Build().Run();
    }
    public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args).ConfigureWebHostDefaults(webBuilder => {
        webBuilder.UseStartup < Startup > ();
    });
}

Logging with the Default Logger

 

As we can see the default logging configuration can be found in app setting.json.

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft": "Warning",
            "Microsoft.Hosting.Lifetime": "Information"
        }
    }
}

Here I have just used test action to show the default log,

[HttpGet]
[Route("LoggTest")]
public IActionResult LoggTest() {
    _logger.LogInformation("normal log");
    int count;
    try {
        for (count = 0; count <= 1; count++) {
            if (count == 1) {
                throw new Exception("default test exception");
            }
        }
        return Ok();
    } catch (Exception ex) {
        _logger.LogError(ex, "Exception catch log");
        return BadRequest(ex.Message);
    }
}

Please see the image below.

 

 

 

This console log will be visible once you switch to Kestrel Webserver.

 

Note

Do not forget to add dependency Injection in controller constructor.

 

Log Levels

 

There are the following log-levels availabe here,

• Trace – Detailed messages with sensitive app data.
• Debug – Useful for the development environment.
• Information – General messages, like the way we mentioned earlier.
• Warning – For unexpected events.
• Error – For exceptions and errors.
• Critical – For failures that may need immediate attention.

Packages Installation

Now we have see how to apply default logging. Let's see how to implement Serilog step by step.

 

First of all we need to know what library we need to install.

 

So here are the libraries listed below,

Install-Package Serilog.AspNetCore
Install-Package Serilog.Settings.Configuration
Install-Package Serilog.Enrichers.Environment
Install-Package Serilog.Enrichers.Process
Install-Package Serilog.Enrichers.Thread

Now here we have installed all the required Serilog packages, so let’s go ahead and configure Serilog.

 

Console Logging

 

For console logging we don't need to do much extra setup. Here you can see the log in the console window.

 

For this, we will be required to do the basic setup to configure Serilog at the entry point in .NET Core Application. Here in the Program.cs file.do the following changes.

public static void Main(string[] args) {
    //Read Configuration from appSettings
    var config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
    //Initialize Logger
    Log.Logger = new LoggerConfiguration().ReadFrom.Configuration(config).CreateLogger();
    try {
        Log.Information("Application Starting.##############3");
        CreateHostBuilder(args).Build().Run();
    } catch (Exception ex) {
        Log.Fatal(ex, "The Application failed to start.######333");
    } finally {
        Log.CloseAndFlush();
    }
    //CreateHostBuilder(args).Build().Run();
}

Here in createhost method we need to do 1 line of change like this,

public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args).UseSerilog() //Uses Serilog instead of default .NET Logger
    .ConfigureWebHostDefaults(webBuilder => {
        webBuilder.UseStartup < Startup > ();
    });

Now run the application and see the image below,

 

 

File Logging

 

Now for the file log we need to do some setup in our appconfig.json file. Please use this setting just copy and paste the following configuration.

"Serilog": {
    "MinimumLevel": {
        "Default": "Information",
        "Override": {
            "Microsoft": "Warning",
            "System": "Warning",
            "System.Net.Http.HttpClient": "Warning"
        }
    },
    "WriteTo": [{
        "Name": "Console"
    }, {
        "Name": "Logger",
        "Args": {
            "configureLogger": {
                "Filter": [{
                    "Name": "ByIncludingOnly",
                    "Args": {
                        "expression": "Contains(SourceContext, 'AspNetCoreSerilogDemo.TestLogApi') and (@Level = 'Error' or @Level = 'Fatal' or @Level = 'Warning')"
                    }
                }],
                "WriteTo": [{
                    "Name": "File",
                    "Args": {
                        "path": "Logs/Error/applog_.log",
                        "outputTemplate": "{Timestamp:o} [Thread:{ThreadId}] [{Level:u3}] ({SourceContext}) {Message}{NewLine}{Exception}",
                        "rollingInterval": "Day",
                        "retainedFileCountLimit": 7
                    }
                }]
            }
        }
    }, {
        "Name": "Logger",
        "Args": {
            "configureLogger": {
                "Filter": [{
                    "Name": "ByIncludingOnly",
                    "Args": {
                        "expression": "Contains(SourceContext, 'AspNetCoreSerilogDemo.TestLogApi') and @Level = 'Information'"
                    }
                }],
                "WriteTo": [{
                    "Name": "File",
                    "Args": {
                        "path": "Logs/Info/applog_.log",
                        "outputTemplate": "{Timestamp:o} [{Level:u3}] ({SourceContext}) {Message}{NewLine}{Exception}",
                        "rollingInterval": "Day",
                        "retainedFileCountLimit": 7
                    }
                }]
            }
        }
    }],
    "Enrich": ["FromLogContext", "WithMachineName", "WithThreadId", "WithThreadName"],
    "Properties": {
        "Application": "AspNetCoreSerilogDemo"
    }
}

Now run the application, then check your application. As you can see 1 folder is created by Name of Logs, and inside this folder we have 2 folders, error and info for logging

separately. Open the folder and you will be able to see some logs there.

 

Refer to these images as well.

 

 

 

Database Logging.

 

Now the last point is to log exception in Db and  for that we need to install one more package,

 

Install-Package Serilog.Sinks.MSSqlServer

 

After installing this packege you need to add some configuration in appsettings.json file,

 

Please use the same as below,

"WriteTo": [{
    "Name": "File",
    "Args": {
        "path": "Logs/Info/applog_.log",
        "outputTemplate": "{Timestamp:o} [{Level:u3}] ({SourceContext}) {Message}{NewLine}{Exception}",
        "rollingInterval": "Day",
        "retainedFileCountLimit": 7
    }
}, {
    "Name": "MSSqlServer",
    "Args": {
        "connectionString": "Data Source =...;Initial Catalog=yourDb;User Id =yourId; Password =yourpwd;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False",
        "sinkOptionsSection": {
            "tableName": "Logs",
            "schemaName": "yourDbName",
            "autoCreateSqlTable": true
        },
        "restrictedToMinimumLevel": "Warning"
    }
}]

Note

You don't need to create your own table Logs, once the application will start for execution, this table will automatically create.

 

After excecuting the application you will be able to see the log for this table.

 

Please refer to the image below,

 

 

Summary

 

Finally we have completed step by step learning logging with default logger provided by Microsoft. Then after that we have learned how to implement Serilog, then after that we have seen practically how to log in console file, then finally in database which is more important to understand.

 

Kindly let me know if you face any issue, I will try my best to resolve as much as possible. I hope you liked this tutorial; please share it with others. Thank you for taking your valuable time to read the full article.