Log Class Reference

#include <Log.h>

Public Member Functions
void	Initialize (boost::asio::io_service *ioService)
void	SetSynchronous ()
void	LoadFromConfig ()
void	Close ()
bool	ShouldLog (std::string const &type, LogLevel level) const
bool	SetLogLevel (std::string const &name, char const *level, bool isLogger=true)
template<typename Format , typename... Args>
void	outMessage (std::string const &filter, LogLevel const level, Format &&fmt, Args &&...args)
template<typename Format , typename... Args>
void	outCommand (uint32 account, Format &&fmt, Args &&...args)
void	outCharDump (char const *str, uint32 account_id, uint64 guid, char const *name)
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 ()
void	write (std::unique_ptr< LogMessage > &&msg) const
Logger const *	GetLoggerByType (std::string const &type) const
Appender *	GetAppenderByName (std::string const &name)
uint8	NextAppenderId ()
void	CreateAppenderFromConfig (std::string const &name)
void	CreateLoggerFromConfig (std::string const &name)
void	ReadAppendersFromConfig ()
void	ReadLoggersFromConfig ()

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

Private Attributes
AppenderCreatorMap	appenderFactory
AppenderMap	appenders
LoggerMap	loggers
uint8	AppenderId
LogLevel	lowestLogLevel
std::string	m_logsDir
std::string	m_logsTimestamp
boost::asio::io_service *	_ioService
boost::asio::strand *	_strand

Member Typedef Documentation

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

private

Constructor & Destructor Documentation

Log::Log ( )

private

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

Here is the call graph for this function:

Log::~Log ( )

private

{
 delete _strand;
 Close();
}

Here is the call graph for this function:

Member Function Documentation

void Log::Close

(

)

{
 loggers.clear();
 for (AppenderMap::iterator it = appenders.begin(); it != appenders.end(); ++it)
 delete it->second;

 appenders.clear();
}

