1 - A briefly understanding about Garbage collecting strategy in C#.

Otávio Larrosa — Sun, 05 Feb 2023 21:15:24 +0000

As a professional developer, constantly you need to improve your application performance. And in most of the cases, the first place you search is about database, or network usage, algorithm complexity and many other places a developer can see.
But, in some cases, the "villain" of the performance, is the garbage collector, when you're dealing with managed languages such as C#, Java, Python, Golang, and many other.

Well, here we have the benefits to use a managed language:

You don't have to manually free the memory your program have allocated.
The objects allocation on the managed heap is very efficient.
Provides an automated way to release the memory.
Make sure that an object will never access the memory allocated for another object(memory safety).

1 - How the CLR allocates memory?

When you initialize a program, the dotnet CLR(Common Language Runtime) reserves a contiguous address space for the process, this region is called "managed heap", imagine something like this:

Well, after creating the managed heap space, the CLR will set a pointer to next free block space on the memory, like this:

An important thing to mention, is that allocating memory in the managed heap, is faster than allocating memory in an unmanaged way, because the CLR has allocated and setted the pointer to the specific memory address. While the unmanaged way needs to search on the entire heap, a place that is enough to your variable/process/object.

2 - How the Garbage Collector runs?

The GC executes 4 steps all the times it was called:

