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

                // Set log level
                logger->setLevel(getLogLevel(loggerNode["level"].String()));
            }
        }
        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())
            {
                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);
        }
        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->errorStream() << "Could not initialize the logging system due to configuration error/s."
            << "The logging system can be in a corrupted state. " << e.what();
    }

    logGlobal->infoStream() << "Initialized logging system based on settings successfully.";
}

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.");
    }
}