Logger.cpp

Go to the documentation of this file.

#include "Logger.hpp"

namespace HCE {
    extern Poco::AutoPtr<Poco::Util::AbstractConfiguration> _config;
}

bool HCE::Logger::alwaysUseDefaultLog = DEFAULT_LOG_ALWAYS_USE_DEF_LOG;

void HCE::Logger::initializeLoggers() {

    HCE::Logger::initializeDefaultLogger();
    HCE::Logger::checkDefaultLogger();
    HCE::Logger::alwaysUseDefaultLog = HCE::_config->getBool(ALWAYS_USE_DEFAULT_LOG,DEFAULT_LOG_ALWAYS_USE_DEF_LOG);

    Poco::AutoPtr<Poco::FormattingChannel> pFCFile;
    Poco::Util::AbstractConfiguration::Keys channels;

    HCE::_config->keys(CHANNELS,channels);

    for (std::vector<std::string>::const_iterator key = channels.begin(); key != channels.end(); ++key) {
        //if key exist use PatternFormatter.key, else use default format.
        std::string patternForChannel = std::string(PATTERN_FORMATTER) + "." + *key;
        if (HCE::_config->has(patternForChannel)) {
            pFCFile = new Poco::FormattingChannel(Poco::AutoPtr<Poco::PatternFormatter>(new Poco::PatternFormatter(HCE::_config->getString(patternForChannel))));
        }
        else {
            pFCFile = new Poco::FormattingChannel(Poco::AutoPtr<Poco::Formatter>(new Poco::PatternFormatter(DEFAULT_LOG_PATTERN_FORMATTER)));
        }
        
        Poco::AutoPtr<Poco::FileChannel> fileChannel(new Poco::FileChannel(HCE::_config->getString(std::string(CHANNELS) + "."+*key)));

        std::string archive = HCE::_config->getString("LOG.archive",DEFAULT_ARCHIVE);
        std::string purgeAge = HCE::_config->getString("LOG.purgeAge",DEFAULT_PURGE_AGE);
        std::string rotation = HCE::_config->getString("LOG.rotation",DEFAULT_ROTATION);

        fileChannel->setProperty("archive",archive);
        fileChannel->setProperty("purgeAge",purgeAge);
        fileChannel->setProperty("rotation",rotation);

        pFCFile->setChannel(fileChannel);

        Poco::Logger* logger = Poco::Logger::has(*key);
        if (logger != NULL) {
            logger->setChannel(pFCFile);
            logger->setLevel(HCE::_config->getString(LOG_LEVEL,DEFAULT_LOG_LEVEL));
        }
        else {
            Poco::Logger& newLogger = Poco::Logger::create(*key,pFCFile);
            newLogger.setLevel(HCE::_config->getString(LOG_LEVEL,DEFAULT_LOG_LEVEL));
        }
    }
}

void HCE::Logger::initializeDefaultLogger() {
    Poco::AutoPtr<Poco::FormattingChannel> defaultpFCFile =
            new Poco::FormattingChannel(Poco::AutoPtr<Poco::PatternFormatter>(new Poco::PatternFormatter(DEFAULT_LOG_PATTERN_FORMATTER)));
    Poco::AutoPtr<Poco::FileChannel> fileChannel(new Poco::FileChannel(getDefaultChannel()));


    std::string archive = HCE::_config->getString("LOG.archive",DEFAULT_ARCHIVE);
    std::string purgeAge = HCE::_config->getString("LOG.purgeAge",DEFAULT_PURGE_AGE);
    std::string rotation = HCE::_config->getString("LOG.rotation",DEFAULT_ROTATION);

    fileChannel->setProperty("archive",archive);
    fileChannel->setProperty("purgeAge",purgeAge);
    fileChannel->setProperty("rotation",rotation);
    defaultpFCFile->setChannel(fileChannel);

    //default log level - information
    Poco::Logger* logger = NULL;
    logger = Poco::Logger::has(DEFAULT_LOG_NAME);
    if (logger == NULL) {
        Poco::Logger& defaultLogger = Poco::Logger::create(DEFAULT_LOG_NAME,defaultpFCFile);
        defaultLogger.setLevel(HCE::_config->getString(LOG_LEVEL,DEFAULT_LOG_LEVEL));
    }
    else {
        //default logger already exist
    }
}

void HCE::Logger::checkDefaultLogger() {
    //finding logger
    Poco::Logger* checkLogger = Poco::Logger::has(DEFAULT_LOG_NAME);
    //<! if default logger does not exist application can not works
    poco_assert (checkLogger != NULL);
}

std::string HCE::Logger::getDefaultChannel () {
    poco_check_ptr(HCE::_config);
    return HCE::_config->getString(BASE_NAME) + std::string(DEFAULT_LOG_SUFFIX);
}

//<! channel - logger name
//<! msg - log message
void HCE::Logger::writeLog (const Poco::Message& msg,const std::string& channel) {
    //<! if channel exist , write msg to channel
    Poco::Logger* logger = NULL;
    logger = Poco::Logger::has(channel);
    if (logger != NULL) {
        logger->log(msg);
    }
    else {
        if (HCE::Logger::alwaysUseDefaultLog == true) {
                logger = Poco::Logger::has(DEFAULT_LOG_NAME);
                if (logger != NULL) {
                        logger->log(msg);
                }
                else {
                        HCE::Logger::writeUnregisterLog (msg,channel);
                }
        }
        else {
                HCE::Logger::writeUnregisterLog(msg,channel);
        }
    }
}

void HCE::Logger::writeUnregisterLog(const Poco::Message& msg,const std::string& channel) {
        std::cout << HCE::Logger::createMsgIfThatChannelNotExist(channel) << std::endl;
    std::cout << MESSAGE_WRITTEN_INTO_UNREGISTER_LOG << " : " << msg.getText() << std::endl;
}

void HCE::Logger::setLevelByChannelName(const std::string& channelName, const int& level) {
    Poco::Logger::setLevel(channelName,level);     
}

void HCE::Logger::setLevelByChannelName (const std::string& channelName,const std::string& level) {
    //this method throw InvalidArgumentException if level not valid.
    int levelIntegerValue = Poco::Logger::parseLevel(level);
    HCE::Logger::setLevelByChannelName(channelName,levelIntegerValue);
}

void HCE::Logger::setLevelForAllChannel(const int& level) {
    Poco::Logger::setLevel(Poco::Logger::ROOT,level);
}

void HCE::Logger::setLevelForAllChannel(const std::string& level) {
    //this method throw InvalidArgumentException if level not valid.
    int levelIntegerValue = Poco::Logger::parseLevel(level);
    HCE::Logger::setLevelForAllChannel(levelIntegerValue);
}

void HCE::Logger::off() {
    Poco::Logger::setLevel(Poco::Logger::ROOT,LOGGER_OFF_LEVEL);
}

void HCE::Logger::on(const std::string& level) {
    HCE::Logger::setLevelForAllChannel(level);
}

void HCE::Logger::on(const int& level) {
    HCE::Logger::setLevelForAllChannel(level);
}

std::string HCE::Logger::createMsgIfThatChannelNotExist (const std::string& channelName) {
        std::stringstream ss;
        ss << "Channel "; ss << channelName; ss << " not exists";
        return ss.str();
}