Introduction:

Logging and monitoring are critical aspects of any application development process, and they play a crucial role in ensuring that an application runs smoothly and meets the desired performance metrics. In the context of .NET Core applications, logging and monitoring can be achieved through various mechanisms, including built-in tools and third-party libraries. In this article, we will discuss the basics of logging and monitoring in .NET Core applications, along with an example program that showcases the use of these mechanisms.

Logging in .NET Core:

Logging is a mechanism for capturing and storing information about an application's behavior, performance, and error conditions. In .NET Core, logging can be implemented using the built-in logging framework provided by Microsoft. The framework provides a set of logging APIs that can be used to log messages, exceptions, and other diagnostic information.

To use the logging framework in a .NET Core application, we need to add the Microsoft.Extensions.Logging NuGet package to the project. This package provides the necessary classes and interfaces for logging.

Once we have added the package, we can create an instance of the ILogger interface, which is the primary interface for logging messages in .NET Core. The ILogger interface defines several logging methods, such as LogInformation, LogWarning, and LogError, which can be used to log messages of different severity levels.

Let's consider an example program that demonstrates the use of the logging framework in .NET Core. In this example, we will create a simple console application that logs some messages to the console and a file.

Step 1:

First, create a new .NET Core console application using Visual Studio or the dotnet new console command.

Step 2:

Add the Microsoft.Extensions.Logging NuGet package to the project using the NuGet Package Manager or the dotnet add package Microsoft.Extensions.Logging command.

Step 3:

Open the Program.cs file and add the following using statements at the top of the file:

using Microsoft.Extensions.Logging;
using System.IO;

Step 4:

In the Main method, create an instance of the ILoggerFactory interface using the LoggerFactory class:

var loggerFactory = LoggerFactory.Create(builder =>
{
    builder
        .AddConsole()
        .AddFile("logs/app.log");
});

This code creates an instance of the ILoggerFactory interface and configures it to log messages to the console and a file. The file will be located in the logs directory of the application's working directory.

Step 5:

Next, create an instance of the ILogger interface using the CreateLogger method of the ILoggerFactory interface:

var logger = loggerFactory.CreateLogger<Program>();

This code creates an instance of the ILogger interface that is associated with the Program class.

Step 6:

Finally, log some messages using the LogInformation method of the ILogger interface:

logger.LogInformation("Application starting...");
logger.LogWarning("Something unusual happened...");
logger.LogError(new Exception("An error occurred."), "An error occurred.");

These messages will be logged to the console and the file configured earlier.

Monitoring in .NET Core:

Monitoring is the process of collecting and analyzing data about an application's performance and behavior in real time. In .NET Core, monitoring can be implemented using various tools and techniques, including built-in diagnostics tools, third-party libraries, and cloud-based monitoring services.

The built-in diagnostics tools provided by .NET Core include the DiagnosticSource API, which enables instrumenting the application code to generate diagnostic events, and the EventSource API, which enables logging structured events that can be consumed by external tools.

Third-party libraries such as Application Insights, New Relic, and Dynatrace provide more advanced monitoring capabilities, including real-time performance monitoring, error tracking, and alerting.

Cloud-based monitoring services such as Azure Monitor and AWS CloudWatch provide centralized logging and monitoring capabilities that enable monitoring and troubleshooting across multiple applications and environments.

Let's continue with the example program from the previous section and add monitoring capabilities to it using the Application Insights library. Application Insights is a cloud-based monitoring service provided by Microsoft that enables real-time performance monitoring, error tracking, and alerting.

Step 1:

Create an Application Insights resource in the Azure portal and copy the instrumentation key.

Step 2:

Add the Microsoft.ApplicationInsights.AspNetCore NuGet package to the project using the NuGet Package Manager or the dotnet add package Microsoft.ApplicationInsights.AspNetCore command.

Step 3:

In the Program.cs file, add the following using statement at the top of the file:

using Microsoft.ApplicationInsights.Extensibility;

Step 4:

In the Main method, create an instance of the TelemetryConfiguration class using the TelemetryConfiguration.Active property, and set the instrumentation key:

var telemetryConfig = TelemetryConfiguration.Active;
telemetryConfig.InstrumentationKey = "YOUR_INSTRUMENTATION_KEY";

Step 5:

 Add the AddApplicationInsightsTelemetry method to the WebHost.CreateDefaultBuilder method chain:

WebHost.CreateDefaultBuilder(args)
    .ConfigureLogging(logging =>
    {
        logging.ClearProviders();
        logging.AddApplicationInsights(telemetryConfig);
    })
    .UseStartup<Startup>();

This code configures the application to use Application Insights for logging and monitoring.

Step 6:

In the Startup.cs file, add the UseApplicationInsights method to the Configure method:

app.UseApplicationInsights();

This code configures the application to use Application Insights for request tracking and dependency tracking.

Step 7:

In the HomeController.cs file, modify the Index method to include a call to the TrackEvent method of the TelemetryClient class:

public IActionResult Index()
{
    ViewData["Message"] = "Welcome to my app!";
    var telemetryClient = new TelemetryClient(telemetryConfig);
    telemetryClient.TrackEvent("Home/Index visited");
    return View();
}

This code logs a custom event to Application Insights whenever the Index method is called.

Step 8:

Build and run the application, and navigate to the home page. Verify that the custom event is logged in Application Insights.

Conclusion:

In this article, we discussed the basics of logging and monitoring in .NET Core applications, along with an example program that demonstrates the use of these mechanisms. Logging enables capturing and storing information about an application's behavior, performance, and error conditions, while monitoring enables collecting and analyzing data about an application's performance and behavior in real time.

In .NET Core, logging and monitoring can be achieved through various mechanisms, including built-in tools and third-party libraries. By implementing logging and monitoring in your .NET Core applications, you can ensure that your applications run smoothly and meet the desired performance metrics.