1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/*
* CBasicLogConfigurator.cpp, part of VCMI engine
*
* Authors: listed in file AUTHORS in main folder
*
* License: GNU General Public License v2.0 or later
* Full text of license available in license.txt file, in main folder
*
*/
#include "StdInc.h"
#include "CBasicLogConfigurator.h"
#include "CLogger.h"
#include "../CConfigHandler.h"
CBasicLogConfigurator::CBasicLogConfigurator(boost::filesystem::path filePath, CConsoleHandler * const console) :
filePath(std::move(filePath)), console(console), appendToLogFile(false) {}
void CBasicLogConfigurator::configureDefault()
{
CLogger::getGlobalLogger()->addTarget(make_unique<CLogConsoleTarget>(console));
CLogger::getGlobalLogger()->addTarget(make_unique<CLogFileTarget>(filePath, appendToLogFile));
appendToLogFile = true;
}
void CBasicLogConfigurator::configure()
{
try
{
const JsonNode & loggingNode = settings["logging"];
if(loggingNode.isNull())
throw std::runtime_error("Settings haven't been loaded.");
// Configure loggers
const JsonNode & loggers = loggingNode["loggers"];
if(!loggers.isNull())
{
for(auto & loggerNode : loggers.Vector())
{
// Get logger
std::string name = loggerNode["domain"].String();
CLogger * logger = CLogger::getLogger(CLoggerDomain(name));
// Set log level
std::string level = loggerNode["level"].String();
logger->setLevel(getLogLevel(level));
logGlobal->debug("Set log level %s => %d", name, level);
}
}
CLogger::getGlobalLogger()->clearTargets();
// Add console target
auto consoleTarget = make_unique<CLogConsoleTarget>(console);
const JsonNode & consoleNode = loggingNode["console"];
if(!consoleNode.isNull())
{
const JsonNode & consoleFormatNode = consoleNode["format"];
if(!consoleFormatNode.isNull()) consoleTarget->setFormatter(CLogFormatter(consoleFormatNode.String()));
const JsonNode & consoleThresholdNode = consoleNode["threshold"];
if(!consoleThresholdNode.isNull()) consoleTarget->setThreshold(getLogLevel(consoleThresholdNode.String()));
const JsonNode & coloredConsoleEnabledNode = consoleNode["coloredOutputEnabled"];
consoleTarget->setColoredOutputEnabled(coloredConsoleEnabledNode.Bool());
CColorMapping colorMapping;
const JsonNode & colorMappingNode = consoleNode["colorMapping"];
if(!colorMappingNode.isNull())
{
for(const JsonNode & mappingNode : colorMappingNode.Vector())
{
std::string domain = mappingNode["domain"].String();
std::string level = mappingNode["level"].String();
std::string color = mappingNode["color"].String();
colorMapping.setColorFor(CLoggerDomain(domain), getLogLevel(level), getConsoleColor(color));
}
}
consoleTarget->setColorMapping(colorMapping);
}
CLogger::getGlobalLogger()->addTarget(std::move(consoleTarget));
// Add file target
auto fileTarget = make_unique<CLogFileTarget>(filePath, appendToLogFile);
const JsonNode & fileNode = loggingNode["file"];
if(!fileNode.isNull())
{
const JsonNode & fileFormatNode = fileNode["format"];
if(!fileFormatNode.isNull()) fileTarget->setFormatter(CLogFormatter(fileFormatNode.String()));
}
CLogger::getGlobalLogger()->addTarget(std::move(fileTarget));
appendToLogFile = true;
}
catch(const std::exception & e)
{
logGlobal->error("Could not initialize the logging system due to configuration error/s."
"The logging system can be in a corrupted state. %s", e.what());
}
logGlobal->info("Initialized logging system based on settings successfully.");
for (auto& domain : CLogManager::get().getRegisteredDomains())
{
logGlobal->info("[log level] %s => %s", domain,
ELogLevel::to_string(CLogger::getLogger(CLoggerDomain(domain))->getLevel()));
}
}
ELogLevel::ELogLevel CBasicLogConfigurator::getLogLevel(const std::string & level)
{
static const std::map<std::string, ELogLevel::ELogLevel> levelMap =
{
{"trace", ELogLevel::TRACE},
{"debug", ELogLevel::DEBUG},
{"info", ELogLevel::INFO},
{"warn", ELogLevel::WARN},
{"error", ELogLevel::ERROR},
};
const auto & levelPair = levelMap.find(level);
if(levelPair != levelMap.end())
return levelPair->second;
else
throw std::runtime_error("Log level " + level + " unknown.");
}
EConsoleTextColor::EConsoleTextColor CBasicLogConfigurator::getConsoleColor(const std::string & colorName)
{
static const std::map<std::string, EConsoleTextColor::EConsoleTextColor> colorMap =
{
{"default", EConsoleTextColor::DEFAULT},
{"green", EConsoleTextColor::GREEN},
{"red", EConsoleTextColor::RED},
{"magenta", EConsoleTextColor::MAGENTA},
{"yellow", EConsoleTextColor::YELLOW},
{"white", EConsoleTextColor::WHITE},
{"gray", EConsoleTextColor::GRAY},
{"teal", EConsoleTextColor::TEAL},
};
const auto & colorPair = colorMap.find(colorName);
if(colorPair != colorMap.end())
return colorPair->second;
else
throw std::runtime_error("Color " + colorName + " unknown.");
}
|
