Log Class Reference

#include "Log.h"

Public Member Functions
void	Initialize (Acore::Asio::IoContext *ioContext=nullptr)
void	SetSynchronous ()
void	LoadFromConfig ()
void	Close ()
bool	ShouldLog (std::string const &type, LogLevel level) const
bool	SetLogLevel (std::string const &name, int32 level, bool isLogger=true)
template<typename... Args>
void	outMessage (std::string const &filter, LogLevel const level, Acore::FormatString< Args... > fmt, Args &&... args)
template<typename... Args>
void	outCommand (uint32 account, Acore::FormatString< Args... > fmt, Args &&... args)
void	SetRealmId (uint32 id)
template<class AppenderImpl >
void	RegisterAppender ()
std::string const &	GetLogsDir () const
std::string const &	GetLogsTimestamp () const

Static Public Member Functions
static Log *	instance ()

Private Types
typedef std::unordered_map< std::string, Logger >	LoggerMap

Private Member Functions
	Log ()
	~Log ()
	Log (Log const &)=delete
	Log (Log &&)=delete
Log &	operator= (Log const &)=delete
Log &	operator= (Log &&)=delete
void	write (std::unique_ptr< LogMessage > &&msg) const
Logger const *	GetLoggerByType (std::string const &type) const
Appender *	GetAppenderByName (std::string_view name)
uint8	NextAppenderId ()
void	CreateAppenderFromConfig (std::string const &name)
void	CreateLoggerFromConfig (std::string const &name)
void	ReadAppendersFromConfig ()
void	ReadLoggersFromConfig ()
void	RegisterAppender (uint8 index, AppenderCreatorFn appenderCreateFn)
void	_outMessage (std::string const &filter, LogLevel level, std::string_view message)
void	_outCommand (std::string_view message, std::string_view param1)

Static Private Member Functions
static std::string	GetTimestampStr ()

Private Attributes
std::unordered_map< uint8, AppenderCreatorFn >	appenderFactory
std::unordered_map< uint8, std::unique_ptr< Appender > >	appenders
std::unordered_map< std::string, std::unique_ptr< Logger > >	loggers
uint8	AppenderId
LogLevel	highestLogLevel
std::string	m_logsDir
std::string	m_logsTimestamp
Acore::Asio::IoContext *	_ioContext
std::unique_ptr< Acore::Asio::Strand >	_strand

Detailed Description

Member Typedef Documentation

LoggerMap

typedef std::unordered_map<std::string, Logger> Log::LoggerMap

private

Constructor & Destructor Documentation

Log() [1/3]

Log::Log ( )

private

         : AppenderId(0), highestLogLevel(LOG_LEVEL_FATAL)
{
    m_logsTimestamp = "_" + GetTimestampStr();
    RegisterAppender<AppenderConsole>();
    RegisterAppender<AppenderFile>();
}

References GetTimestampStr(), and m_logsTimestamp.

~Log()

Log::~Log ( )

private

{
    Close();
}

References Close().

Log() [2/3]

Log::Log ( Log const &  )

privatedelete

Log() [3/3]

Log::Log ( Log &&  )

privatedelete

Member Function Documentation

_outCommand()

void Log::_outCommand ( std::string_view  message, std::string_view  param1  )

private

{
    write(std::make_unique<LogMessage>(LOG_LEVEL_INFO, "commands.gm", message, param1));
}

References LOG_LEVEL_INFO, and write().

Referenced by outCommand().

_outMessage()

void Log::_outMessage ( std::string const &  filter, LogLevel  level, std::string_view  message  )

private

{
    write(std::make_unique<LogMessage>(level, filter, message));
}

References write().

Referenced by outMessage().

Close()

void Log::Close

(

)

{
    loggers.clear();
    appenders.clear();
}

References appenders, and loggers.

Referenced by LoadFromConfig(), ReadLoggersFromConfig(), and ~Log().

CreateAppenderFromConfig()

void Log::CreateAppenderFromConfig ( std::string const &  name )

private

