PBS Delphi Logger - Thread-safe logging with multiple outputs

Simple Thread-Safe Logging for Delphi

A lightweight, thread-safe logging system for Delphi applications. Write log messages to multiple outputs simultaneously - files, console, or GUI memos. Uses a singleton pattern so you can log from anywhere in your code without passing logger instances around.

What's New in Version 2.0

Automatic pruning of old log files (Files_To_Keep), an On_Error hook for the file output, new Write overloads for logging a value against a label (string, boolean or integer), and a Last_Severe property for watchdog-style tracking of the last severe exception.

Two changes to be aware of if you're updating from Version 1.0:

The ATime : Boolean parameter is gone from TLogger.Write. Timestamp suppression is now controlled with the Include_TimeStamp class property instead - see the updated example below.
Add_Output previously discarded a second output of the same class, which silently broke the "Multiple File Outputs" pattern further down this page. That's fixed in 2.0 - TFile_Log_Output now explicitly allows more than one instance, so logging to two files at once works as documented again.

Key Features

Thread-safe via critical sections - safe to use from multiple threads
Multiple output targets - file, console, TMemo (or create your own)
Singleton pattern - use anywhere without initialization
Daily rotating log files with configurable naming, and automatic pruning of old files
Auto-closes files after 5 seconds of inactivity (saves file handles)
Optional class/method context tracking
Exception logging with formatted error blocks, plus severe-exception tracking for watchdog use
Precise timestamps with millisecond accuracy
Automatic log directory creation and validation

Basic Setup

Add outputs at application startup (e.g., in your .dpr file or main form's OnCreate):

uses
  PBS.LIB.Log, PBS.LIB.Log.Disk, PBS.LIB.Log.Console;

var
  LLog_Path : string;
begin
  // Setup file logging
  LLog_Path := 'C:\MyApp\Logs\';
  TLogger.Add_Output(TFile_Log_Output.Create(LLog_Path, 'MyApp'));
  
  // Add console output for debugging
  TLogger.Add_Output(TConsole_Log_Output.Create);
end;

The logger will create daily log files named MyApp_YYYYMMDD.log in the specified directory. If the path is empty, it defaults to a 'logs' folder next to your executable. The directory is created automatically if it doesn't exist.

How to Use

Once configured, you can log from anywhere in your application:

// Simple message with timestamp
TLogger.Write('Application started');

// Message with class and method context
TLogger.Write('Processing order #12345', 'TOrderProcessor', 'ProcessOrder');

// Message without timestamp - Include_TimeStamp is a class property,
// so this affects every subsequent Write until you turn it back on
TLogger.Include_TimeStamp := False;
TLogger.Write('Raw message');
TLogger.Include_TimeStamp := True;

// Log a value against a label - overloads for string, boolean, integer
TLogger.Write('Order Total', 42);
TLogger.Write('Order Valid', True);

// Precise timing (includes milliseconds)
TLogger.Write_Precise('Query executed in 123ms');

// Exception handling
try
  // your code
except
  on E: Exception do
    TLogger.Write(E, 'TOrderProcessor', 'ProcessOrder');
end;

// Add visual separator
TLogger.Write_Error;  // Adds error separator line
TLogger.Write_New_Line;  // Adds blank line

GUI Integration - TMemo Output

You can also log directly to a TMemo on your form for real-time display:

uses
  PBS.LIB.Log.Memo;

procedure TMainForm.FormCreate(Sender: TObject);
begin
  // Add memo output alongside file logging
  TLogger.Add_Output(TMemo_Log_Output.Create(Memo_Log));
end;

All log messages will now appear in both the file and the memo simultaneously.

Sample Log Output

Here's what your log file will look like:

14:23:45  Application started
14:23:45  TOrderProcessor: ProcessOrder: Processing order #12345
14:23:46.123  Query executed in 123ms
14:23:47  Error ------------------------------------
14:23:47  TOrderProcessor: ProcessOrder: Access violation at address 004A2B10

14:23:50  Shutdown complete

Technical Details

File Management

The file logger automatically handles file operations:

Creates new daily log file: Prefix_YYYYMMDD.log
Opens file on first write, appends if file exists
Flushes after each write to ensure data is saved
Auto-closes after 5 seconds of inactivity (configurable via Close_After_Secs property)
Validates path on creation - creates directory and tests write permissions
Prunes old log files automatically, keeping the most recent Files_To_Keep (defaults to 15) - hook On_Error if you want to know when pruning fails

Thread Safety

All logger operations use critical sections for thread safety. Multiple threads can safely call TLogger.Write simultaneously. The file logger has additional locking for file operations.

Architecture

The logger uses a singleton pattern with pluggable outputs:

TLogger - Main singleton class, manages outputs
TLog_Output - Abstract base class for outputs; override Allow_Duplicates if more than one instance of your output type is valid
TFile_Log_Output - Logs to daily rotating files, prunes old ones via PBS.LIB.Prune_Files, uses PBS.LIB.CmdLine for the default exe-relative log path
TConsole_Log_Output - Logs to console (WriteLn)
TMemo_Log_Output - Logs to TMemo control

You can create custom outputs by inheriting from TLog_Output and implementing the Write_Line method.

Requirements

Delphi XE7 or later (uses generics)
VCL for TMemo output (optional - not needed for file/console logging)
No external dependencies - the download includes the two small helper units (PBS.LIB.CmdLine, PBS.LIB.Prune_Files) and the shared PBS.LIB.Common unit that the file output now uses internally

Advanced Usage

Multiple File Outputs

You can log to multiple files simultaneously:

var
  LMain_Path, LError_Path : string;
begin
  LMain_Path := 'C:\Logs\Main\';
  LError_Path := 'C:\Logs\Errors\';
  
  TLogger.Add_Output(TFile_Log_Output.Create(LMain_Path, 'App'));
  TLogger.Add_Output(TFile_Log_Output.Create(LError_Path, 'Errors'));
end;

Custom Output Target

Create your own output by inheriting from TLog_Output:

type
  TDatabase_Log_Output = class(TLog_Output)
  public
    procedure Write_Line(const AMessage: string); override;
  end;

procedure TDatabase_Log_Output.Write_Line(const AMessage: string);
begin
  // Insert into database table
  MyDB.Execute('INSERT INTO logs (message) VALUES (?)', [AMessage]);
end;

Clearing Outputs

You can remove all outputs if needed:

TLogger.Clear_Outputs;  // Frees all output objects

Download Source Code

PBS Delphi Logger - Multiple Output Targets

Back to Articles for Developers
Back to Articles on Delphi
Input Sanitization and Validation for Delphi
Convert Left Click to Right Click in TMS WebCore
Delegating an Interface to a Property in Delphi (implements)

If you found this useful, then please consider making a donation.

Please donate if helpful