Introducción

Cada vez que ocurre un problema en producción, lo primero que hacemos es abrir los logs. Pero ¿cuántas veces te has encontrado con algo así?

1
Erro ao processar pedido

Sin OrderId. Sin CustomerId. Sin saber en qué instancia ocurrió ni en qué versión de la aplicación. Este tipo de log existe en miles de aplicaciones — y no ayuda absolutamente a nadie.

El problema no es la falta de logs. Es la falta de contexto, la falta de estructura y la falta de control. Cuando la aplicación necesita más detalle, tienes que cambiar la configuración, hacer deploy, esperar el reinicio — y cruzar los dedos para capturar el error antes de revertir.

En este artículo, voy a mostrar una estrategia completa de logging para .NET 8 que resuelve estos tres problemas de una vez:

  • Estructurado: cada entrada de log lleva propiedades tipadas, no solo texto plano
  • Contextual: cada línea de log incluye automáticamente información de la aplicación, del host y del request
  • Dinámico: el nivel de log se puede cambiar en producción con un timer de reversión automática — sin deploy, sin reinicio

Todo esto usando el ILogger<T> nativo, sin crear wrappers innecesarios, cumpliendo con SonarQube e integrado con Azure Application Insights.

La implementación completa está disponible en el repositorio blog-zocateli-sample en GitHub. A lo largo del artículo, voy a mostrar los fragmentos clave y explicar el razonamiento detrás de cada decisión. Si quieres ver el contexto completo en cualquier momento, consulta las fuentes en el repositorio.

📦 Código fuente: La implementación completa de este artículo está en el repositorio blog-zocateli-sample en GitHub. Clónalo, explóralo y adáptalo a tu contexto.

💡 Este artículo complementa el Pipeline de Configuración de .NET 8+, que explica cómo funcionan el sistema de configuración, IOptions<T> y los secrets. La estrategia de logging descrita aquí depende directamente de esos conceptos.


El Problema: Por Qué tus Logs No Ayudan

Considera estos dos escenarios reales de log en producción:

Antes — log sin contexto:

1
2
3
info: Pedido processado
warn: Falha ao validar item
error: Erro ao processar pedido

Un analista de soporte mira esto y no puede responder ninguna pregunta: ¿qué pedido? ¿De qué cliente? ¿En qué instancia? ¿Era la versión nueva o la antigua? ¿Este error se reproduce o fue puntual?

Después — log estructurado con contexto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
{
  "Timestamp": "2026-03-07T14:32:18.123Z",
  "Level": "Error",
  "Message": "Failed to process order 3fa85f64-5717-4562-b3fc-2c963f66afa6 for customer C-1234",
  "OrderId": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
  "CustomerId": "C-1234",
  "ApplicationName": "SampleApi",
  "ApplicationVersion": "1.0.0",
  "HostName": "pod-api-7b4f9c",
  "Environment": "Production",
  "CorrelationId": "0HN6KQ2JH2S5E:00000001",
  "EventId": 2004
}

Con este segundo formato, el analista puede:

  • Filtrar por OrderId para ver todo lo que le ocurrió a ese pedido
  • Agrupar por HostName para identificar si el problema es de una instancia específica
  • Usar el CorrelationId para rastrear todo el pipeline de un único request
  • Comparar ApplicationVersion para saber si el bug es de la versión nueva

El costo del troubleshooting cae drásticamente. En lugar de horas rebuscando en logs genéricos, encuentras la causa en minutos con una query en Application Insights.

💡 Un log sin contexto en producción es como buscar un error en Google sin escribir el mensaje de error — técnicamente estás buscando, pero no vas a encontrar nada útil.


Logging Estructurado: Qué Es y Por Qué Importa

Logging estructurado significa que cada entrada de log lleva propiedades tipadas e indexables, no solo un string concatenado.

En .NET, la diferencia es sutil en el código pero enorme en el resultado:

1
2
3
4
5
// ✅ Estructurado — "OrderId" se convierte en una propiedad separada
_logger.LogInformation("Order {OrderId} created for customer {CustomerId}", orderId, customerId);

// ❌ Interpolación — pierde las propiedades, se convierte en texto plano
_logger.LogInformation($"Order {orderId} created for customer {customerId}");

