Why is the logging so important during the application development? Well, while your application is in the developing stage it is very easy to debug the code and to find out what went wrong. But, can you debug in the production environment?
Of course not.
That is why logging messages are a great way to find out what went wrong and where did error happen in your code in the production environment. .NET Core has its own implementation of logging messages, but in all my projects, I prefer to create my own custom logger service.
This is what I am going to show you in this post.
If you want to see all the basic instructions and complete navigation for this series, please follow the following link: Introduction page for this tutorial.
For the previous part check out: Creating .NET Core WebApi project – Basic code preparations
Source code to download is available at this link: .NET Core, Angular 4 and MySQL. Part 3 – Source Code
This post is divided into several sections:
- Creating Required Projects
- Creating the Interface and Installing NLog
- Implementing Interface and Nlog.Config File
- Configuring Logger Service
- DI, IOC and Logger Service Testing
- Conclusion
Creating Required Projects
Let’s create two new projects. Name the first one Contracts. You are going to store the interfaces inside this project. Name the second one LoggerService. You are going to use it for the logger logic.
To create a new project, right click on the solution window, choose Add and then NewProject. Under the .NET Core, choose the Class Library (.NET Core) and name it Contracts.
Do the same thing for the second project, just name it LoggerService.
With these two projects in place, you need to reference them to your main project. In the main project inside solution explorer, right click on the Dependences and choose the AddReference. Under the Projects click the Solution and check both projects.
Before we proceed to the implementation of the LoggerService, let’s do one more thing.
In the LoggerService project right click on the Dependencies and then click on the Add Reference. Inside check the Contracts checkbox to import its reference inside the LoggerService project.
Creating the Interface and Installing NLog
Our logger service will contain four methods for logging:
- Info messages
- Debug messages
- Warning messages
- And error messages
Consequently, you will create the interface ILoggerManager inside the Contracts project containing those four method definitions.
Add the following code to the ILoggerManager interface:
|
1 2 3 4 5 6 7 8 9 10 |
namespace Contracts { public interface ILoggerManager { void LogInfo(string message); void LogWarn(string message); void LogDebug(string message); void LogError(string message); } } |
Before you implement this interface inside the LoggerService project, you need to install the NLog library in our LoggerService project. NLog is logging platform for the .NET which will help us create and log our massages.
I’ll show you two ways how to add NLog library to your project.
- In the
LoggerServiceproject, right click on the Dependences and choose Manage NuGet Packages. After the NuGet window appears, just follow the steps:
- From the View menu choose the Other Windows and then click on the Package Manager Console. After the console appears just follow the leads:
After a couple of seconds, NLog is up and running in your app.
Implementing Interface and Nlog.Config File
In the LoggerService project create the new class LoggerManager.
Let’s modify the LoggerManager class:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
using Contracts; using NLog; using System; namespace LoggerService { public class LoggerManager : ILoggerManager { private static ILogger logger = LogManager.GetCurrentClassLogger(); public LoggerManager() { } public void LogDebug(string message) { logger.Debug(message); } public void LogError(string message) { logger.Error(message); } public void LogInfo(string message) { logger.Info(message); } public void LogWarn(string message) { logger.Warn(message); } } } |
Now, we need to configure it and inject it into the Startup class in the ConfigureServices method.
NLog needs to have information about the folder to create log files in, what the name of these files will be and what a minimum level of logging is. Therefore, you need to create one text file in the main project with the name nlog.config and to populate it as in the example below. You need to change the path of the internal log and filename parameters to your paths.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
<?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" internalLogLevel="Trace" internalLogFile="d:Projects\Blog-AccountOwner\Project\internal_logs\internallog.txt"> <targets> <target name="logfile" xsi:type="File" fileName="d:/Projects/Blog-AccountOwner/Project/logs/${shortdate}_logfile.txt" layout="${longdate} ${level:uppercase=true} ${message}"/> </targets> <rules> <logger name="*" minlevel="Debug" writeTo="logfile" /> </rules> </nlog> |
Configuring Logger Service for Logging Messages
Setting up the configuration for a logger service is quite easy.
First, you must update the constructor in the Startup class:
|
1 2 3 4 5 |
public Startup(IConfiguration configuration, ILoggerFactory loggerFactory) { loggerFactory.ConfigureNLog(String.Concat(Directory.GetCurrentDirectory(), "/nlog.config")); Configuration = configuration; } |
ILoggerFactory has its implementation inside .NET Core and it serves the purpose of configuring the logging system inside it. With the extension method ConfigureNLog, we are forcing the ILoggerFactory to apply the configuration of our new logger from the XML file.
If you have installed a newer version of NLog (in this article we are working with 1.0.0-rtm.rc3 version) then this implementation inside the Startup class is obsolete. Now you should do your registration in this way:
|
1 2 3 4 5 |
public Startup(IConfiguration configuration) { LogManager.LoadConfiguration(String.Concat(Directory.GetCurrentDirectory(), "/nlog.config")); Configuration = configuration; } |
Secondly, you need to add the logger service inside the .NET Core’s IOC container. There are three ways to do that:
- By calling
services.AddSingletonwhich will create the service the first time you request it and then every subsequent request is calling the same instance of the service. This means that all components are sharing the same service every time they need it. You are using the same instance always - By calling
services.AddScopedwhich will create the service once per request. That means whenever we send the HTTP request towards the application, a new instance of the service is created - By calling
services.AddTransientwhich will create the service each time application request it. This means that if during one request towards our application, multiple components need the service, this service will be created again for every single component which needs it
So, in the ServiceExtensions class add a new method:
|
1 2 3 4 |
public static void ConfigureLoggerService(this IServiceCollection services) { services.AddSingleton<ILoggerManager, LoggerManager>(); } |
Lastly, in the ConfigureServices method invoke this extension method, right above services.AddMvc():
|
1 |
services.ConfigureLoggerService(); |
Every time you want to use a logger service, all you need to do is to inject it into the constructor of the class that is going to use that service. .NET Core will serve you that service from the IOC container and all of its features will be available to use. This type of injecting objects is called Dependency Injection.
DI, IOC and Logger Service Testing
What is exactly Dependency Injection(DI) and what is IOC (Inversion of Control)?
Dependency injection is a technique for achieving loose coupling between objects and their dependencies. It means that rather than instantiating an object every time it is needed, we can instantiate it once and then serve it in a class, most often, through a constructor method. This specific approach we utilize is also known as the Constructor Injection.
In a system that is designed to use DI, you may find many classes requesting their dependencies via their constructor. In that case, it is helpful to have a class which will provide all instances to classes through the constructor. These classes are referred to as containers or more specific Inversion of Control containers. An IOC container is essentially a factory that is responsible for providing instances of types that are requested from it.
For the logger service testing purpose, you could use ValuesController. You will find it in the main project in the Controllers folder.
In the Solution Explorer open the Controllers folder and open the ValuesController class. Let’s modify it:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
[Route("api/[controller]")] [ApiController] public class ValuesController : ControllerBase { private ILoggerManager _logger; public ValuesController(ILoggerManager logger) { _logger = logger; } // GET api/values [HttpGet] public IEnumerable<string> Get() { _logger.LogInfo("Here is info message from our values controller."); _logger.LogDebug("Here is debug message from our values controller."); _logger.LogWarn("Here is warn message from our values controller."); _logger.LogError("Here is error message from our values controller."); return new string[] { "value1", "value2" }; } } |
After all, start the application, and browse to http://localhost:5000/api/values. As a result, you will see an array of two strings. Now go to the folder that you have specified in the nlog.config file, and check out the result. You should see four lines logged inside that file.
Conclusion
Now you have the working logger service, you will use through an entire process of our application development.
By reading this post you’ve learned:
- Why logging is important
- How to create external service
- How to use NLog library and how to configure it
- What are DI and IOC
- And how to use them for service injection
Thank you for reading and see you soon in the next blog post where we will talk about repository pattern with entity framework core.
If you have enjoyed reading this article and if you would like to receive the notifications about the freshly published .NET Core content we encourage you to subscribe to our blog.
Thanks for the post. For project reference, you have “Also, add a reference from the Contracts project to the LoggerService project.” This should be the other way around. Right? We should be referencing LoggerService project from Contract project to make use of the interface. When I added a reference from Contracts project to LoggerService project, I got some circular reference error. other then that, everything works fine. I was able to test the logging service in the end.
Hi Sumu (again 😀 ) Well you just misunderstood me or I wrote it in the wrong way. But to explain my self: With the sentence “Also, add a reference from the Contracts project to the LoggerService project.” I meant in the LoggerService right click on the Dependencies and click AddReference, then choose Contracts and import it’s reference inside LoggerService project. Other way around you are going to get circular reference, as you mentioned. I am sorry for misleading sentence, I am going to make it more clear for understanding. Thank you very much for the suggestion. And thank you for reading our posts.
Ok. Thanks!
Great post. I have tried for a long time to become familiar with DI, IOC etc…in vain. Your series brings light into the dark. Thanks.
Concerning the LoggerService I have some questions:
1. NLog is built into .NET Core. So why implement a custom service which is only a shell or wrapper for NLog?
2. In order to demonstrate DI and IOC and thus implementing this custom LoggerService, would’nt it be better to move dependency for NLog to a single place, i.e. into the implementation of LoggerManager?
I left the constructor in Startup.cs as is …public Startup(IConfiguration configuration)… and modified LoggerManager.cs as…
public class LoggerManager : ILoggerManager
{
private static readonly ILogger logger = LogManager.GetCurrentClassLogger();
public LoggerManager()
{
var configFile = String.Concat(Directory.GetCurrentDirectory(), “/nlog.config”);
LogManager.LoadConfiguration(configFile);
}
…
Thus, using NLog is only needed in LoggerManager.cs
I am looking forward to dive into the next parts of this series.
Best regards,
Martin
Hello Martin. Thank you very much for reading the post and for your comment as well. I am so glad if you could find it useful. Regarding your questions:
1) As much as I know, NLog is not built in inside .NET Core Web API project. It is a third party, open source library. Please check this link: http://nlog-project.org/. NET Core has its own logging logic but I always like to use my way of controlling and logging messages. If you know something different or something has changed in the relation between .NET Core and NLog please share it with me.
2) Your implementation is very acceptable but there are two reasons for me to do it like I did. Firstly, the Startup constructor is going to fire up only once (when you start the server) and that is it, every other request won’t trigger this constructor therefore making NLog dependency on a single place as you mentioned and configured just once. The second reason and Main reason is that I had to extend the ILoggerFactory, which is built in in .NET Core, because without this extension NLog didn’t work when application was deployed on Linux environment (at least I had that problem).
I hope you are satisfied with my answers, and one more time, thank you very much for reading and making your suggestions. It is always a pleasure to talk with .NET skillful people 😀
Hey Marinko,
thanks for your quick answer. I appreciate your design. Of course, more than one road lead to Rome.
1) My first statement was not correct – NLog is not integral part but .NET Core is well prepared to use it out of the box:
>>>>> s. https://stackify.com/asp-net-core-logging-what-changed/ >>>>>
For NLog/Serilog, all you have to do is add one line of code in your Startup Configure() method. This adds a special logging provider for NLog/Serilog that redirects the messages.
loggerFactory.AddNLog();
or
loggerFactory.AddSerilog();
<<<<<
2) I debugged my implementation (as it is implemented to the end of part 3) and found that the ctor of my LoggerManager is also called only once (not when the application is started, but as soon as the first request is fired).
As I said: more than one road lead to Rome.
Great stuff, thanks
BR,
Martin
One more time thank you so much mate. It is always a pleasure to talk with people like you. Hope I will see you around. All the best mate.
Best regards,
Marinko.
I just want to say thanks heaps for this series, I came for the error handling stuff but have found so much more!
Thank you very much for your kind words. Don’t forget to subscribe, to get updated about our new posts. One more time thank you a lot.
Hi,
I want use DI in EF class library project, Is there any example available for same?