DEV Community: Panji Kristi Prawiro

Logging in ASP.NET Core

Panji Kristi Prawiro — Sat, 21 Sep 2024 07:24:18 +0000

Intro

As a Developer there is no feeling that compares to the mix of emotions we experience after developing our application: relief, excitement, delight, and occasionally even tears (tears of joy). Because we have put our time and hard work into developing a fully functional application to solve a problem.

In the development stage, we want to ensure our application runs perfectly without a bug. We tested our application by running it in debug mode and verifying all features work as expected, or maybe you have created a unit test and integration test for the project and ensured all running tests passed.

Then we are ready to move to the next stage to ship our code into production, we deploy the application, and we think that our task is done. After a while, users of our application report that they encounter an error when using our application. It feels bummer, right? We have made sure that our code doesn't have bugs, and now it seems hard to identify the root cause of the problem because we cannot use debugging mode in production.

You must know that in a production environment, something can go wrong that isn't directly caused by your code, issues can arise from this unexpected error such as network timeouts, database connectivity issues, or third-party API failures.
The question is how to identify this problem that can arise in our running application in a real-time. Logging come to the rescue

Logging

Logging is recording all the events that occur in our running application. It can create a log message of error or maybe just information on execution flow. These log messages can be saved and looked at in various destinations such as the console, file, database, monitoring tool, etc.

The real question is: what is the best approach to creating logging into our apps? Are you still creating a logging mechanism by creating a file and writing a text in the file manually by yourself?

My best advice is to never manually create a logging system. It's a waste of time, and it might not have a great capability like a logging framework can offer, like structured logging (we'll talk more about the latter). In ASP.NET Core, there is a built-in logging framework that is auto-enabled, and you can use it right away. Before we create our user-defined log message, you must know several log levels indicate the severity of events in your application, there are:

Trace: Use for highly detailed, step-by-step diagnostic information.
Debug: Use for development and debugging purposes, logging detailed internal state information.
Information: Use for general operational events that provide insight into the application's normal behavior.
Warning: Use for issues that may not be immediately harmful but could lead to problems if not addressed. Like in the "else" case, if you insert new data into the database with EF, you should expect to get the number of inserted data, but instead, you get 0, which means there is no row inserted.
Error: Use for significant problems that prevent specific functionalities but do not cause the entire application to fail.
Critical: Use for severe issues that require immediate attention and could cause the entire application or system to fail.

By default, built-in logging in ASP.NET Core has 3 providers (destination where the log message is printed): console, debug, and EventLog (Windows Only).

If we look at the console kestrel above, by default the minimum log level is set to Information. Hence the Trace and Debug level is not printed. You can change the behavior by changing the configuration in appsettings.json

We set the minimum log level into "trace" so it is successful to print log messages from traceand debug and above severity level events. But how to use logger in other than program files like in controller, service, repository, and other files? You can do it by injecting it into the method or constructor right away without needing to configure and register the logging service in the IoC Container beforehand.

You can ask the IoC container to inject ILoggerobject and you can store the injected logger object as a field and then use it anytime you want to create a log event. If you notice there is a message template with a placeholder (curly brace) in the log event to capture dynamic values as structured logging instead of embedding them directly into the log message as plain text. This offers benefit for easy to search and analysis logs (we will talk about it later)

HTTP Logging

It's important to log information about incoming HTTP requests and HTTP responses so you can identify the incoming request.

HTTP logging captures details about each incoming HTTP request and outgoing response. This includes information such as the request path, method (GET, POST, etc.), headers, and response status codes. This makes it easier to trace the flow of requests through your application and identify issues like incorrect routing or faulty response.

how to configure HTTP logging:

you need to add HTTP logging service into the IoC container
you need to use the built-in middleware of UseHttpLogging() to enable automatic logging of HTTP requests and responses in your application

By default, HTTPLogging doesn't log information about the request body and response body. You can set the configuration to capture request and response body but that is not recommended because if you log every incoming request body and response body it will overhead and slow down your server performance. Only log body if in an extremely needed situation.

Serilog