Cuando usas la plantilla con {OrderId}, ILogger preserva el valor como una propiedad separada. En Application Insights, aparece en customDimensions y se puede filtrar, agregar y correlacionar con queries KQL. Cuando usas string interpolation con $, el valor queda embebido en el mensaje — Application Insights recibe solo texto y no puede indexarlo.

Las consecuencias prácticas son directas:

  • Con propiedades estructuradas: customDimensions["OrderId"] == "3fa85f64..." — filtrable
  • Con un string interpolado: necesitas usar contains o una regex sobre el mensaje — lento e impreciso

Además de la cuestión funcional, SonarQube marca la string interpolation en logs como la regla S6664 (Log message template should be compile-time constant), ya que puede afectar el rendimiento y se pierde la capacidad de agrupar mensajes similares.

⚠️ Nunca uses $"Pedido {orderId}" en llamadas de log. Eso crea un string nuevo en cada llamada (incluso cuando el nivel de log está deshabilitado) y pierde la propiedad estructurada. Usa siempre la plantilla: "Pedido {OrderId}".


Enriquecimiento Automático: Contexto de la Aplicación en Cada Log

Si cada desarrollador tiene que acordarse de incluir ApplicationName, HostName y CorrelationId en cada llamada de log, eso no va a suceder. La solución es enriquecer automáticamente.

Middleware con ILogger.BeginScope()

ILogger admite scopes — un bloque que agrega propiedades a todas las entradas de log hechas dentro de él. Combinando esto con un middleware, garantizamos que todo log de cualquier request lleve el contexto de la aplicación:

 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
public sealed class LogEnrichmentMiddleware : IMiddleware
{
    private readonly IOptions<LoggingOptions> _options;
    private readonly IHostEnvironment _environment;

    public LogEnrichmentMiddleware(IOptions<LoggingOptions> options, IHostEnvironment environment)
    {
        _options = options;
        _environment = environment;
    }

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        var logger = context.RequestServices
            .GetRequiredService<ILogger<LogEnrichmentMiddleware>>();

        var enrichmentData = new Dictionary<string, object>
        {
            ["ApplicationName"] = _options.Value.ApplicationName,
            ["ApplicationVersion"] = _options.Value.Version,
            ["HostName"] = Environment.MachineName,
            ["Environment"] = _environment.EnvironmentName,
            ["CorrelationId"] = context.TraceIdentifier
        };

        using (logger.BeginScope(enrichmentData))
        {
            await next(context);
        }
    }
}

El middleware se registra como singleton (por implementar IMiddleware) y se activa en el pipeline:

1
2
3
builder.Services.AddSingleton<LogEnrichmentMiddleware>();
// ...
app.UseMiddleware<LogEnrichmentMiddleware>();

Las propiedades ApplicationName y Version vienen de una sección dedicada del appsettings.json:

1
2
3
4
5
6
7
8
{
  "Logging": {
    "Application": {
      "ApplicationName": "SampleApi",
      "Version": "1.0.0"
    }
  }
}

ℹ️ La clase LoggingOptions se configura mediante el patrón IOptions<T>. Si quieres entender en profundidad cómo funciona este mecanismo, consulta el artículo sobre el Pipeline de Configuración de .NET 8+.

TelemetryInitializer para Application Insights

BeginScope() enriquece los logs de ILogger, pero la telemetría que Application Insights captura automáticamente (requests HTTP, dependencias, exceptions) no pasa por ILogger. Para garantizar que toda la telemetría lleve las mismas propiedades, usamos un ITelemetryInitializer:

 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
public sealed class ApplicationTelemetryInitializer : ITelemetryInitializer
{
    private readonly string _applicationName;
    private readonly string _version;
    private readonly string _hostName;
    private readonly string _environment;

    public ApplicationTelemetryInitializer(
        IOptions<LoggingOptions> options, IHostEnvironment env)
    {
        _applicationName = options.Value.ApplicationName;
        _version = options.Value.Version;
        _hostName = Environment.MachineName;
        _environment = env.EnvironmentName;
    }

    public void Initialize(ITelemetry telemetry)
    {
        telemetry.Context.GlobalProperties.TryAdd("ApplicationName", _applicationName);
        telemetry.Context.GlobalProperties.TryAdd("ApplicationVersion", _version);
        telemetry.Context.GlobalProperties.TryAdd("HostName", _hostName);
        telemetry.Context.GlobalProperties.TryAdd("Environment", _environment);
        telemetry.Context.Component.Version = _version;
    }
}

