Rotación de archivos de log en Serilog: intervalos y retención

Pasa rollingInterval al sink de archivo y Serilog empezará un archivo nuevo con esa periodicidad: .WriteTo.File("logs/log.txt", rollingInterval: RollingInterval.Day) genera log20260824.txt, log20260825.txt y así sucesivamente.

Otras dos opciones deciden durante cuánto tiempo eso sigue siendo manejable. retainedFileCountLimit limita cuántos archivos se conservan antes de eliminar el más antiguo, y fileSizeLimitBytes junto con rollOnFileSizeLimit empieza un archivo nuevo cuando el actual crece demasiado. Sin este último, el sink simplemente deja de escribir cuando se alcanza el límite.

Para una guía más detallada sobre Serilog, consulta el artículo sobre buenas prácticas de logging con Serilog en .NET.

Primeros pasos con el sink de archivo de Serilog

Primero, vamos a crear una aplicación ASP.NET Core MVC sencilla. Necesitaremos instalar los paquetes NuGet Serilog.Sinks.File y Serilog.AspNetCore:

PM> Install-Package Serilog.Sinks.File -Version 7.0.0

PM> Install-Package Serilog.AspNetCore -Version 10.0.0

A continuación, veamos cómo configurar el logging con rotación de archivos en Serilog. Lo hacemos en el archivo principal, Program.cs:

using Serilog;

Log.Logger = new LoggerConfiguration()
    .WriteTo.File("logs/log.txt",
    rollingInterval: RollingInterval.Day,
    rollOnFileSizeLimit: true)
    .CreateLogger();

Configuramos el parámetro rollingInterval para que use RollingInterval.Day, de modo que se cree un archivo de log nuevo cada día. Además, habilitamos la rotación por tamaño de archivo estableciendo rollOnFileSizeLimit en true.

Asignar la configuración a Log.Logger es solo la mitad de la integración. Los loggers que reciben los controladores vienen del propio sistema de logging del host, así que también lo conectamos a Serilog:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();

builder.Host.UseSerilog();

UseSerilog() viene en el paquete Serilog.AspNetCore y, sin argumentos, envía todo a través del Log.Logger estático que configuramos más arriba. Este es también el paso que coloca Serilog detrás de la API ILogger de Microsoft, de modo que nada en el código de nuestra aplicación necesita saber que Serilog está ahí.

Con la configuración lista, vamos a entrar en el directorio Controllers y abrir la clase HomeController. Ahí podemos agregar un logger a través del constructor y actualizar el código del método Index:

private readonly ILogger<HomeController> _logger;

public HomeController(ILogger<HomeController> logger)
{
    _logger = logger;
}

public IActionResult Index()
{
    _logger.LogInformation("TESTING MESSAGE 123..");

    return View();
}

El método Index registra un mensaje de nivel informativo a través de _logger, un ILogger<HomeController> que el framework inyecta en el constructor. Ese logger inyectado llega al archivo solo gracias a la llamada a UseSerilog() de más arriba.

Al ejecutar la aplicación y navegar un poco por ella, podemos ver cómo se crea un nuevo directorio logs en la raíz del proyecto:

El directorio logs contiene archivos de log cuyo nombre indica el punto de rotación, por ejemplo, log20260824.txt. Según nuestra configuración, la aplicación crea un archivo de log nuevo cada día. Si abrimos ese archivo, encontramos nuestra entrada informativa entre los propios mensajes de inicio del host:

2026-08-24 00:17:11.927 +02:00 [INF] TESTING MESSAGE 123..

El formato de esa línea viene de la plantilla de salida predeterminada del sink, que el parámetro outputTemplate reemplaza cuando queremos otra distinta. El texto que sigue al nivel es el mensaje renderizado, y por eso vale la pena escribir bien las plantillas de mensajes.

¿Qué valores tiene RollingInterval en Serilog?

RollingInterval es una enumeración con seis valores: Infinite, Year, Month, Day, Hour y Minute.

Infinite es el valor predeterminado y significa exactamente lo que dice: el archivo nunca rota y no se agrega ninguna información de fecha ni de hora a su nombre.

Los otros cinco marcan el momento en que empieza un archivo nuevo, y cada uno fija también el formato del nombre del archivo. Day genera log20260824.txt; Hour genera log2026082414.txt; Minute agrega los minutos. La fecha se inserta antes de la extensión, así que la ruta que pasamos es una plantilla y no un nombre de archivo literal.

Cuál elegir depende de cuánto crece un solo archivo. Day es adecuado para la mayoría de las aplicaciones. Hour conviene en servicios de gran volumen, en los que un archivo diario crecería demasiado para abrirlo con comodidad. Month y Year encajan en trabajos en segundo plano de poco volumen, en los que un archivo diario quedaría vacío en su mayor parte.

Políticas de rotación en el sink de archivo de Serilog

El paquete NuGet Serilog.Sinks.File admite varias políticas de rotación para controlar la creación de archivos de log nuevos. Veamos las que suelen usar los desarrolladores:

• RollingInterval
• FileSizeLimitBytes
• RetainedFileCountLimit
• RollOnFileSizeLimit

RollingInterval

Esta política especifica el intervalo de tiempo tras el cual debe crearse un archivo de log nuevo. Las opciones disponibles son los seis miembros de la enumeración: RollingInterval.Infinite, RollingInterval.Year, RollingInterval.Month, RollingInterval.Day, RollingInterval.Hour y RollingInterval.Minute. Infinite es el valor predeterminado, así que un sink de archivo configurado sin este parámetro no rota nunca por tiempo. El código fuente de RollingInterval del propio Serilog.Sinks.File documenta ese valor así: “El archivo de log nunca rotará; no se agregará información del periodo de tiempo al nombre del archivo de log”.