In this post, i will show you my favorite log framework, serilog. Why serilog is a good choice then built-in logging ASP.NET? Because they offer more sinks (sink in serilog refers to log destination). You can print the log event into a file, database (SQL Server, MySQL, etc), Seq, Azure, and have more powerful structured logging.

after that you can configure in program file

How to utilize serilog in ASP.NET Core

First, you need to install Serilog and Serilog.AspNetCore from nugget package. In this post, i will show you how to send a log event into 3 sinks which are console, file, and Seq. So you need to install the respective serilog sinks (Serilog.Sinks.Console, Serilog.Sinks.File, and Serilog.Sinks.Seq)

Seq

If you don't know Seq, Seq is a hosted monitoring tool for easy search and analysis in realtime for structured log. Here is the link to how to download and set seq tool on your machine https://docs.datalust.co/docs/getting-started

To set Serilog as logging provider add following code into Program file

above code tell serilog to read its configuration is loaded from configuration file such as appsetting.json and read services in IoC container and make available to serilog.

here how to set serilog configuration

Using section to determine which sinks to include, and then it uses those sinks for logging

Each sink has its configuration you can configure it in WriteTo section, for every sink need a Nameproperty. For Seq you need to Supply serverUrl which locates the URL of the Seq server in the Args section and for the file sink you need to supply a path to find where the file will be created for the first time and append the log message if the file already exists, in addition, you can add more configuration such as rollingInterval to determines how frequently new log file will be created based on the specified time interval, fileSizeLimitBytes to limit the maximum size of the log file and rollOnFileSizeLimit set to true to create a new file every time the size of log file reaches maximum limit.

console serilog looks like

file serilog looks like

seq serilog looks like

Here is one of the benefits use of a structured log instead of a static message log, You can search by property of log-structured event context like below

Enricher

An enricher is additional information or context like machine name, environment’s user name, and other custom user-defined information that will attach to your log event. It enriches information so it will help make it easier to debug and analyze. Enricher will add key-value pairs to your logs.

If you wanna add context that is true for all log events you can add static global key-value pairs by adding Properties to appsettings.json and adding key-value pair as nested property

You can add dynamic value into context with the help of the Diagnostic Context mechanism, there are 2 main types which are LogContext and IDiagnosticContext.
Note: for both dynamic contexts you need to supply LogContext as a value in the Enrichsection.

LogContext
Dynamically add properties to log events for a specific block code by executing LogContext.PushProperty() static method inside using statement. But first, you need to install Serilog.Enrichers.Context package from nugget package manager

context will be attached only for log event that inside using block of LogContext.PushProperty()

IDiagnosticContext
Dynamic context that only appears in the completion request response of the log event. But first, you need to configure Serilog’s request logging middleware which is app.UseSerilogRequestLogging().Unlike useHttpLogging which logs HTTP requests and responses in several events, serilog’s request logging only logs a single event at the completion of the HTTP request response.

First, you need to inject IDiagnosticContext instance then you can set the context to completion of the HTTP request-response with Set IDianosticContext instance's method.

Conclusion

Logging is vital for every application. Especially for big and complex applications. You can perform identity and analysis behavior of your application in production hence you can easily find the root of the problem if there is a bug or unintended behavior in your application easily and quickly, it is also used as a performance monitor because it logs the response time of request so if there is something that taking a long time you as a developer can optimize it, so it is recommended that you always use logging system each time you develop a new application

Understanding Model Binding in ASP.NET

Panji Kristi Prawiro — Thu, 29 Aug 2024 12:53:25 +0000

Introduction

HTTP is the backbone of a website's communication. This regulates how clients and servers exchange information. One of the must-have capabilities of a server is to get data from a client's request. In ASP NET Core, every incoming request from the client will be caught by the Kestrel server and transformed into object context, then passed into source code, and finally routed to the endpoint. First, let's look at how to get data from request object context without a model binding mechanism.

Get query string from context object