Registrado en el DI como:

1
builder.Services.AddSingleton<ITelemetryInitializer, ApplicationTelemetryInitializer>();

Con estas dos piezas tienes cobertura completa: LogEnrichmentMiddleware para los logs de ILogger y ApplicationTelemetryInitializer para request traces, dependency calls y exceptions capturadas automáticamente por el SDK.


Nivel de Log Dinámico con Timer Automático

Escenario real: tu aplicación en producción tiene un comportamiento extraño. Necesitas ver logs de nivel Debug para entender qué está pasando. Pero el appsettings.json de producción está configurado con Information.

El camino tradicional sería: cambiar la configuración, hacer deploy (o reiniciar), capturar los logs detallados y después deshacerlo todo para no ahogar a Application Insights en volumen (y costo). Este proceso puede llevar de minutos a horas dependiendo de tu pipeline.

La solución propuesta aquí es un endpoint administrativo que cambia el nivel de log en runtime, con un timer de reversión automática:

1
2
3
4
5
POST /api/admin/log-level
{
  "level": "Debug",
  "durationMinutes": 15
}

Después de 15 minutos, el nivel vuelve automáticamente al configurado en el appsettings.json. Sin deploy. Sin reinicio. Sin riesgo de olvidar el Debug encendido.

El Mecanismo: ConfigurationProvider Personalizado

El sistema de logging de .NET lee los niveles de log del pipeline de configuración. La clave que define el nivel por defecto es Logging:LogLevel:Default, y por categoría es Logging:LogLevel:{CategoryName}.

La estrategia es crear un ConfigurationProvider personalizado que pueda actualizarse en runtime y que, al cambiar, dispare OnReload() para notificar al framework:

 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
public sealed class DynamicLogLevelConfigurationProvider : ConfigurationProvider
{
    public override void Load()
    {
        // Starts empty — values are set dynamically via Update()
    }

    public void Update(string key, string value)
    {
        if (value is null)
        {
            Data.Remove(key);
        }
        else
        {
            Data[key] = value;
        }

        OnReload();
    }

    public void Clear()
    {
        Data.Clear();
        OnReload();
    }
}

El punto crítico es el registro: este provider debe agregarse al final del pipeline de configuración, para que su valor sobrescriba el del appsettings.json:

1
2
3
// En Program.cs — DESPUÉS de CreateBuilder (que ya agrega appsettings)
((IConfigurationBuilder)builder.Configuration)
    .Add(new DynamicLogLevelConfigurationSource());

El Servicio con Timer

DynamicLogLevelService orquesta la lógica de cambio y de reversión automática:

 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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
public sealed class DynamicLogLevelService : IDisposable
{
    private readonly DynamicLogLevelConfigurationProvider _provider;
    private readonly ILogger<DynamicLogLevelService> _logger;
    private readonly object _lock = new();
    private Timer _revertTimer;
    private LogLevelOverride _currentOverride;

    public DynamicLogLevelService(
        IConfiguration configuration,
        ILogger<DynamicLogLevelService> logger)
    {
        _logger = logger;
        var root = configuration as IConfigurationRoot
            ?? throw new InvalidOperationException("...");
        _provider = root.Providers
            .OfType<DynamicLogLevelConfigurationProvider>()
            .FirstOrDefault()
            ?? throw new InvalidOperationException("...");
    }

    public void SetLogLevel(
        string category, LogLevel level, TimeSpan duration)
    {
        ArgumentOutOfRangeException
            .ThrowIfLessThanOrEqual(duration, TimeSpan.Zero, nameof(duration));

        var key = $"Logging:LogLevel:{category ?? "Default"}";

        lock (_lock)
        {
            _revertTimer?.Dispose();
            _provider.Update(key, level.ToString());

            _currentOverride = new LogLevelOverride(
                Category: category,
                Level: level,
                ExpiresAt: DateTimeOffset.UtcNow.Add(duration));

            _revertTimer = new Timer(
                callback: _ => RevertToDefault(),
                state: null,
                dueTime: duration,
                period: Timeout.InfiniteTimeSpan);
        }
    }