{
    if (appenderName.empty())
    {
        return;
    }
 
    // Format = type, level, flags, optional1, optional2
    // if type = File. optional1 = file and option2 = mode
    // if type = Console. optional1 = Color
    std::string options = sConfigMgr->GetOption<std::string>(appenderName, "");
 
    std::vector<std::string_view> tokens = Acore::Tokenize(options, ',', true);
 
    std::size_t const size = tokens.size();
    std::string name = appenderName.substr(9);
 
    if (size < 2)
    {
        fmt::print(stderr, "Log::CreateAppenderFromConfig: Wrong configuration for appender {}. Config line: {}\n", name, options);
        return;
    }
 
    AppenderFlags flags = APPENDER_FLAGS_NONE;
    AppenderType type = AppenderType(Acore::StringTo<uint8>(tokens[0]).value_or(APPENDER_INVALID));
    LogLevel level = LogLevel(Acore::StringTo<uint8>(tokens[1]).value_or(LOG_LEVEL_INVALID));
 
    auto factoryFunction = appenderFactory.find(type);
    if (factoryFunction == appenderFactory.end())
    {
        fmt::print(stderr, "Log::CreateAppenderFromConfig: Unknown type '{}' for appender {}\n", tokens[0], name);
        return;
    }
 
    if (level > NUM_ENABLED_LOG_LEVELS)
    {
        fmt::print(stderr, "Log::CreateAppenderFromConfig: Wrong Log Level '{}' for appender {}\n", tokens[1], name);
        return;
    }
 
    if (size > 2)
    {
        if (Optional<uint8> flagsVal = Acore::StringTo<uint8>(tokens[2]))
        {
            flags = AppenderFlags(*flagsVal);
        }
        else
        {
            fmt::print(stderr, "Log::CreateAppenderFromConfig: Unknown flags '{}' for appender {}\n", tokens[2], name);
            return;
        }
    }
 
    try
    {
        Appender* appender = factoryFunction->second(NextAppenderId(), name, level, flags, tokens);
        appenders[appender->getId()].reset(appender);
    }
    catch (InvalidAppenderArgsException const& iaae)
    {
        fmt::print(stderr, "{}\n", iaae.what());
    }
}

References APPENDER_FLAGS_NONE, APPENDER_INVALID, appenderFactory, appenders, Appender::getId(), LOG_LEVEL_INVALID, NextAppenderId(), NUM_ENABLED_LOG_LEVELS, sConfigMgr, and Acore::Tokenize().

Referenced by ReadAppendersFromConfig().

CreateLoggerFromConfig()

void Log::CreateLoggerFromConfig ( std::string const &  name )

private

{
    if (appenderName.empty())
    {
        return;
    }
 
    LogLevel level = LOG_LEVEL_DISABLED;
 
    std::string options = sConfigMgr->GetOption<std::string>(appenderName, "");
    std::string name = appenderName.substr(7);
 
    if (options.empty())
    {
        fmt::print(stderr, "Log::CreateLoggerFromConfig: Missing config option Logger.{}\n", name);
        return;
    }
 
    std::vector<std::string_view> tokens = Acore::Tokenize(options, ',', true);
 
    if (tokens.size() != 2)
    {
        fmt::print(stderr, "Log::CreateLoggerFromConfig: Wrong config option Logger.%s=%s\n", name, options);
        return;
    }
 
    std::unique_ptr<Logger>& logger = loggers[name];
    if (logger)
    {
        fmt::print(stderr, "Error while configuring Logger {}. Already defined\n", name);
        return;
    }
 
    level = LogLevel(Acore::StringTo<uint8>(tokens[0]).value_or(LOG_LEVEL_INVALID));
    if (level > NUM_ENABLED_LOG_LEVELS)
    {
        fmt::print(stderr, "Log::CreateLoggerFromConfig: Wrong Log Level '{}' for logger {}\n", tokens[0], name);
        return;
    }
 
    if (level > highestLogLevel)
    {
        highestLogLevel = level;
    }
 
    logger = std::make_unique<Logger>(name, level);
 
    for (std::string_view appendName : Acore::Tokenize(tokens[1], ' ', false))
    {
        if (Appender* appender = GetAppenderByName(appendName))
        {
            logger->addAppender(appender->getId(), appender);
        }
        else
        {
            fmt::print(stderr, "Error while configuring Appender {} in Logger {}. Appender does not exist\n", appendName, name);
        }
    }
}