Here is the caller graph for this function:

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->GetStringDefault(appenderName.c_str(), "");

 Tokenizer tokens(options, ',');
 Tokenizer::const_iterator iter = tokens.begin();

 size_t size = tokens.size();
 std::string name = appenderName.substr(9);

 if (size < 2)
 {
 fprintf(stderr, "Log::CreateAppenderFromConfig: Wrong configuration for appender %s. Config line: %s\n", name.c_str(), options.c_str());
 return;
 }

 AppenderFlags flags = APPENDER_FLAGS_NONE;
 AppenderType type = AppenderType(atoi(*iter++));
 LogLevel level = LogLevel(atoi(*iter++));

 if (level > LOG_LEVEL_FATAL)
 {
 fprintf(stderr, "Log::CreateAppenderFromConfig: Wrong Log Level %d for appender %s\n", level, name.c_str());
 return;
 }

 if (size > 2)
 flags = AppenderFlags(atoi(*iter++));

 auto factoryFunction = appenderFactory.find(type);
 if (factoryFunction == appenderFactory.end())
 {
 fprintf(stderr, "Log::CreateAppenderFromConfig: Unknown type %d for appender %s\n", type, name.c_str());
 return;
 }

 try
 {
 Appender* appender = factoryFunction->second(NextAppenderId(), name, level, flags, ExtraAppenderArgs(iter, tokens.end()));
 appenders[appender->getId()] = appender;
 }
 catch (InvalidAppenderArgsException const& iaae)
 {
 fprintf(stderr, "%s", iaae.what());
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

{
 if (appenderName.empty())
 return;

 LogLevel level = LOG_LEVEL_DISABLED;
 uint8 type = uint8(-1);

 std::string options = sConfigMgr->GetStringDefault(appenderName.c_str(), "");
 std::string name = appenderName.substr(7);

 if (options.empty())
 {
 fprintf(stderr, "Log::CreateLoggerFromConfig: Missing config option Logger.%s\n", name.c_str());
 return;
 }

 Tokenizer tokens(options, ',');
 Tokenizer::const_iterator iter = tokens.begin();

 if (tokens.size() != 2)
 {
 fprintf(stderr, "Log::CreateLoggerFromConfig: Wrong config option Logger.%s=%s\n", name.c_str(), options.c_str());
 return;
 }

 Logger& logger = loggers[name];
 if (!logger.getName().empty())
 {
 fprintf(stderr, "Error while configuring Logger %s. Already defined\n", name.c_str());
 return;
 }

 level = LogLevel(atoi(*iter++));
 if (level > LOG_LEVEL_FATAL)
 {
 fprintf(stderr, "Log::CreateLoggerFromConfig: Wrong Log Level %u for logger %s\n", type, name.c_str());
 return;
 }

 if (level < lowestLogLevel)
 lowestLogLevel = level;

 logger.Create(name, level);
 //fprintf(stdout, "Log::CreateLoggerFromConfig: Created Logger %s, Level %u\n", name.c_str(), level);

 std::istringstream ss(*iter);
 std::string str;

 ss >> str;
 while (ss)
 {
 if (Appender* appender = GetAppenderByName(str))
 {
 logger.addAppender(appender->getId(), appender);
 //fprintf(stdout, "Log::CreateLoggerFromConfig: Added Appender %s to Logger %s\n", appender->getName().c_str(), name.c_str());
 }
 else
 fprintf(stderr, "Error while configuring Appender %s in Logger %s. Appender does not exist", str.c_str(), name.c_str());
 ss >> str;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Appender * Log::GetAppenderByName ( std::string const &  name )

private

{
 AppenderMap::iterator it = appenders.begin();
 while (it != appenders.end() && it->second && it->second->getName() != name)
 ++it;

 return it == appenders.end() ? NULL : it->second;
}

Here is the caller graph for this function:

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

inlineprivate

{
 LoggerMap::const_iterator it = loggers.find(type);
 if (it != loggers.end())
 return &(it->second);

 if (type == LOGGER_ROOT)
 return NULL;

 std::string parentLogger = LOGGER_ROOT;
 size_t found = type.find_last_of(".");
 if (found != std::string::npos)
 parentLogger = type.substr(0,found);

 return GetLoggerByType(parentLogger);
}

Here is the caller graph for this function:

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

inline

{ return m_logsDir; }

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

inline

{ return m_logsTimestamp; }

std::string Log::GetTimestampStr ( )

staticprivate

{
 time_t tt = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());

 std::tm aTm;
 localtime_r(&tt, &aTm);

 // YYYY year
 // MM month (2 digits 01-12)
 // DD day (2 digits 01-31)
 // HH hour (2 digits 00-23)
 // MM minutes (2 digits 00-59)
 // SS seconds (2 digits 00-59)
 return Trinity::StringFormat("%04d-%02d-%02d_%02d-%02d-%02d",
 aTm.tm_year + 1900, aTm.tm_mon + 1, aTm.tm_mday, aTm.tm_hour, aTm.tm_min, aTm.tm_sec);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Log::Initialize

(

boost::asio::io_service *

ioService

)

{
 if (ioService)
 {
 _ioService = ioService;
 _strand = new boost::asio::strand(*ioService);
 }

 LoadFromConfig();
}

Here is the call graph for this function:

Log * Log::instance ( )

static

{
 static Log instance;
 return &instance;
}

void Log::LoadFromConfig

(

)

{
 Close();

 lowestLogLevel = LOG_LEVEL_FATAL;
 AppenderId = 0;
 m_logsDir = sConfigMgr->GetStringDefault("LogsDir", "");
 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();
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8 Log::NextAppenderId ( )

private

{
 return AppenderId++;
}

Here is the caller graph for this function:

void Log::outCharDump	(	char const *	str,
		uint32	account_id,
		uint64	guid,
		char const *	name
	)

{
 if (!str || !ShouldLog("entities.player.dump", LOG_LEVEL_INFO))
 return;

 std::ostringstream ss;
 ss << "== START DUMP == (account: " << accountId << " guid: " << guid << " name: " << name
 << ")\n" << str << "\n== END DUMP ==\n";

 std::unique_ptr<LogMessage> msg(new LogMessage(LOG_LEVEL_INFO, "entities.player.dump", ss.str()));
 std::ostringstream param;
 param << guid << '_' << name;

 msg->param1 = param.str();

 write(std::move(msg));
}

Here is the call graph for this function:

template<typename Format , typename... Args>

void Log::outCommand ( uint32  account, Format &&  fmt, Args &&...  args  )

inline

 {
 if (!ShouldLog("commands.gm", LOG_LEVEL_INFO))
 return;

 std::unique_ptr<LogMessage> msg =
 Trinity::make_unique<LogMessage>(LOG_LEVEL_INFO, "commands.gm",
 Trinity::StringFormat(std::forward<Format>(fmt), std::forward<Args>(args)...));

 msg->param1 = std::to_string(account);

 write(std::move(msg));
 }

Here is the call graph for this function:

template<typename Format , typename... Args>

void Log::outMessage ( std::string const &  filter, LogLevel const  level, Format &&  fmt, Args &&...  args  )

inline

 {
 write(Trinity::make_unique<LogMessage>(level, filter,
 Trinity::StringFormat(std::forward<Format>(fmt), std::forward<Args>(args)...)));
 }

Here is the call graph for this function:

void Log::ReadAppendersFromConfig ( )

private

{
 std::list<std::string> keys = sConfigMgr->GetKeysByString("Appender.");

 while (!keys.empty())
 {
 CreateAppenderFromConfig(keys.front());
 keys.pop_front();
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Log::ReadLoggersFromConfig ( )

private

{
 std::list<std::string> keys = sConfigMgr->GetKeysByString("Logger.");

 while (!keys.empty())
 {
 CreateLoggerFromConfig(keys.front());
 keys.pop_front();
 }

 // Bad config configuration, creating default config
 if (loggers.find(LOGGER_ROOT) == loggers.end())
 {
 fprintf(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, ExtraAppenderArgs());
 appenders[appender->getId()] = appender;

 Logger& rootLogger = loggers[LOGGER_ROOT];
 rootLogger.Create(LOGGER_ROOT, LOG_LEVEL_ERROR);
 rootLogger.addAppender(appender->getId(), appender);

 Logger& serverLogger = loggers["server"];
 serverLogger.Create("server", LOG_LEVEL_INFO);
 serverLogger.addAppender(appender->getId(), appender);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class AppenderImpl >

void Log::RegisterAppender ( )

inline

 {
 using Index = typename AppenderImpl::TypeIndex;
 auto itr = appenderFactory.find(Index::value);
 ASSERT(itr == appenderFactory.end());
 appenderFactory[Index::value] = &CreateAppender<AppenderImpl>;
 }

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

{
 LogLevel newLevel = LogLevel(atoi(newLevelc));
 if (newLevel < 0)
 return false;

 if (isLogger)
 {
 LoggerMap::iterator 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 < lowestLogLevel)
 lowestLogLevel = newLevel;
 }
 else
 {
 Appender* appender = GetAppenderByName(name);
 if (!appender)
 return false;

 appender->setLogLevel(newLevel);
 }

 return true;
}

Here is the call graph for this function:

void Log::SetRealmId

(

uint32

id

)

{
 for (AppenderMap::iterator it = appenders.begin(); it != appenders.end(); ++it)
 it->second->setRealmId(id);
}

void Log::SetSynchronous

(

)

{
 delete _strand;
 _strand = nullptr;
 _ioService = nullptr;
}

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

inline

{
 // 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 lower than lowest log levels across all loggers
 if (level < lowestLogLevel)
 return false;

 Logger const* logger = GetLoggerByType(type);
 if (!logger)
 return false;

 LogLevel logLevel = logger->getLogLevel();
 return logLevel != LOG_LEVEL_DISABLED && logLevel <= level;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

{
 Logger const* logger = GetLoggerByType(msg->type);

 if (_ioService)
 {
 auto logOperation = std::shared_ptr<LogOperation>(new LogOperation(logger, std::move(msg)));

 _ioService->post(_strand->wrap([logOperation](){ logOperation->call(); }));
 }
 else
 logger->write(msg.get());
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

boost::asio::io_service* Log::_ioService

private

boost::asio::strand* Log::_strand

private

AppenderCreatorMap Log::appenderFactory

private

uint8 Log::AppenderId

private

AppenderMap Log::appenders

private

LoggerMap Log::loggers

private

LogLevel Log::lowestLogLevel

private

std::string Log::m_logsDir

private

std::string Log::m_logsTimestamp

private

---

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

• src/common/Logging/Log.h
• src/common/Logging/Log.cpp