Without model binding, you must do extra work to do. First, you need to access the IQueryCollection object from HttpContext and check if there is any associate key-value pair. If any, it will give you a StringValues type, which under the hood implements IList<string> so you need to access a string element from that list, and then you need to perform a type conversation from the string into the appropriate value. This tedious work increases the error-proneness, luckily ASP.NET offers the easy way with Model Binding mechanism.

Model Binding

Model binding is one of the greatest mechanisms in ASP.NET. It is a process of collecting the data from an incoming request (it could be in the form of query string, route data, request body, or request header) and then supplying the values as an action method argument. Hence, you have access directly to data that was sent from the client to perform validation and process it in the business logic layer. Behind the scenes, ASP.NET will take care of the binding process, so it's not ours. The model binding mechanism will automatically perform when requests are routed to match endpoints and right before the execution of the action method.

let's look how to get query string data with model binding

It seems like magic 🎩✨🐇 isn't it?

It is significantly quicker and easier. to extract data from a query with model binding that you wouldn't need to perform a data conversation from a string into an appropriate type. It comes automatically behind the scenes by model binding.

In order to bind successfully, you must make sure the name of the key of the query string matches the identifier of the action method parameter. but you don't have to match the case because it is not case-sensitive. Bonded data is not limited to one source. It still works fine if you place the data in the query string and route data.

Get Query String and Route Data with model binding

So it is great that ASP.NET has these features to make development more intuitive, easy, and fast. However, if you don't understand the behavior of model binding, you will end up confused. Let's say the client makes the following request:

From above, we can see that it has collision data between the query string and route data because they have the same identifier called "movieId". If we look at the above watch window, the movieId gets populated with a value of 89. You might wonder why ASP.NET extracts "movieId" parameter data from route data instead of a query string? It turns out ASP.NET has an order of priority for model binding. Let's take a look at the image below, It starts from the top, which has the highest priority, down to the bottom, which has less priority.

Great, now you have a better understanding of model binding behavior.
But what if you don't want to achieve this behavior?
You can use the [FromQuery] attribute to tell ASP.NET, "Hey, forget about your order priority. I will state explicitly that I want you to bind the data from the query string instead."

It will populated movieId with value of 22 instead of 89.

here another useful attribute list that you can use to explicitly specify the source of data for action method parameters

[FromRoute]
[FromQuery]
[FromBody]
[FromForm]

Model Binding with Model Class

What happens if the customer provides a lot of data? Of course, you don't want to scatter up the action method arguments; it will clutter your code. Instead, you can create a model class and declare it as an action method parameter. Model binding will automatically map incoming request data to the properties of your model class based on their names.

client send a request with a multipart/form-data content type

Great, the movie object has been automatically populated based on the data from the request form-data. Sometimes you want more granular control over which properties get populated from incoming request data, to achieve this, you can utilize [Bind] and [BindNever]attributes.

Bind

decorate action method parameter with Bind attribute then you need to supply name of property or parameter to include in binding. It will tell that we only interest to populate Title value and leave the rest of properties to hold null or default value
BindNever

decorate the property model that you want to exclude from the model binding process. It will make the Title property excluded from the binding process hence, it will store a null value, and the rest of the properties still be populated from the binding.

Custom Model Binders

ASP.NET gives you more control over the binding process from requests into action method parameters by creating your own model binding class. so it will override the built-in Model binding mechanism and use your own model binding class. Let's say that the client will send query string data of poster URL and trailer URL and you want to store them into a single value separated by semicolon. First, you need to create a class that implements the IModelBinder interface and overrides the BindModelAsync method.

After you create your own model binder class, you need to decorate the parameter of your model parameter in the action method with the ModelBinder attribute and pass your model as a type on the first argument.

You are successfully using your own custom model binder so you can have granular control over the rule of the binding process.

Conclusion

Model Binding Mechanism in ASP.NET helps us to populate data from requests with a breeze. It will perform automatically, and you don't have to write tedious code that could be error-prone. With the understanding behavior of model binding performed by ASP.NET you know how to handle it if something looks off or does not look as you expect it with the right technique. Even if the model binding by ASP.NET cannot meet your requirements, you can create your custom model binders by yourself and override the built-in model binding mechanism in ASP.NET.