Logtail uses a highly popular NLog logging library. You can integrate Logtail into your .NET application in just a few simple steps.

Supported version:

• .NET 5 or newer (to use the example project .NET 6 is required)

To use Logtail in your .NET project you need to install the following two packages. It can be done from the Visual Studio interface or command line, depending on your preferences.

In Visual Studio, open NuGet Package Manager Console by clicking Tools → NuGet Package Manager → Package Manager Console

In the opened console run the following command:

Install-Package Logtail

Then run the following command to install NLog.Extensions.Logging package:

Install-Package NLog.Extensions.Logging

To install the Logtail package using PowerShell, run the following command in your project’s directory:

dotnet add package Logtail

Then install NLog.Extensions.Logging package using the following command:

dotnet add package NLog.Extensions.Logging

Download or clone the repository to your select project directory.

Open the .csproj file in the Visual Studio. Then click on the green play button DotNetLogtail or press F5 to run the application.

Open the command line in the projects directory and enter the following command:

dotnet run

This is the expected output:

All done! Now, you can check Logtail to see your logs

This part shows and explains the usage of the Logtail package for .NET as shown in the example application

In the root directory of the project create the nlog.config file or copy the file from the example project. In Visual Studio, you can press Ctrl + Shift + A and enter the file name. This file is used to configure NLog using XML syntax. The content of the file should look like this:

<?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="Warn"
        internalLogFile="internal.txt">
	<extensions>
		<add assembly="Logtail" />
	</extensions>

	<targets>
		<!-- Dont forget to change SOURCE_TOKEN to your actual cource token-->
		<target xsi:type="Logtail" name="logtail" sourceToken="SOURCE_TOKEN" />
	</targets>

	<rules>
		<logger name="*" minlevel="Trace" writeTo="logtail" />
	</rules>
</nlog>

Make sure that you replace SOURCE_TOKEN with the actual source token that you can find in the Source settings.

Also, make sure that the nlog.config file is set to be copied to the output directory when running the application.

If you are using Visual Studio, you can set this option by right-clicking on the file and selecting Properties. Find the Copy to Output Directory option and set it to Copy Always.

Another way is to open the .csproj file and add the following directive:

<ItemGroup>
    <None Update="nlog.config">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </None>
</ItemGroup>

First, include the NLog library upon which the Logtail package was built. Then create a Logger instance which will be later used for sending log messages. To create a Logger instance, call LogManager.GetCurrentClassLogger() constructor.

using NLog;

// Create logger for current class
var logger = LogManager.GetCurrentClassLogger();

This will create a logger for the current class. In this case, it will be created for the Program class and it will add “logger_string” with the value “Program” to the context of the JSON log message.

The name of the logger will also be present in the log message which will look something like this:

"2022-01-26 10:25:06.0980|DEBUG|Program|Debugging is hard, but can be easier with Logtai!"

This provides an option to filter logs based on the logger that sends them. You can create a logger for each of the logical components of your application and then filter the logs based on the names of the components.

For example, if you create a logger as a field of the ShoppingCart class, the value of logger_string will be ShoppingCart :

public class ShoppingCart
{
     private static Logger ShoppingCartLogger = LogManager.GetCurrentClassLogger();
     //...
}

The output will look similar to this:

{
   "dt":"2022-01-26 10:48:10.635 UTC",
   "context":{
      "logger_string":"ShoppingCart",
      "runtime":{
         "class_string":"ShoppingCart",
         "file_string":"C:\\Users\\someuser\\source\\repos\\DotNetLogtail\\DotNetLogtail\\ShoppingCart.cs",
         "line_integer":"16",
         "member_string":".ctor"
      }
   },
   "level_string":"Error",
   "message_string":"2022-01-26 11:48:10.6354|ERROR|DotNetLogtail.ShoppingCart|Error !!!!!"
}

Then it is possible to filter the logs using the following search formula:

context.logger_string="ShoppingCart"

This will only show logs that were sent from to ShoppingCart logger.

The Logger instance we created in the setup is used to send log messages to Logtail. It provides 6 logging methods for the 6 default log levels. The log levels and their method are:

• TRACE - Trace the code using the Trace() method
• DEBUG - Send debug messages using the Debug() method
• INFO - Send informative messages about the application progress using the Info() method
• WARN - Report non-critical issues using the Warn() method
• ERROR - Send messages about serious problems using the Error() method
• FATAL - Report fatal errors that caused the application to crash using the Fatal() method

To send a log message of select log level, use the corresponding method. In this example, we will send the DEBUG level log and ERROR level log.

//Send debug messages using the Debug() method
logger.Debug("Debugging is hard, but can be easier with Logtai!");

//Send message about serious problems using the Error() method
logger.Error("Error occurred! And it's not good.");

This will create the following JSON output:

{
   "dt":"2022-01-26 09:25:06.098 UTC",
   "context":{
      "logger_string":"Program",
      "runtime":{
         "class_string":"Program",
         "file_string":"C:\\Users\\someuser\\source\\repos\\DotNetLogtail\\DotNetLogtail\\Program.cs",
         "line_integer":"21",
         "member_string":"<Main>$"
      }
   },
   "level_string":"Debug",
   "message_string":"2022-01-26 10:25:06.0980|DEBUG|Program|Debugging is hard, but can be easier with Logtai!"
}

{
   "dt":"2022-01-26 09:25:06.098 UTC",
   "context":{
      "logger_string":"Program",
      "runtime":{
         "class_string":"Program",
         "file_string":"C:\\Users\\someuser\\source\\repos\\DotNetLogtail\\DotNetLogtail\\Program.cs",
         "line_integer":"32",
         "member_string":"<Main>$"
      }
   },
   "level_string":"Error",
   "message_string":"2022-01-26 10:25:06.0980|ERROR|Program|Error occurred! And it's not good."
}

The Logtail target will send you logs periodically in batches to optimize network traffic with several retries in case of unexpected HTTP errors. You can adjust this behavior by setting the maxBatchSize, flushPeriodMilliseconds, and retries parameters to your custom values in your config.

<target
   xsi:type="Logtail"
   name="logtail"
   sourceToken="YOUR_SOURCE_TOKEN"
   maxBatchSize="200"
   flushPeriodMilliseconds="1000"
   retries="3" />

All of the properties that you pass to the log will be stored in a structured form in the context section of the logged event.

logger.Info("User {user} - {userID} just ordered item {item}", "Josh", 95845, 75423);

Code above will create the following output:

{
   "dt":"2022-01-26 09:55:34.128 UTC",
   "context":{
      "logger_string":"Program",
      "runtime":{
         "class_string":"Program",
         "file_string":"D:\\dotnet_logtail\\Program.cs",
         "line_integer":"25",
         "member_string":"<Main>$"
      },
      "properties":{
         "item_integer":"75423",
         "userID_integer":"95845",
         "user_string":"Josh"
      }
   },
   "level_string":"Info",
   "message_string":"2022-01-26 10:55:34.1285|INFO|Program|User \"Josh\" - 95845 just ordered item 75423"
}

A new field called properties is added into the context and it contains the arguments that were passed and their values.