LoggerPro.FileAppender.pas

// *************************************************************************** }
//
// LoggerPro
//
// Copyright (c) 2010-2026 Daniele Teti
//
// https://github.com/danieleteti/loggerpro
//
// ***************************************************************************
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// ***************************************************************************

unit LoggerPro.FileAppender;

{$IF Defined(Android) or Defined(iOS)}
{$DEFINE MOBILE}
{$ENDIF}

interface

uses
  LoggerPro,
  System.Generics.Collections,
  System.Classes,
  System.SysUtils;

type
  {
    @abstract(Logs to file using one different file for each different TAG used.)
    @author(Daniele Teti - d.teti@bittime.it)
    Implements log rotations.
    This appender is the default appender when no configuration is done on the @link(TLogger) class.

    Without any configuration LoggerPro uses the @link(TLoggerProFileAppender) with the default configuration.

    So the following two blocks of code are equivalent:

    @longcode(#
    ...
    TLogger.Initialize; //=> uses the TLoggerProFileAppender because no other configuration is provided
    ...

    ...
    TLogger.AddAppender(TLoggerProFileAppender.Create);
    TLogger.Initialize //=> uses the TLoggerProFileAppender as configured
    ...
    #)

  }

  { @abstract(The base class for different file appenders)
    Do not use this class directly, but one of TLoggerProFileAppender or TLoggerProSimpleFileAppender.
    Check the sample @code(file_appender.dproj)
  }
  TLoggerProFileAppenderBase = class(TLoggerProAppenderBase)
  protected
    fEncoding: TEncoding;
    fMaxBackupFileCount: Integer;
    fMaxFileSizeInKiloByte: Integer;
    fLogFileNameFormat: string;
    fLogsFolder: string;
    fRotationInterval: TTimeRotationInterval;
    fCurrentTimestamp: string;
    fMaxRetainedFiles: Integer;
    fOnAfterRotate: TFileRotateCallback;
    procedure RetryMove(const aFileSrc, aFileDest: string);
    procedure RetryDelete(const aFileSrc: string);
    function CreateWriter(const aFileName: string; const aBufferSize: Integer = 32): TStreamWriter;
    procedure CheckLogFileNameFormat(const LogFileNameFormat: String); virtual;
    procedure EmitStartRotateLogItem(aWriter: TStreamWriter); virtual;
    procedure EmitEndRotateLogItem(aWriter: TStreamWriter); virtual;
    function GetLogFileName(const aTag: string; const aFileNumber: Integer): string; virtual;
    function GetTimestampForInterval(aDateTime: TDateTime): string;
    procedure CleanupOldTimeRotatedFiles(const aTag: string);
    procedure WriteToStream(const aStreamWriter: TStreamWriter; const aValue: string); inline;
    procedure RotateFile(const aLogTag: string; out aNewFileName: string); virtual;
    procedure InternalWriteLog(const aStreamWriter: TStreamWriter; const aLogItem: TLogItem);
  public const
    { @abstract(Defines the default format string used by the @link(TLoggerProFileAppender).)
      The positional parameters are the following:
      @orderedList(
      @item Number
      @item Module
      @item Tag
      )
    }
    DEFAULT_FILENAME_FORMAT = '{module}.{number}.{tag}.log';
    DEFAULT_FILENAME_FORMAT_WITH_PID = '{module}.{number}.{pid}.{tag}.log';
    DEFAULT_FILENAME_FORMAT_WITHOUT_TAG = '{module}.{number}.log';
    { @abstract(Defines number of log file set to maintain during logs rotation) }
    DEFAULT_MAX_BACKUP_FILE_COUNT = 5;
    { @abstract(Defines the max size of each log file)
      The actual meaning is: "If the file size is > than @link(DEFAULT_MAX_FILE_SIZE_KB) then rotate logs. }
    DEFAULT_MAX_FILE_SIZE_KB = 1000;
    { @abstract(Milliseconds to wait between the RETRY_COUNT times. }
    RETRY_DELAY = 200;
    { @abstract(How many times do we have to retry if the file is locked?. }
    RETRY_COUNT = 5;
    constructor Create(
      aMaxBackupFileCount: Integer = TLoggerProFileAppenderBase.DEFAULT_MAX_BACKUP_FILE_COUNT;
      aMaxFileSizeInKiloByte: Integer = TLoggerProFileAppenderBase.DEFAULT_MAX_FILE_SIZE_KB;
      aLogsFolder: string = '';
      aLogFileNameFormat: string = TLoggerProFileAppenderBase.DEFAULT_FILENAME_FORMAT;
      aLogItemRenderer: ILogItemRenderer = nil;
      aEncoding: TEncoding = nil;
      aRotationInterval: TTimeRotationInterval = TTimeRotationInterval.None;
      aMaxRetainedFiles: Integer = 0);
      reintroduce; virtual;
    procedure Setup; override;
    { @abstract(Callback invoked after a log file is rotated.)
      Runs on the logger thread - do not block. }
    property OnAfterRotate: TFileRotateCallback read fOnAfterRotate write fOnAfterRotate;
  end;

  { @abstract(The default file appender)
    This file appender separates TLogItems with different tags into a log file for each tag.
    To learn how to use this appender, check the sample @code(file_appender.dproj)
  }
  TLoggerProFileAppender = class(TLoggerProFileAppenderBase)
  private
    fWritersDictionary: TObjectDictionary<string, TStreamWriter>;
    fFileNamesDictionary: TDictionary<string, string>;
    procedure AddWriter(const aLogTag: string; var aWriter: TStreamWriter; var aLogFileName: string);
    procedure RotateLog(const aLogTag: string; aWriter: TStreamWriter);
  public
    procedure Setup; override;
    procedure TearDown; override;
    procedure WriteLog(const aLogItem: TLogItem); overload; override;
    { Returns the current log file name for the given tag, or '' if no log
      has yet been written under that tag. The file may not exist on disk
      until the first WriteLog for that tag. }
    function GetCurrentLogFileName(const aLogTag: string): string;
    { Returns every log file name currently being written to (one per tag
      encountered so far). Useful for uploading / rotating / emailing the
      complete set. }
    function GetAllCurrentLogFileNames: TArray<string>;
    { Scan aLog's appenders and return the first TLoggerProFileAppender
      found, or nil. Handy when the Builder's WriteToFile created the
      appender internally and the caller needs access to the file-name
      helpers above. }
    class function FromLog(const aLog: ICustomLogWriter): TLoggerProFileAppender; static;
  end;

  { @abstract(File appender with multiple tags)
    This file appender writes all TLogItems into a single log file.
    Combined with a @code(TLoggerProAppenderFilterImpl) you can filter out any log tags you like.
    If you want to run several TLoggerProSimpleFileAppender in parallel you have to provide a different
    LogFileFormat for each of them in the constructor in order to prevent name collisions.
    To learn how to use this appender, check the sample @code(file_appender.dproj)
  }
  TLoggerProSimpleFileAppender = class(TLoggerProFileAppenderBase)
  private
    fCurrentLogFileName: string;
    procedure RotateLog;
  protected
    { Exposed to descendants so structured-output appenders (HTML, XML, ...)
      can write custom open/close markers in Setup / TearDown / EmitStart /
      EmitEnd overrides. Still not meant for external access. }
    fFileWriter: TStreamWriter;
    procedure CheckLogFileNameFormat(const LogFileNameFormat: String); override;
  public
  const
    DEFAULT_FILENAME_FORMAT = '{module}.{number}.log';
    procedure Setup; override;
    procedure TearDown; override;
    procedure WriteLog(const aLogItem: TLogItem); overload; override;
    function GetCurrentLogFileName: string;
    constructor Create(
      aMaxBackupFileCount: Integer = TLoggerProFileAppenderBase.DEFAULT_MAX_BACKUP_FILE_COUNT;
      aMaxFileSizeInKiloByte: Integer = TLoggerProFileAppenderBase.DEFAULT_MAX_FILE_SIZE_KB;
      aLogsFolder: string = '';
      aLogFileNameFormat: string = TLoggerProSimpleFileAppender.DEFAULT_FILENAME_FORMAT;
      aLogItemRenderer: ILogItemRenderer = nil;
      aEncoding: TEncoding = nil;
      aRotationInterval: TTimeRotationInterval = TTimeRotationInterval.None;
      aMaxRetainedFiles: Integer = 0);
      override;
  end;


  TMakeFileNameProc = reference to procedure(out AFileName: string);

  { by an idea of Mark Lobanov <mark.v.lobanov@gmail.com> }
  TLoggerProFileByFolderAppender = class(TLoggerProSimpleFileAppender)
  private
    fCurrentDate: TDateTime;
    function GetLogFolder: string;
    function GetFileFormat: string;
    procedure RotateLog;
    procedure ChangeLogFolder;
    procedure RefreshCurrentDate;
    procedure InternalRotateLog(aMakeFileNameProc: TMakeFileNameProc);
  protected
    function GetLogFileName(const aTag: string; const aFileNumber: Integer): string; override;
    procedure CheckLogFileNameFormat(const aLogFileNameFormat: string); override;
  public
    constructor Create(
      aMaxBackupFileCount: Integer = TLoggerProFileAppenderBase.DEFAULT_MAX_BACKUP_FILE_COUNT;
      aMaxFileSizeInKiloByte: Integer = TLoggerProFileAppenderBase.DEFAULT_MAX_FILE_SIZE_KB;
      const aLogsFolder: string = '';
      const aLogItemRenderer: ILogItemRenderer = nil;
      const aEncoding: TEncoding = nil); reintroduce;

    procedure WriteLog(const ALogItem: TLogItem); override;
    procedure Setup; override;
    procedure TearDown; override;
  end;

  TLoggerProLogFmtFileAppender = class(TLoggerProSimpleFileAppender)
  protected
    function GetLogFileName(const aTag: string; const aFileNumber: Integer): string; override;
    procedure EmitStartRotateLogItem(aWriter: TStreamWriter); override;
    procedure EmitEndRotateLogItem(aWriter: TStreamWriter); override;
  public
    constructor Create(aMaxBackupFileCount: Integer = TLoggerProFileAppender.DEFAULT_MAX_BACKUP_FILE_COUNT;
      aMaxFileSizeInKiloByte: Integer = TLoggerProFileAppender.DEFAULT_MAX_FILE_SIZE_KB; aLogsFolder: string = '';
      aLogFileNameFormat: string = TLoggerProSimpleFileAppender.DEFAULT_FILENAME_FORMAT; aEncoding: TEncoding = nil);
      reintroduce;
  end;

// Returns the size of an existing file in bytes. TFile.GetSize requires
// Delphi 11 Alexandria (CompilerVersion 35); on older compilers (e.g.
// 10.2.3 Tokyo) it falls back to a TFileStream-based size read.
function GetFileSizeCompat(const aFileName: string): Int64;

implementation

uses
  System.Types,
  System.IOUtils,
  System.StrUtils,
  System.Math,
  System.DateUtils,
  LoggerPro.Renderers,
  idGlobal
{$IF Defined(Android)}
    ,Androidapi.Helpers
    ,Androidapi.JNI.GraphicsContentViewText
    ,Androidapi.JNI.JavaTypes
{$ENDIF}
    ;


function GetFileSizeCompat(const aFileName: string): Int64;
{$IF CompilerVersion >= 35}
begin
  Result := TFile.GetSize(aFileName);
end;
{$ELSE}
var
  lStream: TFileStream;
begin
  lStream := TFileStream.Create(aFileName, fmOpenRead or fmShareDenyNone);
  try
    Result := lStream.Size;
  finally
    lStream.Free;
  end;
end;
{$ENDIF}

function OccurrencesOfChar(const S: string; const C: char): integer;
var
  i: Integer;
begin
  result := 0;
  for i := 1 to Length(S) do
    if S[i] = C then
      inc(result);
end;

procedure TLoggerProFileAppenderBase.CheckLogFileNameFormat(const LogFileNameFormat: String);
begin
  //DEFAULT_FILENAME_FORMAT = '{module}.{number}.{tag}.log';
  // When time rotation is active, {number} is optional (time-only rotation doesn't need it)
  if fRotationInterval <> TTimeRotationInterval.None then
  begin
    if not LogFileNameFormat.Contains('{tag}') then
      raise ELoggerPro.CreateFmt('Wrong FileFormat [%s] - [HINT] A correct file format for %s requires {tag} placeholder. A valid file format is : %s',
        [
          ClassName,
          LogFileNameFormat,
          '{module}.{date}.{tag}.log'
        ]);
  end
  else
  begin
    if not (LogFileNameFormat.Contains('{number}') and LogFileNameFormat.Contains('{tag}')) then
    begin
      raise ELoggerPro.CreateFmt('Wrong FileFormat [%s] - [HINT] A correct file format for %s requires {number} and {tag} placeholders ({module} is optional). A valid file format is : %s',
        [
          ClassName,
          LogFileNameFormat,
          TLoggerProFileAppenderBase.DEFAULT_FILENAME_FORMAT
        ]);
    end;
  end;
end;


{ TLoggerProFileAppenderBase }

function TLoggerProFileAppenderBase.GetLogFileName(const aTag: string; const aFileNumber: Integer): string;
var
  lModuleName: string;
  lPath: string;
  lFormat: string;
  lDir: string;
begin
{$IF Defined(Android)}
  lModuleName := TAndroidHelper.ApplicationTitle.Replace(' ', '_', [rfReplaceAll]);
{$ENDIF}
{$IF not Defined(Mobile)}
  lModuleName := TPath.GetFileNameWithoutExtension(GetModuleName(HInstance));
{$ENDIF}
{$IF Defined(IOS)}
  raise Exception.Create('Platform not supported');
{$ENDIF}
  lFormat := fLogFileNameFormat;

  lPath := fLogsFolder;
  lFormat := lFormat
    .Replace('{module}', lModuleName, [rfReplaceAll])
    .Replace('{number}', aFileNumber.ToString.PadLeft(
      Max(2,fMaxBackupFileCount.ToString.Length), //min padding 2
      '0') , [rfReplaceAll])
    .Replace('{tag}', aTag, [rfReplaceAll])
    .Replace('{pid}', CurrentProcessId.ToString.PadLeft(8,'0'), [rfReplaceAll])
    .Replace('{date}', fCurrentTimestamp, [rfReplaceAll]);
  Result := TPath.Combine(lPath, lFormat);

  // Ensure directory exists (needed when format contains subdirectories like {tag}/ or {date}/)
  lDir := TPath.GetDirectoryName(Result);
  if (lDir <> '') and (not TDirectory.Exists(lDir)) then
    TDirectory.CreateDirectory(lDir);
end;

procedure TLoggerProFileAppenderBase.Setup;
begin
  inherited;

  if fLogsFolder = '' then
  begin
{$IF (Defined(MSWINDOWS) or Defined(POSIX)) and (not Defined(MOBILE))}
    fLogsFolder := TPath.GetDirectoryName(GetModuleName(HInstance));
{$ENDIF}
{$IF Defined(Android) or Defined(IOS)}
    fLogsFolder := TPath.GetSharedDocumentsPath();
{$ENDIF}
  end;
  if not TDirectory.Exists(fLogsFolder) then
    TDirectory.CreateDirectory(fLogsFolder);
end;

procedure TLoggerProFileAppenderBase.WriteToStream(const aStreamWriter: TStreamWriter; const aValue: string);
begin
  aStreamWriter.WriteLine(aValue);
  aStreamWriter.Flush;
end;

procedure TLoggerProFileAppenderBase.InternalWriteLog(const aStreamWriter: TStreamWriter; const aLogItem: TLogItem);
begin
  WriteToStream(aStreamWriter, FormatLog(aLogItem));
end;

procedure TLoggerProFileAppenderBase.RetryDelete(const aFileSrc: string);
var
  lRetries: Integer;
const
  MAX_RETRIES = 5;
begin
  lRetries := 0;
  repeat
    try
      Sleep(50);
      // the incidence of "Locked file goes to nearly zero..."
      TFile.Delete(aFileSrc);
      if not TFile.Exists(aFileSrc) then
      begin
        Break;
      end;
    except
      on E: Exception do
      begin
        Inc(lRetries);
        Sleep(100);
      end;
    end;
  until lRetries = MAX_RETRIES;

  if lRetries = MAX_RETRIES then
    raise ELoggerPro.CreateFmt('Cannot delete file %s', [aFileSrc]);
end;

procedure TLoggerProFileAppenderBase.RetryMove(const aFileSrc, aFileDest: string);
var
  lRetries: Integer;
const
  MAX_RETRIES = 5;
begin
  lRetries := 0;
  repeat
    try
      Sleep(50);
      // the incidence of "Locked file goes to nearly zero..."
      TFile.Move(aFileSrc, aFileDest);
      Break;
    except
      on E: EInOutError do
      begin
        Inc(lRetries);
        Sleep(100);
      end;
      on E: Exception do
      begin
        raise;
      end;
    end;
  until lRetries = MAX_RETRIES;

  if lRetries = MAX_RETRIES then
    raise ELoggerPro.CreateFmt('Cannot rename %s to %s', [aFileSrc, aFileDest]);
end;

procedure TLoggerProFileAppenderBase.RotateFile(const aLogTag: string; out aNewFileName: string);
var
  lRenamedFile: string;
  I: Integer;
  lCurrentFileName: string;
begin
  aNewFileName := GetLogFileName(aLogTag, 0);
  // remove the last file of backup set
  lRenamedFile := GetLogFileName(aLogTag, fMaxBackupFileCount - 1);
  if TFile.Exists(lRenamedFile) then
  begin
    TFile.Delete(lRenamedFile);
    if TFile.Exists(lRenamedFile) then // double check for slow file systems
    begin
      RetryDelete(lRenamedFile);
    end;
  end;
  // shift the files names
  for I := fMaxBackupFileCount - 1 downto 1 do
  begin
    lCurrentFileName := GetLogFileName(aLogTag, I);
    lRenamedFile := GetLogFileName(aLogTag, I + 1);
    if TFile.Exists(lCurrentFileName) then
    begin
      RetryMove(lCurrentFileName, lRenamedFile);
    end;
  end;
  lRenamedFile := GetLogFileName(aLogTag, 1);
  RetryMove(aNewFileName, lRenamedFile);
end;

function TLoggerProFileAppenderBase.GetTimestampForInterval(aDateTime: TDateTime): string;
var
  lYear, lMonth, lDay, lHour, lWeek: Word;
begin
  DecodeDate(aDateTime, lYear, lMonth, lDay);
  lHour := HourOf(aDateTime);

  case fRotationInterval of
    TTimeRotationInterval.Hourly:
      Result := Format('%.4d%.2d%.2d%.2d', [lYear, lMonth, lDay, lHour]);

    TTimeRotationInterval.Daily:
      Result := Format('%.4d%.2d%.2d', [lYear, lMonth, lDay]);

    TTimeRotationInterval.Weekly:
      begin
        lWeek := WeekOfTheYear(aDateTime);
        Result := Format('%.4dW%.2d', [lYear, lWeek]);
      end;

    TTimeRotationInterval.Monthly:
      Result := Format('%.4d%.2d', [lYear, lMonth]);
  else
    Result := '';
  end;
end;

procedure TLoggerProFileAppenderBase.CleanupOldTimeRotatedFiles(const aTag: string);
var
  lFiles: TStringDynArray;
  lPattern: string;
  lModuleName: string;
  I, J: Integer;
  lTemp: string;
begin
  if fMaxRetainedFiles <= 0 then
    Exit;

{$IF not Defined(Mobile)}
  lModuleName := TPath.GetFileNameWithoutExtension(GetModuleName(HInstance));
{$ELSE}
  lModuleName := 'app';
{$ENDIF}

  lPattern := lModuleName + '.*.' + aTag + '.log';
  lFiles := TDirectory.GetFiles(fLogsFolder, lPattern);

  // Simple sort (timestamps in filenames ensure chronological order)
  for I := 0 to Length(lFiles) - 2 do
    for J := I + 1 to Length(lFiles) - 1 do
      if lFiles[I] > lFiles[J] then
      begin
        lTemp := lFiles[I];
        lFiles[I] := lFiles[J];
        lFiles[J] := lTemp;
      end;

  for I := 0 to Length(lFiles) - fMaxRetainedFiles - 1 do
  begin
    try
      TFile.Delete(lFiles[I]);
    except
      // Ignore deletion errors (file might be locked)
    end;
  end;
end;

constructor TLoggerProFileAppenderBase.Create(
  aMaxBackupFileCount: Integer;
  aMaxFileSizeInKiloByte: Integer;
  aLogsFolder: string;
  aLogFileNameFormat: string;
  aLogItemRenderer: ILogItemRenderer;
  aEncoding: TEncoding;
  aRotationInterval: TTimeRotationInterval;
  aMaxRetainedFiles: Integer);
begin
  inherited Create(aLogItemRenderer);
  fLogsFolder := aLogsFolder;
  fMaxBackupFileCount:= Max(1, aMaxBackupFileCount);
  fMaxFileSizeInKiloByte := aMaxFileSizeInKiloByte;
  fRotationInterval := aRotationInterval;
  fMaxRetainedFiles := aMaxRetainedFiles;
  CheckLogFileNameFormat(aLogFileNameFormat);
  fLogFileNameFormat := aLogFileNameFormat;
  if Assigned(aEncoding) then
    fEncoding := aEncoding
  else
    fEncoding := TEncoding.DEFAULT;
end;

function TLoggerProFileAppenderBase.CreateWriter(const aFileName: string; const aBufferSize: Integer = 32): TStreamWriter;
var
  lFileStream: TFileStream;
  lFileAccessMode: Word;
  lRetries: Integer;
begin
  lFileAccessMode := fmOpenWrite or fmShareDenyNone;
  if not TFile.Exists(aFileName) then
    lFileAccessMode := lFileAccessMode or fmCreate;

  // If the file si still blocked by a precedent execution or
  // for some other reasons, we try to access the file for 5 times.
  // If after 5 times (with a bit of delay in between) the file is still
  // locked, then the exception is raised.
  lRetries := 0;
  while true do
  begin
    try
      lFileStream := TFileStream.Create(aFileName, lFileAccessMode);
      try
        lFileStream.Seek(0, TSeekOrigin.soEnd);
        Result := TStreamWriter.Create(lFileStream, fEncoding, aBufferSize);
        Result.AutoFlush := true;
        Result.OwnStream;
        Break;
      except
        lFileStream.Free;
        raise;
      end;
    except
      if lRetries = RETRY_COUNT then
      begin
        raise;
      end
      else
      begin
        Inc(lRetries);
        Sleep(RETRY_DELAY); // just wait a little bit
      end;
    end;
  end;
end;

{ TLoggerProFileAppender }

procedure TLoggerProFileAppender.AddWriter(const aLogTag:string; var aWriter: TStreamWriter; var aLogFileName: string);
begin
  aLogFileName := GetLogFileName(aLogTag, 0);
  aWriter := CreateWriter(aLogFileName);
  fWritersDictionary.Add(aLogTag, aWriter);
  fFileNamesDictionary.AddOrSetValue(aLogTag, aLogFileName);
end;

procedure TLoggerProFileAppenderBase.EmitEndRotateLogItem(aWriter: TStreamWriter);
begin
  WriteToStream(aWriter, '#[ROTATE LOG ' + datetimetostr(Now, FormatSettings) + ']');
end;

procedure TLoggerProFileAppenderBase.EmitStartRotateLogItem(aWriter: TStreamWriter);
begin
  WriteToStream(aWriter, '#[START LOG ' + datetimetostr(Now, FormatSettings) + ']');
end;

procedure TLoggerProFileAppender.RotateLog(const aLogTag: string; aWriter: TStreamWriter);
var
  lLogFileName: string;
begin
  EmitEndRotateLogItem(aWriter);
  // remove the writer during rename
  fWritersDictionary.Remove(aLogTag);
  RotateFile(aLogTag, lLogFileName);
  if Assigned(fOnAfterRotate) then
    fOnAfterRotate(GetLogFileName(aLogTag, 1));
  // re-create the writer
  AddWriter(aLogTag, aWriter, lLogFileName);
  EmitStartRotateLogItem(aWriter);
end;

procedure TLoggerProFileAppender.Setup;
begin
  inherited;
  fWritersDictionary := TObjectDictionary<string, TStreamWriter>.Create([doOwnsValues]);
  fFileNamesDictionary := TDictionary<string, string>.Create;
  if fRotationInterval <> TTimeRotationInterval.None then
    fCurrentTimestamp := GetTimestampForInterval(Now);
end;

procedure TLoggerProFileAppender.TearDown;
var
  lWriter: TStreamWriter;
begin
  for lWriter in fWritersDictionary.Values do
  begin
    lWriter.Flush;
  end;
  fWritersDictionary.Free;
  fFileNamesDictionary.Free;
  inherited;
end;

procedure TLoggerProFileAppender.WriteLog(const aLogItem: TLogItem);
var
  lWriter: TStreamWriter;
  lLogFileName: string;
  lNewTimestamp: string;
begin
  // Check time-based rotation
  if fRotationInterval <> TTimeRotationInterval.None then
  begin
    lNewTimestamp := GetTimestampForInterval(aLogItem.TimeStamp);
    if lNewTimestamp <> fCurrentTimestamp then
    begin
      // Fire callback for each file being rotated
      if Assigned(fOnAfterRotate) then
        for lLogFileName in fFileNamesDictionary.Values do
          fOnAfterRotate(lLogFileName);
      // Close all writers (interval changed)
      fWritersDictionary.Clear; // doOwnsValues frees the writers
      fFileNamesDictionary.Clear;
      fCurrentTimestamp := lNewTimestamp;
    end;
  end;

  if not fWritersDictionary.TryGetValue(aLogItem.LogTag, lWriter) then
  begin
    AddWriter(aLogItem.LogTag, lWriter, lLogFileName);
  end;

  InternalWriteLog(lWriter, aLogItem);

  // Size-based rotation (only when MaxFileSizeInKB > 0)
  if (fMaxFileSizeInKiloByte > 0) and
     (lWriter.BaseStream.Size > fMaxFileSizeInKiloByte * 1024) then
  begin
    RotateLog(aLogItem.LogTag, lWriter);
  end;
end;

function TLoggerProFileAppender.GetCurrentLogFileName(const aLogTag: string): string;
begin
  if not fFileNamesDictionary.TryGetValue(aLogTag, Result) then
    Result := '';
end;

function TLoggerProFileAppender.GetAllCurrentLogFileNames: TArray<string>;
begin
  Result := fFileNamesDictionary.Values.ToArray;
end;

class function TLoggerProFileAppender.FromLog(const aLog: ICustomLogWriter): TLoggerProFileAppender;
var
  i: Integer;
  lObj: TObject;
begin
  Result := nil;
  if aLog = nil then
    Exit;
  for i := 0 to aLog.AppendersCount - 1 do
  begin
    lObj := aLog.Appenders[i] as TObject;
    if lObj is TLoggerProFileAppender then
      Exit(TLoggerProFileAppender(lObj));
  end;
end;

{ TLoggerProSimpleFileAppender }

procedure TLoggerProSimpleFileAppender.CheckLogFileNameFormat(const LogFileNameFormat: String);
begin
  //DEFAULT_FILENAME_FORMAT = '{module}.{number}.{tag}.log';
  if not LogFileNameFormat.Contains('{number}') then
  begin
    raise ELoggerPro.CreateFmt('Wrong FileFormat [%s] - [HINT] A correct file format for %s requires {number} placeholder ({module} is optional). A valid file format is : %s',
      [
        ClassName,
        LogFileNameFormat,
        TLoggerProSimpleFileAppender.DEFAULT_FILENAME_FORMAT
      ]);
  end;
end;

constructor TLoggerProSimpleFileAppender.Create(aMaxBackupFileCount, aMaxFileSizeInKiloByte: Integer;
  aLogsFolder: string; aLogFileNameFormat: String;
  aLogItemRenderer: ILogItemRenderer;
  aEncoding: TEncoding;
  aRotationInterval: TTimeRotationInterval;
  aMaxRetainedFiles: Integer);
begin
  inherited Create(
    aMaxBackupFileCount,
    aMaxFileSizeInKiloByte,
    aLogsFolder,
    aLogFileNameFormat,
    aLogItemRenderer,
    aEncoding,
    aRotationInterval,
    aMaxRetainedFiles);
end;

procedure TLoggerProSimpleFileAppender.RotateLog;
var
  lLogFileName: string;
begin
  EmitEndRotateLogItem(fFileWriter);
  // remove the writer during rename
  fFileWriter.Free;
  RotateFile('', lLogFileName);
  if Assigned(fOnAfterRotate) then
    fOnAfterRotate(GetLogFileName('', 1));
  // re-create the writer
  fCurrentLogFileName := GetLogFileName('', 0);
  fFileWriter := CreateWriter(fCurrentLogFileName);
  EmitStartRotateLogItem(fFileWriter);
end;

procedure TLoggerProSimpleFileAppender.Setup;
begin
  inherited;
  fCurrentLogFileName := GetLogFileName('', 0);
  fFileWriter := CreateWriter(fCurrentLogFileName);
end;

procedure TLoggerProSimpleFileAppender.TearDown;
begin
  fFileWriter.Flush;
  fFileWriter.Free;
  inherited;
end;

procedure TLoggerProSimpleFileAppender.WriteLog(const aLogItem: TLogItem);
begin
  InternalWriteLog(fFileWriter, aLogItem);
  if fFileWriter.BaseStream.Size > fMaxFileSizeInKiloByte * 1024 then
  begin
    RotateLog;
  end;
end;

function TLoggerProSimpleFileAppender.GetCurrentLogFileName: string;
begin
  Result := fCurrentLogFileName;
end;

{ TLoggerProFileByFolderAppender }

constructor TLoggerProFileByFolderAppender.Create(
  aMaxBackupFileCount, aMaxFileSizeInKiloByte: Integer;
  const aLogsFolder: string;
  const aLogItemRenderer: ILogItemRenderer;
  const aEncoding: TEncoding);
var
  lEncoding: TEncoding;
begin
  if AEncoding = nil then
    LEncoding := TEncoding.UTF8
  else
    LEncoding := AEncoding;

  inherited Create(aMaxBackupFileCount, aMaxFileSizeInKiloByte,
    aLogsFolder, GetFileFormat, aLogItemRenderer, LEncoding);
  RefreshCurrentDate;
end;

procedure TLoggerProFileByFolderAppender.CheckLogFileNameFormat(const ALogFileNameFormat: string);
begin
  //do nothing, user cannot change filename format in this appender
end;

function TLoggerProFileByFolderAppender.GetLogFolder: string;
const
  LOG_DIR = 'Logs';
begin
  if fLogsFolder.IsEmpty then
    fLogsFolder := TPath.Combine(TPath.GetDirectoryName({ParamStr(0)} GetModuleName(HInstance)), LOG_DIR)
  else
  if not EndsText(LOG_DIR, fLogsFolder) then
    fLogsFolder := TPath.Combine(FLogsFolder, LOG_DIR);
  if not TDirectory.Exists(fLogsFolder) then
    TDirectory.CreateDirectory(fLogsFolder);

  Result := TPath.Combine(fLogsFolder, FormatDateTime('yyyymmdd', Now));
  if not TDirectory.Exists(Result) then
    TDirectory.CreateDirectory(Result);
end;


procedure TLoggerProFileByFolderAppender.InternalRotateLog(aMakeFileNameProc: TMakeFileNameProc);
var
  lLogFileName: string;
  lOldFileName: string;
begin
  lOldFileName := fCurrentLogFileName;
  EmitEndRotateLogItem(fFileWriter);
  FreeAndNil(fFileWriter);
  aMakeFileNameProc(lLogFileName);
  fCurrentLogFileName := lLogFileName;
  if Assigned(fOnAfterRotate) and (lOldFileName <> '') then
    fOnAfterRotate(lOldFileName);
  fFileWriter := CreateWriter(lLogFileName, 16 * 1024);
  EmitStartRotateLogItem(fFileWriter);
end;

procedure TLoggerProFileByFolderAppender.ChangeLogFolder;
begin
  InternalRotateLog(
    procedure(out AFileName: string)
    begin
      AFileName := GetLogFileName(EmptyStr, 0);
    end
 );
end;

procedure TLoggerProFileByFolderAppender.RotateLog;
begin
  InternalRotateLog(
    procedure(out AFileName: string)
    begin
      RotateFile(EmptyStr, AFileName);
    end
 );
end;

function TLoggerProFileByFolderAppender.GetFileFormat: string;
begin
  Result := TLoggerProFileAppenderBase.DEFAULT_FILENAME_FORMAT_WITHOUT_TAG;
end;

function TLoggerProFileByFolderAppender.GetLogFileName(const ATag: string; const AFileNumber: Integer): string;
var
  lOnlyFileName: String;
begin
  lOnlyFileName := TPath.GetFileName(inherited);
  Result := TPath.Combine(GetLogFolder, lOnlyFileName);
end;


procedure TLoggerProFileByFolderAppender.RefreshCurrentDate;
begin
  fCurrentDate := Date;
end;

procedure TLoggerProFileByFolderAppender.Setup;
begin
  inherited;
  RefreshCurrentDate;
end;

procedure TLoggerProFileByFolderAppender.TearDown;
begin
  inherited;
end;

procedure TLoggerProFileByFolderAppender.WriteLog(const ALogItem: TLogItem);
begin
  if not SameDate(fCurrentDate, Date) then
  begin
    ChangeLogFolder;
    RefreshCurrentDate;
  end;

  WriteToStream(fFileWriter, FormatLog(ALogItem));

  if fFileWriter.BaseStream.Size > fMaxFileSizeInKiloByte * 1024 then
  begin
    RotateLog;
  end;
end;

{ TLoggerProLogFmtFileAppender }

constructor TLoggerProLogFmtFileAppender.Create(aMaxBackupFileCount, aMaxFileSizeInKiloByte: Integer; aLogsFolder,
  aLogFileNameFormat: string; aEncoding: TEncoding);
begin
  inherited Create(
    aMaxBackupFileCount,
    aMaxFileSizeInKiloByte,
    aLogsFolder,
    aLogFileNameFormat,
    TLogItemRendererLogFmt.Create,
    aEncoding);
end;

procedure TLoggerProLogFmtFileAppender.EmitEndRotateLogItem(aWriter: TStreamWriter);
begin
  // do nothing
end;

procedure TLoggerProLogFmtFileAppender.EmitStartRotateLogItem(aWriter: TStreamWriter);
begin
  // do nothing
end;

function TLoggerProLogFmtFileAppender.GetLogFileName(const aTag: string; const aFileNumber: Integer): string;
var
  lOrigFName, lOrigExt: string;
begin
  lOrigFName := inherited;
  lOrigExt := TPath.GetExtension(lOrigFName);
  if lOrigExt.IsEmpty then
  begin
    lOrigExt := '.log';
  end;
  Result := TPath.ChangeExtension(lOrigFName, '.logfmt' + lOrigExt);
end;

end.