vcmi/lib/logging/CBasicLogConfigurator.cpp

#include "StdInc.h"
#include "CBasicLogConfigurator.h"

#include "../CConfigHandler.h"

CBasicLogConfigurator::CBasicLogConfigurator(const std::string & filePath, CConsoleHandler * console) : filePath(filePath), console(console)
{

}

void CBasicLogConfigurator::configureDefault(bool appendToLogFile /*= true*/)
{
    CGLogger::getGlobalLogger()->addTarget(make_unique<CLogConsoleTarget>(console));
    CGLogger::getGlobalLogger()->addTarget(make_unique<CLogFileTarget>(filePath, appendToLogFile));
}

void CBasicLogConfigurator::configure(bool appendToLogFile /*= true*/)
{
    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())
    {
        BOOST_FOREACH(auto & loggerNode, loggers.Vector())
        {
            // Get logger
            std::string name = loggerNode["domain"].String();
            CGLogger * logger = CGLogger::getLogger(CLoggerDomain(name));

            // Set log level
            logger->setLevel(getLogLevel(loggerNode["level"].String()));
        }
    }
    CGLogger::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())
        {
            BOOST_FOREACH(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);
    }
    CGLogger::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()));
    }
    CGLogger::getGlobalLogger()->addTarget(std::move(fileTarget));
}

ELogLevel::ELogLevel CBasicLogConfigurator::getLogLevel(const std::string & level) const
{
    static const std::map<std::string, ELogLevel::ELogLevel> levelMap = boost::assign::map_list_of
            ("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) const
{
    static const std::map<std::string, EConsoleTextColor::EConsoleTextColor> colorMap = boost::assign::map_list_of
            ("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.");
    }
}