ibrcommon/ibrcommon/Logger.h

Go to the documentation of this file.

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

#ifndef LOGGER_H_
#define LOGGER_H_

//#define __IBRCOMMON_MULTITHREADED__

#include <ibrcommon/thread/Queue.h>
#include <ibrcommon/thread/Thread.h>
#include <iostream>
#include <sstream>
#include <list>

#define IBRCOMMON_LOGGER_LEVEL ibrcommon::Logger::getVerbosity()
#define IBRCOMMON_LOGGER(level) { ibrcommon::Logger log = ibrcommon::Logger::level(); log
#define IBRCOMMON_LOGGER_DEBUG(verbosity) if (ibrcommon::Logger::getVerbosity() >= verbosity) { ibrcommon::Logger log = ibrcommon::Logger::debug(verbosity); log
#define IBRCOMMON_LOGGER_ENDL std::flush; log << ibrcommon::Logger::endl; }

namespace ibrcommon
{
        class Logger : public std::stringstream
        {
        public:
                enum LogOptions
                {
                        LOG_NONE =              0,
                        LOG_DATETIME =  1 << 0, /* print date/time on log messages */
                        LOG_HOSTNAME =  1 << 1, /* print hostname on log messages */
                        LOG_LEVEL =             1 << 2, /* print the log level on log messages */
                        LOG_TIMESTAMP = 1 << 3  /* print timestamp on log messages */
                };

                enum LogLevel
                {
                        LOGGER_EMERG =          1 << 0, /* system is unusable */
                        LOGGER_ALERT =          1 << 1, /* action must be taken immediately */
                        LOGGER_CRIT =           1 << 2, /* critical conditions */
                        LOGGER_ERR =            1 << 3, /* error conditions */
                        LOGGER_WARNING =        1 << 4, /* warning conditions */
                        LOGGER_NOTICE =         1 << 5, /* normal but significant condition */
                        LOGGER_INFO =           1 << 6, /* informational */
                        LOGGER_DEBUG =          1 << 7, /* debug-level messages */
                        LOGGER_ALL =            0xff
                };

                Logger(const Logger&);
                virtual ~Logger();

                static Logger emergency();
                static Logger alert();
                static Logger critical();
                static Logger error();
                static Logger warning();
                static Logger notice();
                static Logger info();
                static Logger debug(int verbosity);

                static void setVerbosity(const int verbosity);

                static int getVerbosity();

                static void addStream(std::ostream &stream, const unsigned char logmask = LOGGER_INFO, const unsigned char options = LOG_NONE);

                static void enableSyslog(const char *name, int option, int facility, const unsigned char logmask = LOGGER_INFO);

                void flush();

                class endl_flag
                {
                public:
                        endl_flag() {};
                        ~endl_flag() {};
                };

                static endl_flag endl;

                static void enableAsync();

                static void stop();

                friend
                Logger& operator<<(Logger &logger, endl_flag&)
                {
                        if (Logger::_use_queue)
                        {
                                Logger::_queue.push(logger);
                        }
                        else
                        {
                                logger.flush();
                        }
                        return logger;
                }
                
        protected:
                static ibrcommon::Queue<Logger> _queue;

        private:
                Logger(LogLevel level, int debug_verbosity = 0);

                class LoggerOutput
                {
                public:
                        LoggerOutput(std::ostream &stream, const unsigned char logmask, const unsigned char options);
                        ~LoggerOutput();

                        void log(const Logger &log);

                        std::ostream &_stream;
                        unsigned char _level;
                        unsigned char _options;
                };
                
                class LogWriter : public ibrcommon::JoinableThread
                {
                public:
                        LogWriter();
                        virtual ~LogWriter();

                protected:
                        void flush();
                        void run();
                        bool __cancellation();
                };

                LogLevel _level;
                int _debug_verbosity;

                static bool _use_queue;
                static LogWriter _logwriter;
                static std::list<LoggerOutput> _logger;
                static int _verbosity;
                static bool _syslog;
                static unsigned char _syslog_mask;

                struct timeval _logtime;
        };
}

#endif /* LOGGER_H_ */