    public void RevertToDefault()
    {
        lock (_lock)
        {
            _revertTimer?.Dispose();
            _revertTimer = null;
            _provider.Clear();
            _currentOverride = null;
        }
    }
}

Puntos importantes de esta implementación:

  • El Timer se crea con Timeout.InfiniteTimeSpan como period — se ejecuta una única vez después del dueTime
  • Si se vuelve a llamar a SetLogLevel antes de que el timer expire, el timer anterior se descarta y se crea uno nuevo
  • El lock garantiza thread safety entre el timer (que se ejecuta en un hilo del ThreadPool) y las llamadas simultáneas
  • Se implementa IDisposable para la limpieza correcta del Timer

💡 Protege este endpoint con la autorización adecuada — en producción, solo los administradores deberían cambiar el nivel de log. Consulta el artículo sobre Autenticación y Autorización: JWT, OAuth2 y OpenID Connect para ver estrategias de protección.


ILogger Nativo: Sin Reinventar la Rueda

Un patrón que veo con una frecuencia preocupante es la creación de un ICustomLogger o LogService que encapsula el ILogger<T>:

1
2
3
4
5
6
// ❌ Anti-pattern — NO hagas esto
public class CustomLogger
{
    private readonly ILogger<CustomLogger> _logger;
    public void LogInfo(string message) => _logger.LogInformation(message);
}

Este wrapper rompe varios mecanismos:

  • La categoría del log pasa a ser siempre CustomLogger en lugar de la clase real que originó el log
  • Los filtros por namespace (Logging:LogLevel:MiNamespace) dejan de funcionar
  • La trazabilidad en Application Insights se ve perjudicada
  • Los tests se vuelven más complejos (hay que mockear el wrapper y no el ILogger)

El enfoque correcto en el .NET moderno es usar ILogger<T> directamente y el atributo [LoggerMessage] para generar los métodos de log mediante un source generator:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static partial class LogMessages
{
    [LoggerMessage(
        EventId = 2000,
        Level = LogLevel.Information,
        Message = "Order {OrderId} created for customer {CustomerId}, total: {Total}")]
    public static partial void OrderCreated(
        ILogger logger, Guid orderId, string customerId, decimal total);

    [LoggerMessage(
        EventId = 2003,
        Level = LogLevel.Debug,
        Message = "Processing order {OrderId}: validating {ItemCount} items for customer {CustomerId}")]
    public static partial void OrderProcessingDebug(
        ILogger logger, Guid orderId, int itemCount, string customerId);

    [LoggerMessage(
        EventId = 2004,
        Level = LogLevel.Error,
        Message = "Failed to process order {OrderId} for customer {CustomerId}")]
    public static partial void OrderFailed(
        ILogger logger, Exception exception, Guid orderId, string customerId);
}

Beneficios del Source Generator [LoggerMessage]

  1. Rendimiento: el source generator crea código que verifica el nivel de log antes de construir el mensaje — cero asignaciones cuando el log está deshabilitado
  2. AOT-friendly: compatible con Native AOT, sin reflection en runtime
  3. Cumplimiento con SonarQube: resuelve las reglas S6664 (plantilla constante en tiempo de compilación), S2629 (logging guard) y S6667 (structured logging)
  4. EventId: cada mensaje tiene un ID numérico fijo, lo que facilita alertas y dashboards
  5. Testeable: como son métodos estáticos con ILogger como parámetro, pasar un mock en los tests es trivial

El uso es directo en cualquier endpoint o servicio:

1
LogMessages.OrderCreated(logger, newOrder.Id, newOrder.CustomerId, newOrder.Total);

⚠️ Crear un ICustomLogger que encapsula ILogger<T> añade una capa sin valor, rompe la trazabilidad y dificulta los tests. Usa ILogger<T> directamente con [LoggerMessage] — es la abstracción correcta.


Integración con Azure Application Insights

Application Insights es el APM (Application Performance Management) de Azure que captura automáticamente requests HTTP, dependencias (bases de datos, HTTP clients, colas) y exceptions. El logging estructurado que implementamos complementa esa telemetría automática con el contexto de negocio.

Setup

La configuración es mínima — una línea en Program.cs y la connection string en la configuración:

1
2
builder.Services.AddApplicationInsightsTelemetry();
builder.Services.AddSingleton<ITelemetryInitializer, ApplicationTelemetryInitializer>();
1
2
3
4
5
{
  "ApplicationInsights": {
    "ConnectionString": "InstrumentationKey=..."
  }
}

⚠️ Nunca pongas la connection string directamente en el código fuente ni en el appsettings.json versionado. Usa variables de entorno, Azure Key Vault o User Secrets para el desarrollo local. Consulta cómo configurarlo en el artículo Pipeline de Configuración de .NET 8+.

Cómo Aparece el Log Estructurado en Application Insights

Cuando haces un log usando [LoggerMessage] con propiedades estructuradas, cada propiedad aparece en customDimensions en Application Insights. Combinado con las propiedades inyectadas por LogEnrichmentMiddleware y por ApplicationTelemetryInitializer, el resultado es:

ColumnaValor
messageOrder 3fa85f64… created for customer C-1234, total: 150.00
customDimensions.OrderId3fa85f64-5717-4562-b3fc-2c963f66afa6
customDimensions.CustomerIdC-1234
customDimensions.Total150.00
customDimensions.ApplicationNameSampleApi
customDimensions.ApplicationVersion1.0.0
customDimensions.HostNamepod-api-7b4f9c
customDimensions.CorrelationId0HN6KQ2JH2S5E:00000001

Queries KQL para Troubleshooting

Con estas propiedades indexadas, las queries en Application Insights se vuelven quirúrgicas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
// Todos los logs de un pedido específico
traces
| where customDimensions["OrderId"] == "3fa85f64-5717-4562-b3fc-2c963f66afa6"
| project timestamp, message, severityLevel,
          tostring(customDimensions["ApplicationVersion"]),
          tostring(customDimensions["HostName"])
| order by timestamp asc

// Errores agrupados por host (detecta la instancia problemática)
traces
| where severityLevel >= 3
| summarize ErrorCount = count() by tostring(customDimensions["HostName"])
| order by ErrorCount desc

// Correlacionar logs con el request HTTP
traces
| where customDimensions["CorrelationId"] == "0HN6KQ2JH2S5E:00000001"
| union requests
| where operation_Id == "0HN6KQ2JH2S5E:00000001"
| order by timestamp asc

ℹ️ Application Insights ya captura automáticamente requests HTTP, dependencias y exceptions — el log estructurado lo complementa con el contexto de negocio que solo tu aplicación conoce.


La Aplicación de Ejemplo

La aplicación de ejemplo implementa todos los conceptos de este artículo en una Minimal API de .NET 8. La estructura del proyecto organiza los componentes de logging en una carpeta dedicada:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
dotnet-structured-logging-sample/
├── src/SampleApi/
│   ├── Program.cs                  # Composición: DI, middleware, endpoints
│   ├── appsettings.json            # Configuración con la sección Logging:Application
│   ├── Logging/
│   │   ├── DynamicLogLevelConfigurationSource.cs
│   │   ├── DynamicLogLevelConfigurationProvider.cs
│   │   ├── DynamicLogLevelService.cs
│   │   ├── LogEnrichmentMiddleware.cs
│   │   ├── ApplicationTelemetryInitializer.cs
│   │   ├── LoggingOptions.cs
│   │   └── LogMessages.cs          # [LoggerMessage] source generator
│   ├── Endpoints/
│   │   ├── LogLevelEndpoints.cs    # GET/POST/DELETE /api/admin/log-level
│   │   └── OrderEndpoints.cs       # POST/GET /api/orders (ejemplo de negocio)
│   └── Models/
│       ├── SetLogLevelRequest.cs
│       └── Order.cs
├── tests/SampleApi.Tests/          # 13 tests unitarios con xUnit y NSubstitute
├── README.md
├── global.json                     # Fijado en el SDK 8.0.418
└── SampleApi.sln

Diagrama de arquitectura que muestra el flujo del request por el middleware de enriquecimiento, el ILogger con LoggerMessage y Application Insights