References GetAppenderByName(), highestLogLevel, LOG_LEVEL_DISABLED, LOG_LEVEL_INVALID, loggers, NUM_ENABLED_LOG_LEVELS, sConfigMgr, and Acore::Tokenize().

Referenced by ReadLoggersFromConfig().

GetAppenderByName()

Appender * Log::GetAppenderByName ( std::string_view  name )

private

{
    auto it = appenders.begin();
    while (it != appenders.end() && it->second && it->second->getName() != name)
    {
        ++it;
    }
 
    return it == appenders.end() ? nullptr : it->second.get();
}

References appenders.

Referenced by CreateLoggerFromConfig(), and SetLogLevel().

GetLoggerByType()

Logger const * Log::GetLoggerByType ( std::string const &  type ) const

private

{
    auto it = loggers.find(type);
    if (it != loggers.end())
    {
        return it->second.get();
    }
 
    if (type == LOGGER_ROOT)
    {
        return nullptr;
    }
 
    std::string parentLogger = LOGGER_ROOT;
    std::size_t found = type.find_last_of('.');
    if (found != std::string::npos)
    {
        parentLogger = type.substr(0, found);
    }
 
    return GetLoggerByType(parentLogger);
}

References GetLoggerByType(), LOGGER_ROOT, and loggers.

Referenced by GetLoggerByType(), ShouldLog(), and write().

GetLogsDir()

std::string const & Log::GetLogsDir ( ) const

inline

{ return m_logsDir; }

References m_logsDir.

GetLogsTimestamp()

std::string const & Log::GetLogsTimestamp ( ) const

inline

{ return m_logsTimestamp; }

References m_logsTimestamp.

GetTimestampStr()

std::string Log::GetTimestampStr ( )

staticprivate

{
    return Acore::Time::TimeToTimestampStr(GetEpochTime(), "%Y-%m-%d_%H_%M_%S");
}

References GetEpochTime(), and Acore::Time::TimeToTimestampStr().

Referenced by Log().

Initialize()

void Log::Initialize

(

Acore::Asio::IoContext *

ioContext = nullptr

)

{
    if (ioContext)
    {
        _ioContext = ioContext;
        _strand = std::make_unique<Acore::Asio::Strand>(*ioContext);
    }
 
    LoadFromConfig();
}

References _ioContext, _strand, and LoadFromConfig().

instance()

Log * Log::instance ( )

static

{
    static Log instance;
    return &instance;
}

References instance().

Referenced by instance().

LoadFromConfig()

void Log::LoadFromConfig

(

)

{
    Close();
 
    highestLogLevel = LOG_LEVEL_FATAL;
    AppenderId = 0;
    m_logsDir = sConfigMgr->GetOption<std::string>("LogsDir", "", false);
 
    if (!m_logsDir.empty())
        if ((m_logsDir.at(m_logsDir.length() - 1) != '/') && (m_logsDir.at(m_logsDir.length() - 1) != '\\'))
        {
            m_logsDir.push_back('/');
        }
 
    ReadAppendersFromConfig();
    ReadLoggersFromConfig();
}

References AppenderId, Close(), highestLogLevel, LOG_LEVEL_FATAL, m_logsDir, ReadAppendersFromConfig(), ReadLoggersFromConfig(), and sConfigMgr.

Referenced by Initialize().

NextAppenderId()

uint8 Log::NextAppenderId ( )

private

{
    return AppenderId++;
}

References AppenderId.

Referenced by CreateAppenderFromConfig(), and ReadLoggersFromConfig().

operator=() [1/2]

Log & Log::operator= ( Log &&  )

privatedelete

operator=() [2/2]

Log & Log::operator= ( Log const &  )

privatedelete

outCommand()

template<typename... Args>

