AppenderFile Class Reference

#include "AppenderFile.h"

Inheritance diagram for AppenderFile:

Public Member Functions
	AppenderFile (uint8 id, std::string const &name, LogLevel level, AppenderFlags flags, std::vector< std::string_view > const &args)
	~AppenderFile ()
FILE *	OpenFile (std::string const &name, std::string const &mode, bool backup)
AppenderType	getType () const override
Public Member Functions inherited from Appender
	Appender (uint8 _id, std::string const &name, LogLevel level=LOG_LEVEL_DISABLED, AppenderFlags flags=APPENDER_FLAGS_NONE)
virtual	~Appender ()
uint8	getId () const
std::string const &	getName () const
virtual AppenderType	getType () const =0
LogLevel	getLogLevel () const
AppenderFlags	getFlags () const
void	setLogLevel (LogLevel)
void	write (LogMessage *message)
virtual void	setRealmId (uint32)

Static Public Attributes
static constexpr AppenderType	type = APPENDER_FILE

Private Member Functions
void	CloseFile ()
void	_write (LogMessage const *message) override

Private Attributes
FILE *	logfile
std::string	_fileName
std::string	_logDir
bool	_dynamicName
bool	_backup
uint64	_maxFileSize
std::atomic< uint64 >	_fileSize

Additional Inherited Members
Static Public Member Functions inherited from Appender
static char const *	getLogLevelString (LogLevel level)

Detailed Description

Constructor & Destructor Documentation

AppenderFile()

AppenderFile::AppenderFile	(	uint8	id,
		std::string const &	name,
		LogLevel	level,
		AppenderFlags	flags,
		std::vector< std::string_view > const &	args
	)

                                                                                                                                      :
    Appender(id, name, level, flags),
    logfile(nullptr),
    _logDir(sLog->GetLogsDir()),
    _maxFileSize(0),
    _fileSize(0)
{
    if (args.size() < 4)
    {
        throw InvalidAppenderArgsException(Acore::StringFormat("Log::CreateAppenderFromConfig: Missing file name for appender {}", name));
    }
 
    _fileName.assign(args[3]);
 
    std::string mode = "a";
    if (4 < args.size())
    {
        mode.assign(args[4]);
    }
 
    if (flags & APPENDER_FLAGS_USE_TIMESTAMP)
    {
        std::size_t dot_pos = _fileName.find_last_of('.');
        if (dot_pos != std::string::npos)
        {
            _fileName.insert(dot_pos, sLog->GetLogsTimestamp());
        }
        else
        {
            _fileName += sLog->GetLogsTimestamp();
        }
    }
 
    if (5 < args.size())
    {
        if (Optional<uint32> size = Acore::StringTo<uint32>(args[5]))
        {
            _maxFileSize = *size;
        }
        else
        {
            throw InvalidAppenderArgsException(Acore::StringFormat("Log::CreateAppenderFromConfig: Invalid size '{}' for appender {}", args[5], name));
        }
    }
 
    _dynamicName = std::string::npos != _fileName.find("%s");
    _backup = (flags & APPENDER_FLAGS_MAKE_FILE_BACKUP) != 0;
 
    if (!_dynamicName)
    {
        logfile = OpenFile(_fileName, mode, (mode == "w") && _backup);
    }
}

References _backup, _dynamicName, _fileName, _maxFileSize, APPENDER_FLAGS_MAKE_FILE_BACKUP, APPENDER_FLAGS_USE_TIMESTAMP, Appender::flags, logfile, Appender::name, OpenFile(), sLog, and Acore::StringFormat().

~AppenderFile()

AppenderFile::~AppenderFile

(

)

{
    CloseFile();
}

References CloseFile().

Member Function Documentation

_write()

void AppenderFile::_write ( LogMessage const *  message )

overrideprivatevirtual

Implements Appender.

{
    bool exceedMaxSize = _maxFileSize > 0 && (_fileSize.load() + message->Size()) > _maxFileSize;
 
    if (_dynamicName)
    {
        char namebuf[ACORE_PATH_MAX];
        snprintf(namebuf, ACORE_PATH_MAX, _fileName.c_str(), message->param1.c_str());
 
        // always use "a" with dynamic name otherwise it could delete the log we wrote in last _write() call
        FILE* file = OpenFile(namebuf, "a", _backup || exceedMaxSize);
        if (!file)
        {
            return;
        }
 
        fprintf(file, "%s%s\n", message->prefix.c_str(), message->text.c_str());
        fflush(file);
        _fileSize += uint64(message->Size());
        fclose(file);
 
        return;
    }
    else if (exceedMaxSize)
    {
        logfile = OpenFile(_fileName, "w", true);
    }
 
    if (!logfile)
    {
        return;
    }
 
    fprintf(logfile, "%s%s\n", message->prefix.c_str(), message->text.c_str());
    fflush(logfile);
    _fileSize += uint64(message->Size());
}

References _backup, _dynamicName, _fileName, _fileSize, _maxFileSize, ACORE_PATH_MAX, logfile, OpenFile(), LogMessage::param1, LogMessage::prefix, LogMessage::Size(), and LogMessage::text.

CloseFile()

void AppenderFile::CloseFile ( )

private

{
    if (logfile)
    {
        fclose(logfile);
        logfile = nullptr;
    }
}

References logfile.

Referenced by OpenFile(), and ~AppenderFile().

getType()

AppenderType AppenderFile::getType ( ) const

inlineoverridevirtual

Implements Appender.

{ return type; }

References type.

OpenFile()

FILE * AppenderFile::OpenFile	(	std::string const &	name,
		std::string const &	mode,
		bool	backup
	)

{
    std::string fullName(_logDir + filename);
    if (backup)
    {
        CloseFile();
        std::string newName(fullName);
        newName.push_back('.');
        newName.append(LogMessage::getTimeStr(GetEpochTime()));
        std::replace(newName.begin(), newName.end(), ':', '-');
        rename(fullName.c_str(), newName.c_str()); // no error handling... if we couldn't make a backup, just ignore
    }
 
    if (FILE* ret = fopen(fullName.c_str(), mode.c_str()))
    {
        _fileSize = ftell(ret);
        return ret;
    }
 
    return nullptr;
}

References _fileSize, _logDir, CloseFile(), GetEpochTime(), and LogMessage::getTimeStr().

Referenced by _write(), and AppenderFile().

Member Data Documentation

_backup

bool AppenderFile::_backup

private

Referenced by _write(), and AppenderFile().

_dynamicName

bool AppenderFile::_dynamicName

private

Referenced by _write(), and AppenderFile().

_fileName

std::string AppenderFile::_fileName

private

Referenced by _write(), and AppenderFile().

_fileSize

std::atomic<uint64> AppenderFile::_fileSize

private

Referenced by _write(), and OpenFile().

_logDir

std::string AppenderFile::_logDir

private

Referenced by OpenFile().

_maxFileSize

uint64 AppenderFile::_maxFileSize

private

Referenced by _write(), and AppenderFile().

logfile

FILE* AppenderFile::logfile

private

Referenced by _write(), AppenderFile(), and CloseFile().

type

constexpr AppenderType AppenderFile::type = APPENDER_FILE

staticconstexpr

Referenced by getType().