El diagrama anterior muestra cómo se conectan los componentes: cada request HTTP pasa por el LogEnrichmentMiddleware, que abre un BeginScope() con las propiedades de contexto. Cualquier llamada de log hecha dentro de ese request — ya sea en los endpoints, en los servicios o en bibliotecas internas — hereda automáticamente esas propiedades. En paralelo, ApplicationTelemetryInitializer garantiza que la telemetría automática de Application Insights (requests, dependencies) también lleve la misma información.

Cómo Ejecutar Localmente

1
2
cd src/SampleApi
dotnet run

Prueba el endpoint de log dinámico:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
# Activar Debug durante 15 minutos
curl -X POST http://localhost:5000/api/admin/log-level \
  -H "Content-Type: application/json" \
  -d '{"level": "Debug", "durationMinutes": 15}'

# Verificar el estado actual
curl http://localhost:5000/api/admin/log-level

# Revertir manualmente al valor por defecto
curl -X DELETE http://localhost:5000/api/admin/log-level

El repositorio completo con instrucciones detalladas está en github.com/lzocateli/blog-zocateli-sample — Logging.


Consejos y Buenas Prácticas

Estas son las prácticas que considero esenciales para una estrategia de logging robusta:

  1. Usa las categorías de log con criterio: .NET usa el namespace de la clase como categoría (ILogger<OrderService> genera la categoría SampleApi.Endpoints.OrderService). Esto permite filtrar por namespace en el appsettings.json — por ejemplo, "SampleApi.Endpoints": "Debug" activa debug solo en los endpoints sin afectar al resto de la aplicación.

  2. Nunca registres datos sensibles: nombres, CPF (identificación fiscal brasileña), tokens, contraseñas y datos financieros no deben aparecer en los logs. Además del riesgo de seguridad, la LGPD brasileña exige la protección de los datos personales. Si necesitas rastrear a un usuario, usa un identificador opaco como CustomerId.

  3. Controla el costo de Application Insights: con volumen alto, Application Insights cobra por la ingesta de datos. Usa sampling adaptativo para reducir el volumen sin perder visibilidad. La configuración por defecto del SDK ya incluye sampling — evita deshabilitarlo sin un cálculo de costos.

  4. EventId consistente por mensaje: cada [LoggerMessage] debe tener un EventId único y fijo. Esto permite crear alertas en Azure Monitor basadas en el EventId (más confiable que una regex sobre el mensaje) y facilita los dashboards de operación.

  5. Entorno de desarrollo con consola JSON: configura appsettings.Development.json para usar el JsonConsoleFormatter con IncludeScopes: true. Esto muestra las propiedades estructuradas directamente en la terminal durante el desarrollo, sin necesidad de Application Insights.

  6. Prueba los logs: con [LoggerMessage] e ILogger<T>, es trivial verificar en los tests unitarios si se emitieron los logs correctos. La aplicación de ejemplo incluye tests del middleware que verifican las propiedades inyectadas en el scope.

  7. Registra las operaciones administrativas como Warning: los cambios de nivel de log, los reinicios y las operaciones manuales deben registrarse como Warning — visibles por defecto y fáciles de auditar.


Conclusión

Un logging eficiente no se trata de cantidad — se trata de calidad y contexto. En este artículo, cubrimos tres pilares que, juntos, transforman los logs de ruido en una herramienta de diagnóstico:

  • Estructura: propiedades tipadas con el source generator [LoggerMessage] en lugar de strings concatenados
  • Contexto automático: LogEnrichmentMiddleware con BeginScope() y ApplicationTelemetryInitializer garantizan que cada entrada de log lleve la información de la aplicación, del host y del request
  • Control dinámico: un ConfigurationProvider personalizado con OnReload() y un timer permite activar Debug en producción de forma segura y temporal

Todo esto funciona con el ILogger<T> nativo de .NET — sin wrappers, sin abstracciones inventadas, sin romper SonarQube. Application Insights recibe las propiedades en customDimensions, lo que permite queries KQL quirúrgicas para el troubleshooting.

Si tu aplicación todavía usa _logger.LogInformation($"Procesando pedido {id}"), ahora es un buen momento para evolucionar. Clona el repositorio de ejemplo, adáptalo a tu contexto y nota la diferencia la próxima vez que necesites investigar un problema en producción.

Para trabajar con logs en servicios background de larga duración, mira cómo aplicar esta misma estrategia en Worker y Background Service en .NET: Alto Volumen.


Lee También


Referencias