void Log::outCommand ( uint32  account, Acore::FormatString< Args... >  fmt, Args &&...  args  )

inline

    {
        if (!ShouldLog("commands.gm", LOG_LEVEL_INFO))
        {
            return;
        }
 
        _outCommand(Acore::StringFormat(fmt, std::forward<Args>(args)...), std::to_string(account));
    }

References _outCommand(), LOG_LEVEL_INFO, ShouldLog(), and Acore::StringFormat().

outMessage()

template<typename... Args>

void Log::outMessage ( std::string const &  filter, LogLevel const  level, Acore::FormatString< Args... >  fmt, Args &&...  args  )

inline

    {
        _outMessage(filter, level, Acore::StringFormat(fmt, std::forward<Args>(args)...));
    }

References _outMessage(), and Acore::StringFormat().

ReadAppendersFromConfig()

void Log::ReadAppendersFromConfig ( )

private

{
    std::vector<std::string> keys = sConfigMgr->GetKeysByString("Appender.");
    for (std::string const& appenderName : keys)
    {
        CreateAppenderFromConfig(appenderName);
    }
}

References CreateAppenderFromConfig(), and sConfigMgr.

Referenced by LoadFromConfig().

ReadLoggersFromConfig()

void Log::ReadLoggersFromConfig ( )

private

{
    std::vector<std::string> keys = sConfigMgr->GetKeysByString("Logger.");
    for (std::string const& loggerName : keys)
    {
        CreateLoggerFromConfig(loggerName);
    }
 
    // Bad config configuration, creating default config
    if (loggers.find(LOGGER_ROOT) == loggers.end())
    {
        fmt::print(stderr, "Wrong Loggers configuration. Review your Logger config section.\n"
                        "Creating default loggers [root (Error), server (Info)] to console\n");
 
        Close(); // Clean any Logger or Appender created
 
        AppenderConsole* appender = new AppenderConsole(NextAppenderId(), "Console", LOG_LEVEL_DEBUG, APPENDER_FLAGS_NONE, {});
        appenders[appender->getId()].reset(appender);
 
        Logger* rootLogger = new Logger(LOGGER_ROOT, LOG_LEVEL_WARN);
        rootLogger->addAppender(appender->getId(), appender);
        loggers[LOGGER_ROOT].reset(rootLogger);
 
        Logger* serverLogger = new Logger("server", LOG_LEVEL_INFO);
        serverLogger->addAppender(appender->getId(), appender);
        loggers["server"].reset(serverLogger);
 
        highestLogLevel = LOG_LEVEL_INFO;
        return;
    }
}

References Logger::addAppender(), APPENDER_FLAGS_NONE, appenders, Close(), CreateLoggerFromConfig(), Appender::getId(), highestLogLevel, LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARN, LOGGER_ROOT, loggers, NextAppenderId(), and sConfigMgr.

Referenced by LoadFromConfig().

RegisterAppender() [1/2]

template<class AppenderImpl >

void Log::RegisterAppender ( )

inline

    {
        RegisterAppender(AppenderImpl::type, &CreateAppender<AppenderImpl>);
    }

References RegisterAppender().

Referenced by RegisterAppender().

RegisterAppender() [2/2]

void Log::RegisterAppender ( uint8  index, AppenderCreatorFn  appenderCreateFn  )

private

{
    auto itr = appenderFactory.find(index);
    ASSERT(itr == appenderFactory.end());
    appenderFactory[index] = appenderCreateFn;
}

References appenderFactory, and ASSERT.

SetLogLevel()

bool Log::SetLogLevel	(	std::string const &	name,
		int32	level,
		bool	isLogger = true
	)

{
    if (newLeveli < 0)
    {
        return false;
    }
 
    LogLevel newLevel = LogLevel(newLeveli);
 
    if (isLogger)
    {
        auto it = loggers.begin();
        while (it != loggers.end() && it->second->getName() != name)
        {
            ++it;
        }
 
        if (it == loggers.end())
        {
            return false;
        }
 
        it->second->setLogLevel(newLevel);
 
        if (newLevel != LOG_LEVEL_DISABLED && newLevel > highestLogLevel)
        {
            highestLogLevel = newLevel;
        }
    }
    else
    {
        Appender* appender = GetAppenderByName(name);
        if (!appender)
        {
            return false;
        }
 
        appender->setLogLevel(newLevel);
    }
 
    return true;
}

