Logging

🌍 Idioma: English | Español

Infraestructura de logging estructurado para Delphi inspirada en Microsoft.Extensions.Logging de .NET. Escribe entradas de log a través de una interfaz ILogger unificada — proveedores intercambiables (NNLog, consola, personalizados) registrados al arrancar.

¿Por qué usarlo?

🎚️ Seis niveles de log — Trace, Debug, Information, Warning, Error, Critical
📝 Logging estructurado — Marcadores {Clave} nombrados en plantillas de mensaje
🔌 Modelo de proveedores — Registra uno o más ILoggerProvider; todos reciben cada entrada
🏷️ Categorías — Los loggers se etiquetan por clase o nombre de cadena para filtrado
🔗 Scopes — Adjunta datos contextuales a un bloque de entradas con BeginScope
🛠️ Listo para DI — AddLogging(Services, ...) registra ILoggerFactory en el contenedor

Inicio rápido

uses
  Daf.Extensions.Logging,
  Daf.Logging,
  DAF.Logging.Builder,
  DAF.NNLog; // cualquier proveedor

// Sin DI
var Factory := TMultiProviderLoggerFactory.Create;
Factory.AddProvider(TNNLogProvider.Create(Targets, Rules));
var Logger := Factory.CreateLogger('MyApp');

Logger.LogInformation('Servidor arrancado en el puerto {Port}', [8080]);
Logger.LogError(Ex, 'Excepción no controlada en {Operation}', ['ProcessOrder']);

Niveles de log

Nivel	Valor	Cuándo usarlo
`Trace`	0	Extremadamente detallado — desactivado en producción
`Debug`	1	Diagnóstico de desarrollo
`Information`	2	Hitos del flujo normal de la app
`Warning`	3	Situaciones inesperadas pero recuperables
`Error`	4	Fallos en la operación actual
`Critical`	5	Requiere atención inmediata
`None`	6	Desactiva el logging

Logging estructurado

Usa marcadores nombrados en las plantillas de mensaje:

Logger.LogInformation('Usuario {UserId} autenticado desde {IP}', [UserId, RemoteIP]);
Logger.LogWarning('Reintento {Attempt} de {Max} para {Operation}', [3, 5, 'SendEmail']);

La plantilla y los argumentos se mantienen juntos en TLogState, lo que permite a los proveedores formatearlos o indexarlos de forma independiente.

Integración con DI y Hosting

uses DAF.Logging.Builder, DAF.NNLog;

// En ConfigureServices:
AddLogging(Services, procedure(Builder: ILoggingBuilder)
begin
  Builder.AddProvider(TNNLogProvider.Create(Targets, Rules));
end);

// Resolver en un servicio:
var Factory := Provider.GetRequiredService<ILoggerFactory>;
var Logger  := Factory.CreateLogger<TMyService>;

Documentación

📖 Guía de uso — scopes, logging estructurado, proveedores, DI, crear proveedores personalizados

Abstracciones

Logging.Abstractions

🌍 Idioma: English | Español

Contratos fundamentales de la infraestructura de logging de DAFce. Referencia estas interfaces al construir componentes que emiten entradas de log o al implementar proveedores personalizados — sin depender de ninguna implementación concreta de logging.

Interfaces

ILogger

Fachada por categoría que emite entradas de log.

ILogger = interface
  procedure Log(Level: TLogLevel; const Msg: string; const Args: array of const); overload;
  procedure Log(Level: TLogLevel; E: Exception; const Msg: string; const Args: array of const); overload;

  procedure LogTrace      (const Msg: string; const Args: array of const); overload;
  procedure LogDebug      (const Msg: string; const Args: array of const); overload;
  procedure LogInformation(const Msg: string; const Args: array of const); overload;
  procedure LogWarning    (const Msg: string; const Args: array of const); overload;
  procedure LogError      (const Msg: string; const Args: array of const); overload;
  procedure LogError      (E: Exception; const Msg: string; const Args: array of const); overload;
  procedure LogCritical   (const Msg: string; const Args: array of const); overload;
  procedure LogCritical   (E: Exception; const Msg: string; const Args: array of const); overload;

  function BeginScope(const Msg: string; const Args: array of const;
                      ScopedProc: TProc): ILogScopeVoid; overload;
end;

ILoggerFactory

Crea instancias de ILogger y distribuye las escrituras a todos los proveedores registrados.

ILoggerFactory = interface
  function  CreateLogger(const Category: string): ILogger; overload;
  function  CreateLogger(AClass: TClass): ILogger; overload;
  function  CreateLogger(TypeInfo: PTypeInfo): ILogger; overload;
  procedure AddProvider(Provider: ILoggerProvider);
end;

Ayuda genérica: Factory.CreateLogger<TMyClass> — usa el nombre de la clase como categoría.

ILoggerProvider

Produce instancias de ILogger para un destino de salida específico.

ILoggerProvider = interface
  function CreateLogger(const Category: string): ILogger;
end;

ILoggingBuilder

Interfaz fluida para configurar proveedores antes de que el host arranque (se usa dentro de AddLogging).

ILoggingBuilder = interface
  procedure AddProvider(Provider: ILoggerProvider);
  function  Build: ILoggerFactory;
end;

ILogScope / ILogScopeVoid

Representan un scope de logging activo. ILogScopeVoid es la versión devuelta por BeginScope cuando el procedimiento de scope no devuelve ningún valor.

Tipos de valor

TLogLevel

TLogLevel = (Trace, Debug, Information, Warning, Error, Critical, None);

TLogState

Contiene un mensaje de log estructurado — plantilla de cadena más argumentos posicionales.

TLogState = record
  Template: string;
  Args: TArray<TVarRec>;
  function Format: string;
end;

TLogEntry

Entrada de log individual entregada al método Write de un proveedor.

TLogEntry = record
  Level     : TLogLevel;
  Category  : string;
  EventId   : Integer;
  Exception : Exception;
  Scope     : string;
  State     : TLogState;
  Message   : string;
end;

Relacionado

Logging — implementación concreta y registro en DI
Logging — Guía de uso
NNLog — proveedor basado en reglas