ibrcommon/ibrcommon/Logger.cpp

Go to the documentation of this file.

/*
 * Logger.cpp
 *
 *  Created on: 08.06.2010
 *      Author: morgenro
 */

#include "ibrcommon/Logger.h"
#include "ibrcommon/SyslogStream.h"
#include <algorithm>
#include <sys/time.h>

namespace ibrcommon
{
        std::list<Logger::LoggerOutput> Logger::_logger;
        int Logger::_verbosity = 0;
        bool Logger::_syslog = 0;
        unsigned char Logger::_syslog_mask = 0;
        Logger::endl_flag Logger::endl;

        Logger::Logger(LogLevel level, int debug_verbosity)
         : _level(level), _debug_verbosity(debug_verbosity)
        {
        }

        Logger::Logger(const Logger &obj)
         : std::stringstream(obj.str()), _level(obj._level), _debug_verbosity(obj._debug_verbosity)
        {
        }

        Logger::~Logger()
        {
        }

        Logger Logger::emergency()
        {
                return Logger(LOGGER_EMERG);
        }

        Logger Logger::alert()
        {
                return Logger(LOGGER_ALERT);
        }

        Logger Logger::critical()
        {
                return Logger(LOGGER_CRIT);
        }

        Logger Logger::error()
        {
                return Logger(LOGGER_ERR);
        }

        Logger Logger::warning()
        {
                return Logger(LOGGER_WARNING);
        }

        Logger Logger::notice()
        {
                return Logger(LOGGER_NOTICE);
        }

        Logger Logger::info()
        {
                return Logger(LOGGER_INFO);
        }

        Logger Logger::debug(int verbosity)
        {
                return Logger(LOGGER_DEBUG, verbosity);
        }

        void Logger::setVerbosity(const int verbosity)
        {
                Logger::_verbosity = verbosity;
        }

        int Logger::getVerbosity()
        {
                return Logger::_verbosity;
        }

        void Logger::addStream(std::ostream &stream, const unsigned char logmask, const unsigned char options)
        {
                _logger.push_back( LoggerOutput(stream, logmask, options) );
        }

        void Logger::enableSyslog(const char *name, int option, int facility, const unsigned char logmask)
        {
                // init syslog
                ::openlog(name, option, facility);
                Logger::_syslog = true;
                Logger::_syslog_mask = logmask;
        }

        void Logger::flush()
        {
                if (Logger::_verbosity >= _debug_verbosity)
                {
                        for (std::list<LoggerOutput>::iterator iter = _logger.begin(); iter != _logger.end(); iter++)
                        {
                                LoggerOutput &output = (*iter);
                                output.log(*this);
                        }

                        // additionally log to the syslog
                        if (Logger::_syslog)
                        {
                                if (_level & Logger::_syslog_mask)
                                {
                                        switch (_level)
                                        {
                                        case LOGGER_EMERG:
                                                ::syslog( LOG_EMERG, "%s", str().c_str() );
                                                break;

                                        case LOGGER_ALERT:
                                                ::syslog( LOG_ALERT, "%s", str().c_str() );
                                                break;

                                        case LOGGER_CRIT:
                                                ::syslog( LOG_CRIT, "%s", str().c_str() );
                                                break;

                                        case LOGGER_ERR:
                                                ::syslog( LOG_ERR, "%s", str().c_str() );
                                                break;

                                        case LOGGER_WARNING:
                                                ::syslog( LOG_WARNING, "%s", str().c_str() );
                                                break;

                                        case LOGGER_NOTICE:
                                                ::syslog( LOG_NOTICE, "%s", str().c_str() );
                                                break;

                                        case LOGGER_INFO:
                                                ::syslog( LOG_INFO, "%s", str().c_str() );
                                                break;

                                        case LOGGER_DEBUG:
                                                ::syslog( LOG_DEBUG, "%s", str().c_str() );
                                                break;

                                        default:
                                                ::syslog( LOG_NOTICE, "%s", str().c_str() );
                                                break;
                                        }
                                }
                        }
                }
        }

        void Logger::LoggerOutput::log(const Logger &log)
        {
                if (_level & log._level)
                {
                        std::list<std::string> prefixes;

                        // check for prefixes
                        if (_options & LOG_TIMESTAMP)
                        {
                                // get timestamp
                                time_t ltime; /* calendar time */
                                ltime=time(NULL); /* get current cal time */
                                std::string timestamp(asctime( localtime(&ltime) ));
                                timestamp.erase(std::remove(timestamp.begin(), timestamp.end(), '\n'), timestamp.end());
                                prefixes.push_back(timestamp);
                        }

                        if (_options & LOG_LEVEL)
                        {
                                // print log level
                                switch (log._level)
                                {
                                        case LOGGER_EMERG:
                                                prefixes.push_back("EMERGENCY");
                                                break;

                                        case LOGGER_ALERT:
                                                prefixes.push_back("ALERT");
                                                break;

                                        case LOGGER_CRIT:
                                                prefixes.push_back("CRTITICAL");
                                                break;

                                        case LOGGER_ERR:
                                                prefixes.push_back("ERROR");
                                                break;

                                        case LOGGER_WARNING:
                                                prefixes.push_back("WARNING");
                                                break;

                                        case LOGGER_NOTICE:
                                                prefixes.push_back("NOTICE");
                                                break;

                                        case LOGGER_INFO:
                                                prefixes.push_back("INFO");
                                                break;

                                        case LOGGER_DEBUG:
                                        {
                                                std::stringstream ss;
                                                ss << "DEBUG." << log._debug_verbosity;
                                                prefixes.push_back(ss.str());
                                                break;
                                        }

                                        default:
                                                break;
                                }
                        }

                        if (_options & LOG_HOSTNAME)
                        {
                                char *hostname_array = new char[64];
                                if ( gethostname(hostname_array, 64) == 0 )
                                {
                                        std::string hostname(hostname_array);
                                        prefixes.push_back(hostname);
                                }

                                delete[] hostname_array;
                        }

                        // print prefixes
                        for (std::list<std::string>::const_iterator iter = prefixes.begin(); iter != prefixes.end(); iter++)
                        {
                                if (iter == prefixes.begin())
                                {
                                        _stream << (*iter);
                                }
                                else
                                {
                                        _stream << " " << (*iter);
                                }
                        }

                        if (!prefixes.empty())
                        {
                                _stream << ": ";
                        }

                        _stream << log.rdbuf() << std::endl;
                }
        }

        Logger::LoggerOutput::LoggerOutput(std::ostream &stream, const unsigned char logmask, const unsigned char options)
         : _stream(stream), _level(logmask), _options(options)
        {
        }

        Logger::LoggerOutput::~LoggerOutput()
        {
        }
}

---