References GetAppenderByName(), highestLogLevel, LOG_LEVEL_DISABLED, loggers, and Appender::setLogLevel().

SetRealmId()

void Log::SetRealmId

(

uint32

id

)

{
    for (std::pair<uint8 const, std::unique_ptr<Appender>>& appender : appenders)
    {
        appender.second->setRealmId(id);
    }
}

References appenders.

SetSynchronous()

void Log::SetSynchronous

(

)

{
    _strand.reset();
    _ioContext = nullptr;
}

References _ioContext, and _strand.

ShouldLog()

bool Log::ShouldLog	(	std::string const &	type,
		LogLevel	level
	)		const

Todo:

: Use cache to store "Type.sub1.sub2": "Type" equivalence, should

{
    // Speed up in cases where requesting "Type.sub1.sub2" but only configured
    // Logger "Type"
 
    // Don't even look for a logger if the LogLevel is higher than the highest log levels across all loggers
    if (level > highestLogLevel)
    {
        return false;
    }
 
    Logger const* logger = GetLoggerByType(type);
    if (!logger)
    {
        return false;
    }
 
    LogLevel logLevel = logger->getLogLevel();
    return logLevel != LOG_LEVEL_DISABLED && logLevel >= level;
}

References GetLoggerByType(), Logger::getLogLevel(), highestLogLevel, and LOG_LEVEL_DISABLED.

Referenced by outCommand().

write()

void Log::write ( std::unique_ptr< LogMessage > &&  msg ) const

private

{
    Logger const* logger = GetLoggerByType(msg->type);
 
    if (_ioContext)
    {
        std::shared_ptr<LogOperation> logOperation = std::make_shared<LogOperation>(logger, std::move(msg));
        Acore::Asio::post(*_ioContext, Acore::Asio::bind_executor(*_strand, [logOperation]() { logOperation->call(); }));
    }
    else
        logger->write(msg.get());
}

References _ioContext, _strand, GetLoggerByType(), Acore::Asio::post(), and Logger::write().

Referenced by _outCommand(), and _outMessage().

Member Data Documentation

_ioContext

Acore::Asio::IoContext* Log::_ioContext

private

Referenced by Initialize(), SetSynchronous(), and write().

_strand

std::unique_ptr<Acore::Asio::Strand> Log::_strand

private

Referenced by Initialize(), SetSynchronous(), and write().

appenderFactory

std::unordered_map<uint8, AppenderCreatorFn> Log::appenderFactory

private

Referenced by CreateAppenderFromConfig(), and RegisterAppender().

AppenderId

uint8 Log::AppenderId

private

Referenced by LoadFromConfig(), and NextAppenderId().

appenders

std::unordered_map<uint8, std::unique_ptr<Appender> > Log::appenders

private

Referenced by Close(), CreateAppenderFromConfig(), GetAppenderByName(), ReadLoggersFromConfig(), and SetRealmId().

highestLogLevel

LogLevel Log::highestLogLevel

private

Referenced by CreateLoggerFromConfig(), LoadFromConfig(), ReadLoggersFromConfig(), SetLogLevel(), and ShouldLog().

loggers

std::unordered_map<std::string, std::unique_ptr<Logger> > Log::loggers

private

Referenced by Close(), CreateLoggerFromConfig(), GetLoggerByType(), ReadLoggersFromConfig(), and SetLogLevel().

m_logsDir

std::string Log::m_logsDir

private

Referenced by GetLogsDir(), and LoadFromConfig().

m_logsTimestamp

std::string Log::m_logsTimestamp

private

Referenced by GetLogsTimestamp(), and Log().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/common/Logging/Log.h
• azerothcore-wotlk/src/common/Logging/Log.cpp