It suspends the execution of your program
The GC sweeps all the managed heap, searching for objects that doesn't have more references to.
The GC destroy this objects, move the remaining objects on the memory to the start of the managed heap spaces, and set the pointer to the next free space(here, the GC will promote the remaining objects from #gen0 to #gen1 and #gen2, but we will talk about this behaviour on the next post).
The GC resumes the execution of your program.

3 - When the GC runs?

Nothing complex here, the garbage collector runs where one of these conditions is true:

When the operating system or the host, notifies the CLR that the system has low memory available.
When the memory used on the managed heap exceeds the acceptable threshold.
2.1. Important thing to mention is: the acceptable memory threshold on managed heap is constantly adjusted while the process runs.
When the GC.Collect method is arbitrary called by your code.
3.1 Important thing: In most of the cases, you don't need to call this. And, is recommended to not use this call.

Trabalhando com correlationId em .Net + Serilog

Otávio Larrosa — Sun, 05 Feb 2023 18:32:32 +0000

Em aplicações distribuídas, uma das coisas mais importantes que devemos ter, é rastreabilidade, principalmente de erros, e uma prática muito comum e eficiente, é trabalharmos com correlation id’s, para diferentes requisições ou workers.

Para implementarmos esse conceito, iremos utilizar como padrão, um exemplo de API, que pode ser encontrada em: otaviolarrosa/DotnetApi (github.com).

Primeiro, iremos utilizar os seguintes pacotes:

Serilog
Serilog.AspNetCore
Serilog.Enrichers.CorrelationId

Conforme exemplificado no arquivo .csproj da aplicação

  <Project Sdk="Microsoft.NET.Sdk.Web">

    <PropertyGroup>
        <TargetFramework>net6.0</TargetFramework>
        <Nullable>enable</Nullable>
        <ImplicitUsings>enable</ImplicitUsings>
    </PropertyGroup>

    <ItemGroup>
        <PackageReference Include="Microsoft.AspNet.WebApi.Core" Version="5.2.9" />
        <PackageReference Include="Serilog" Version="2.11.0" />
        <PackageReference Include="Serilog.AspNetCore" Version="6.0.1" />
        <PackageReference Include="Serilog.Enrichers.CorrelationId" Version="3.0.1" />
        <PackageReference Include="Serilog.Enrichers.Memory" Version="1.0.4" />
        <PackageReference Include="Serilog.Sinks.Console" Version="4.0.1" />
        <PackageReference Include="Swashbuckle.AspNetCore" Version="6.4.0" />
        <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="6.0.8">
            <PrivateAssets>all</PrivateAssets>
            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
        </PackageReference>
    </ItemGroup>

    <ItemGroup>
        <ProjectReference Include="..\..\StreamNet\StreamNet\StreamNet.csproj" />
        <ProjectReference Include="..\Application\Application.csproj" />
        <ProjectReference Include="..\Consumers\Consumers.csproj" />
        <ProjectReference Include="..\Infrastructure\Infrastructure.csproj" />
        <ProjectReference Include="..\Producers\Producers.csproj" />
    </ItemGroup>

</Project>

Após isso, também é necessário configurar no startup do projeto, alguns pontos para utilizarmos o Serilog, tais como:

Utilização do Serilog com o Enricher do CorrelationId
Utilização do Serilog, para utilizar o CorrelationId que vem do chamador da requisição, caso queira uma rastreabilidade integrada
Formatação de um template para facilitar a leitura dos logs

using Application.Extensions;
using Consumers;
using Infrastructure.Extensions;
using Producers;
using Serilog;
using StreamNet;

var builder = WebApplication.CreateBuilder(args);


Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .Enrich.WithCorrelationId() //Aqui, pedimos para o Serilog utilizar a feature de correlation Id.
    .Enrich.WithCorrelationIdHeader() //Aqui, pedimos para utilizar o correlation Id, de quem solicitou a chamada na requisição HTTP, para que o trace fique ainda mais rico, com os logs do frontend.
    .WriteTo.Console(outputTemplate: "[{CorrelationId} - {Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}") //Aqui, formatamos um template para formatação dos logs padronizados, à fim de facilitar a leitura.
    .CreateLogger();

builder.Host.UseSerilog(); //Adicionamos o Serilog dentro do Host do nosso serviço
builder.Services.AddHttpContextAccessor();
builder.Services.AddSingleton(builder.Logging);

builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

builder.Services.RegisterApplicationDependencies(builder.Configuration);
builder.Services.RegisterInfrastructureDependencies(builder.Configuration);
builder.Services.AddProducers();
builder.Services.AddConsumers();
builder.Services.AddTopicManagement();

var app = builder.Build();
app.RunMigrations();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseAuthorization();

app.MapControllers();

app.Run();

Após isso, temos apenas que utilizar a interface ILogger da abstração Microsoft.Extensions.Logging, como na controller abaixo:

using Application.UseCases.User.CreateUser.Input;
using Application.UseCases.User.RequestCreateUser;
using Microsoft.AspNetCore.Mvc;
using System.Net;

namespace Api.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class UserController : ControllerBase
    {
        private readonly IRequestCreateUserUseCase _requestCreateUserUseCase;
        private readonly ILogger<UserController> _logger;

        public UserController(IRequestCreateUserUseCase requestCreateUserUseCase, ILogger<UserController> logger)
        {
            _requestCreateUserUseCase = requestCreateUserUseCase;
            _logger = logger;
        }

        [HttpPost]
        [Route("/user")]
        public async Task<IActionResult> CreateUser([FromBody]RequestCreateUserInput userInput)
        {
            try
            {
                _logger.LogInformation("Starting request {method} with params {@input}", nameof(CreateUser), userInput);
                await _requestCreateUserUseCase.ExecuteAsync(userInput);
                _logger.LogInformation("Ended request {method} with params {@input}", nameof(CreateUser), userInput);
                return Ok();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "A unexpected error occurred in {method} with params {@input}", nameof(CreateUser), userInput);
                return StatusCode((int)HttpStatusCode.InternalServerError, "A unexpected error occurred in CreateUser.");
            }
        }
    }
}

E assim, temos como resultado, um template bem simples de ler, e com o correlationId :)

DEV Community: Otávio Larrosa

1 - A briefly understanding about Garbage collecting strategy in C#.

1 - How the CLR allocates memory?

2 - How the Garbage Collector runs?

3 - When the GC runs?

Trabalhando com correlationId em .Net + Serilog