Consulta la implementación de ejemplo que tenemos en la sección de primeros pasos.

FileSizeLimitBytes

El objetivo de establecer FileSizeLimitBytes es controlar el tamaño máximo de cada archivo de log:

    var log = new LoggerConfiguration()
    .WriteTo.File("logs/log.txt",
      fileSizeLimitBytes: 524288000,
      rollOnFileSizeLimit: true)
      .CreateLogger();

Al especificar un límite de tamaño de archivo con el parámetro fileSizeLimitBytes y establecer además el parámetro rollOnFileSizeLimit en true, nos aseguramos de que los archivos de log no crezcan indefinidamente hasta volverse demasiado grandes para gestionarlos y consumirlos con eficacia. El README del sink indica el valor predeterminado sin rodeos: “el sink de archivo limita el tamaño de los archivos a 1 GB de forma predeterminada”. A los desarrolladores de software les suele resultar más fácil buscar, analizar y diagnosticar problemas en archivos de log más pequeños con un visor.

Cuando alcanzamos el límite de 500 megabytes (524 288 000 bytes), Serilog creará un archivo de log nuevo y seguirá escribiendo los logs en él.

RetainedFileCountLimit

Los desarrolladores la consideran una política importante; la usamos para especificar el número máximo de archivos de log que se conservan:

var log = new LoggerConfiguration()
    .WriteTo.File("logs/log.txt",
     retainedFileCountLimit: 21,
     rollingInterval: RollingInterval.Day)
     .CreateLogger();

Con esta configuración, nos aseguramos de que los archivos de log antiguos se eliminen según el parámetro retainedFileCountLimit. El valor predeterminado es 31, más o menos un mes de los largos, como recoge el README del sink (consultado el 13 de septiembre de 2026). El archivo de log más antiguo se eliminará si el número de archivos supera este límite.

RollOnFileSizeLimit

En cuanto a la política de rotación FileSizeLimitBytes, establecer rollOnFileSizeLimit en true hace que se cree un archivo de log nuevo cuando alcanzamos el fileSizeLimitBytes especificado.

En cambio, si no habilitamos la rotación por tamaño de archivo estableciendo el parámetro en false, el sink deja de escribir eventos nuevos en el archivo una vez alcanzado el límite. Es importante tenerlo en cuenta, ya que puede provocar una pérdida de información.

¿El sink de archivo de Serilog crea el directorio?

Sí. El sink crea los directorios que falten en la ruta cuando abre el primer archivo, así que logs/log.txt funciona sin que tengamos que crear logs antes.

Por eso aparece una carpeta logs en la raíz del proyecto tras la primera ejecución de nuestra aplicación de ejemplo: no la creó nadie más que el propio sink.

Hay dos cosas que no hace. No pone la fecha en el nombre de una carpeta, así que logs/{Date}/log.txt crea una carpeta que se llama literalmente {Date}, y no arregla una ruta en la que el proceso no tiene permiso de escritura. Lo segundo falla en el momento de escribir y, de forma predeterminada, Serilog falla en silencio en lugar de lanzar una excepción, porque un logger que hace caer la aplicación por un problema de logging es peor que uno que descarta eventos.

Vale la pena tener presente ese silencio. SelfLog es el canal de diagnóstico propio de Serilog, y dirigirlo a la consola es la forma más rápida de averiguar por qué nunca apareció un archivo.

¿Qué opciones de rotación conviene configurar?

Tres, y funcionan en conjunto: un intervalo, un límite de tamaño con la rotación habilitada y un límite de retención.

El intervalo hace que los archivos sean fáciles de recorrer: con un archivo por día, encontrar el log de ayer es cuestión de leer el nombre del archivo. El límite de tamaño evita que un solo día de mucha actividad produzca un archivo demasiado grande para abrirlo. El límite de retención evita que la carpeta crezca indefinidamente.

La trampa es establecer el límite de tamaño sin rollOnFileSizeLimit: true. Para respetar el límite, el sink se detiene en lugar de rotar, así que el logging se interrumpe en silencio a mitad del día sin ningún error en ninguna parte.

En entornos regulados, vale la pena pensar con cuidado la retención. retainedFileCountLimit elimina por número, lo que significa que una semana tranquila y una semana con mucha actividad conservan cantidades distintas de historial. retainedFileTimeLimit elimina por antigüedad, que es como suele redactarse una política de retención, y cuando se establecen ambos gana el más estricto de los dos.

La salida comprimida no está en esa lista. El sink de archivo no tiene un parámetro gzip propio; en su lugar, expone un parámetro hooks, y una implementación de FileLifecycleHooks puede envolver el stream de salida dentro del método OnFileOpened para comprimir los eventos a medida que se escriben.

Conclusión

En este artículo, hemos visto cómo configurar el logging con rotación de archivos usando Serilog.Sinks.File. Al usar políticas de rotación como FileSizeLimitBytes y RetainedFileCountLimit, podemos gestionar los archivos de log con eficacia y asegurarnos de que no crezcan demasiado ni abarroten el sistema de archivos. Con Serilog podemos manejar los archivos de log de una aplicación .NET de forma flexible y eficiente.

Cuántos eventos llegan de entrada a esos archivos es una palanca aparte, y conviene recurrir a ella antes que al límite de retención: consulta los niveles de log de Serilog y el control del nivel mínimo. Una vez que el volumen es el adecuado, registrar el nombre de la clase y del método es lo que permite buscar en un archivo grande.

Recuerda ajustar las políticas de rotación según las necesidades de logging de la aplicación y las limitaciones de espacio en disco.

Probado con .NET 10.0.10.