Logger.h

Go to the documentation of this file.

// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 4; -*-
// vim: set shiftwidth=4 softtabstop=4 expandtab:
/*
 ********************************************************************
 ** NIDAS: NCAR In-situ Data Acquistion Software
 **
 ** 2006, Copyright University Corporation for Atmospheric Research
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
 ** the Free Software Foundation; either version 2 of the License, or
 ** (at your option) any later version.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU General Public License for more details.
 **
 ** The LICENSE.txt file accompanying this software contains
 ** a copy of the GNU General Public License. If it is not found,
 ** write to the Free Software Foundation, Inc.,
 ** 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 **
 ********************************************************************
*/
 
#ifndef NIDAS_UTIL_LOGGER_H_
#define NIDAS_UTIL_LOGGER_H_
 
#include <syslog.h>
#include <pthread.h> // pthread_id
#include <string>
#include <sstream>
#include <vector>
#include <map>
 
// define to thread_local to use C++11 thread_local storage for static
// LogContext instances declared by the logging macros.  if every LogContext
// is in thread-local storage, then the active flag is only (almost) accessed
// by one thread.  if another thread changes the current LogScheme and
// reconfigures all the log points, then that would be flagged by a
// concurrency checker. however, in all nidas programs so far, the log scheme
// is setup once at startup and never changed.
#ifndef NIDAS_LOGGER_THREADLOCAL
#define NIDAS_LOGGER_THREADLOCAL thread_local
#endif
 
// define to non-zero to guard all access to the LogContext active flag. this
// is one way to prevent multiple threads from accessing the active flag of
// the same LogContext instance, but it incurs the overhead (unmeasured) of
// locking the logging mutex on every test of the active flag.  it is here for
// historical record but deprecated in favor of thread_local.
#ifndef NIDAS_LOGGER_GUARD_ACTIVE
#define NIDAS_LOGGER_GUARD_ACTIVE 0
#endif
 
namespace nidas { namespace util {
 
    const int LOGGER_EMERG = LOG_EMERG;
    const int LOGGER_EMERGENCY = LOG_EMERG;
    const int LOGGER_ALERT = LOG_ALERT;
    const int LOGGER_CRIT = LOG_CRIT;
    const int LOGGER_CRITICAL = LOG_CRIT;
    const int LOGGER_ERROR = LOG_ERR;
    const int LOGGER_ERR = LOG_ERR;
    const int LOGGER_PROBLEM = LOG_ERR;
    const int LOGGER_WARNING = LOG_WARNING;
    const int LOGGER_NOTICE = LOG_NOTICE;
    const int LOGGER_INFO = LOG_INFO;
    const int LOGGER_DEBUG = LOG_DEBUG;
    const int LOGGER_VERBOSE = LOG_DEBUG+1;
    const int LOGGER_NONE = LOG_EMERG-1;
#undef  LOG_EMERG
#undef  LOG_ALERT
#undef  LOG_CRIT
#undef  LOG_ERR
#undef  LOG_WARNING
#undef  LOG_NOTICE
#undef  LOG_INFO
#undef  LOG_DEBUG
 
#define LOG_CONTEXT(LEVEL) \
    nidas::util::LEVEL, __FILE__, __PRETTY_FUNCTION__, __LINE__
 
#define LOG_STATIC_CONTEXT(LEVEL) \
    nidas::util::LEVEL, __FILE__, "file_static_scope", __LINE__
 
    // Redefine the log levels to be a full LogContext instance.
#define LOG_EMERG LOG_CONTEXT(LOGGER_EMERG)
#define LOG_ALERT LOG_CONTEXT(LOGGER_ALERT)
#define LOG_CRIT LOG_CONTEXT(LOGGER_CRIT)
#define LOG_ERR LOG_CONTEXT(LOGGER_ERR)
#define LOG_WARNING LOG_CONTEXT(LOGGER_WARNING)
#define LOG_NOTICE LOG_CONTEXT(LOGGER_NOTICE)
#define LOG_INFO LOG_CONTEXT(LOGGER_INFO)
#define LOG_DEBUG LOG_CONTEXT(LOGGER_DEBUG)
#define LOG_VERBOSE LOG_CONTEXT(LOGGER_VERBOSE)
 
#define LOGGER_LOGPOINT(LEVEL,TAGS,MSG)                                 \
    do {                                                                \
        nidas::util::Logger::init();                                    \
        static NIDAS_LOGGER_THREADLOCAL nidas::util::LogContext logctxt \
            (nidas::util::LEVEL, __FILE__,__PRETTY_FUNCTION__,          \
             __LINE__,TAGS);                                            \
        if (logctxt.active())                                           \
            logctxt.log(nidas::util::LogMessage().format MSG); }        \
    while (0)
 
#define ELOG(MSG) LOGGER_LOGPOINT(LOGGER_EMERG,"",MSG)
#define ALOG(MSG) LOGGER_LOGPOINT(LOGGER_ALERT,"",MSG)
#define CLOG(MSG) LOGGER_LOGPOINT(LOGGER_CRITICAL,"",MSG)
#define PLOG(MSG) LOGGER_LOGPOINT(LOGGER_ERR,"",MSG) // For Problem, as in Error
#define WLOG(MSG) LOGGER_LOGPOINT(LOGGER_WARNING,"",MSG)
#define NLOG(MSG) LOGGER_LOGPOINT(LOGGER_NOTICE,"",MSG)
#define ILOG(MSG) LOGGER_LOGPOINT(LOGGER_INFO,"",MSG)
#define DLOG(MSG) LOGGER_LOGPOINT(LOGGER_DEBUG,"",MSG)
#define VLOG(MSG) LOGGER_LOGPOINT(LOGGER_VERBOSE,"",MSG)
 
#define ELOGT(TAGS,MSG) LOGGER_LOGPOINT(LOGGER_EMERG,TAGS,MSG)
#define ALOGT(TAGS,MSG) LOGGER_LOGPOINT(LOGGER_ALERT,TAGS,MSG)
#define CLOGT(TAGS,MSG) LOGGER_LOGPOINT(LOGGER_CRITICAL,TAGS,MSG)
#define PLOGT(TAGS,MSG) LOGGER_LOGPOINT(LOGGER_ERR,TAGS,MSG) // For Problem, as in Error
#define WLOGT(TAGS,MSG) LOGGER_LOGPOINT(LOGGER_WARNING,TAGS,MSG)
#define NLOGT(TAGS,MSG) LOGGER_LOGPOINT(LOGGER_NOTICE,TAGS,MSG)
#define ILOGT(TAGS,MSG) LOGGER_LOGPOINT(LOGGER_INFO,TAGS,MSG)
#define DLOGT(TAGS,MSG) LOGGER_LOGPOINT(LOGGER_DEBUG,TAGS,MSG)
#define VLOGT(TAGS,MSG) LOGGER_LOGPOINT(LOGGER_VERBOSE,TAGS,MSG)
    class Logger;
    class LoggerPrivate;
    class LogMessage;
 
    int
    stringToLogLevel(const std::string& slevel);
 
    std::string
    logLevelToString(int);
 
    class LogContextState
    {
    public:
 
        LogContextState(int level, const char* file, const char* function,
                        int line, const char* tags = 0);
 
        inline bool
        active() const
        {
            return _active;
        }
 
        void
        setActive(bool active)
        {
            _active = active;
        }
 
        const char*
        filename() const
        {
            return _file;
        }
 
        const char*
        function() const
        {
            return _function;
        }
 
        int
        line() const
        {
            return _line;
        }
 
        int
        level() const
        {
            return _level;
        }
 
        const char*
        tags() const
        {
            return _tags;
        }
 
        std::string
        threadName() const;
 
        std::string
        levelName() const
        {
            return logLevelToString(_level);
        }
 
        inline void
        log(const std::string& msg) const;
 
        inline LogMessage
        log() const;
 
    protected:
        int _level;
        const char* _file;
        const char* _function;
        int _line;
        const char* _tags;
 
        bool _active;
 
        pthread_t _threadId;
    };
 
    class LogContext: public LogContextState
    {
    public:
 
        LogContext (int level, const char* file, const char* function, int line,
                    const char* tags = 0);
 
#if NIDAS_LOGGER_GUARD_ACTIVE
        bool
        active() const;
 
        void
        setActive(bool active);
#endif
 
        ~LogContext();
 
        LogContext(const LogContext&) = delete;
        LogContext& operator=(const LogContext&) = delete;
 
        friend class nidas::util::Logger;
        friend class nidas::util::LoggerPrivate;
    };
 
 
    class LogConfig
    {
    public:
 
        std::string filename_match;
 
        std::string function_match;
 
        std::string tag_match;
 
        int line;
 
        int level;
 
        bool activate;
 
        bool
        matches(const LogContext& lc) const;
 
        LogConfig&
        parse(const std::string& text);
 
        LogConfig(const std::string& text = "");
    };
 
 
    class LogScheme
    {
    public:
 
        enum LogField 
        {
            NoneField = 0,
            ThreadField = 1, 
            FunctionField = 2, 
            FileField = 4, 
            LevelField = 8,
            MessageField = 16,
            TimeField = 32,
            AllFields = 63
        };
 
        typedef std::vector<LogConfig> log_configs_v;
 
        static LogField
        stringToField(const std::string& s);
 
        static std::string
        fieldToString(LogScheme::LogField lf);
 
        explicit
        LogScheme(const std::string& name = "");
 
        LogScheme&
        setName(const std::string& name)
        {
            if (name.length() > 0)
                _name = name;
            return *this;
        }
 
        const std::string&
        getName() const
        {
            return _name;
        }
 
        LogScheme&
        clearConfigs();
 
        LogScheme&
        addConfig(const LogConfig& lc);
 
        LogScheme&
        addConfig(const std::string& config);
 
        LogScheme&
        addFallback(const LogConfig& lc);
 
        LogScheme&
        addFallback(const std::string& config);
 
        log_configs_v
        getConfigs();
 
        int
        logLevel();
 
        LogScheme&
        setShowFields(const std::vector<LogField>& fields);
 
        LogScheme&
        setShowFields(const std::string& fields);
 
        std::string
        getShowFieldsString () const;
 
        bool
        parseParameter(const std::string& text);
 
        void
        setParameter(const std::string& name, const std::string& value);
 
        std::string
        getParameter(const std::string& name, const std::string& dvalue="");
 
        template <typename T>
        T
        getParameterT(const std::string& name, const T& dvalue = T());
 
        std::string
        getEnvParameter(const std::string& name, const std::string& dvalue="");
 
        void
        showLogPoints(bool show);
 
        bool
        getShowLogPoints()
        {
            return _showlogpoints;
        }
 
    private:
 
        void
        show_log_point(const LogContextState& lp) const;
 
        std::string _name;
        log_configs_v log_configs;
        std::vector<LogField> log_fields;
        std::map<std::string, std::string> _parameters;
        bool _showlogpoints;
        bool _fallbacks;
 
        friend class nidas::util::LoggerPrivate;
        friend class nidas::util::Logger;
        friend class nidas::util::LogContext;
    };
 
 
    class LogMessage
    {
    public:
        LogMessage(const std::string& s = "") :
            msg(),
            _log_context(0)
        {
            msg << s;
        }
 
        LogMessage(const LogContextState* lp, const std::string& s = "") :
            msg(),
            _log_context(lp)
        {
            msg << s;
        }
 
        LogMessage(const LogMessage& right) :
            msg(),
            _log_context(right._log_context)
        {
            msg << right.msg.str();
        }
 
        LogMessage&
        operator=(const LogMessage& right)
        {
            msg << right.msg.str();
            _log_context = right._log_context;
            return *this;
        }
 
        LogMessage&
        format(const char *fmt, ...);
 
        std::string
        getMessage() const
        {
            return msg.str();
        }
 
        operator std::string () const
        {
            return msg.str();
        }
 
        template <typename T>
        LogMessage&
        operator<< (const T& t);
 
        ~LogMessage()
        {
            log();
        }
 
        inline std::streampos
        length()
        {
            return msg.tellp();
        }
 
        void
        log()
        {
            if (_log_context && length() > 0)
            {
                _log_context->log(*this);
            }
            msg.str("");
            msg.clear();
        }
 
    private:
        std::ostringstream msg;
        const LogContextState* _log_context;
    };
 
 
    template <typename T>
    inline
    LogMessage&
    LogMessage::
    operator<< (const T& t)
    {
        msg << t;
        return *this;
    }
 
 
    inline LogMessage&
    endlog(LogMessage& logmsg)
    {
        logmsg.log();
        return logmsg;
    }
 
    inline LogMessage&
    operator<<(LogMessage& logmsg, LogMessage& (*op)(LogMessage&))
    {
        return (*op)(logmsg);
    }
 
    class Logger {
    protected:
        Logger(const std::string& ident, int logopt, int facility,
               const char *TZ = 0);
        Logger(std::ostream* );
        Logger();
 
    public:
 
        static Logger* 
        createInstance(const std::string& ident, int logopt, int facility,
                       const char *TZ = 0);
 
        static Logger* createInstance(std::ostream* out = 0);
 
        static Logger* getInstance();
 
        static void
        destroyInstance();
 
        static void
        init();
 
        void
        log(int severity, const char* file, const char* fn,
            int line, const char *fmt, ...);
 
        void
        msg(const LogContextState& lc, const std::string& msg);
 
        inline void
        msg(const LogContextState& lc, const LogMessage& m)
        {
            msg (lc, m.getMessage());
        }
 
        static void
        setScheme(const std::string& name);
 
        static void
        setScheme(const LogScheme& scheme);
 
        static void
        updateScheme(const LogScheme& scheme);
 
        static LogScheme
        getScheme(const std::string& name);
 
        static LogScheme
        getScheme();
 
        static bool
        knownScheme(const std::string& name);
 
        static void
        clearSchemes();
 
    protected:
        void setTZ(const char* val);
 
        static Logger* _instance;
 
        std::ostream* _output;
        bool _syslogit;
 
        char* _loggerTZ;
        char* _saveTZ;
        char* _ident;
 
    private:
 
        static Logger*
        get_instance_locked(std::ostream* out = 0);
 
        friend class nidas::util::LogContext;
        friend class nidas::util::LogScheme;
        friend class nidas::util::LoggerPrivate;
 
        ~Logger();
 
        Logger(const Logger&);
 
        Logger& operator=(const Logger&);
    };
 
    inline void
    LogContextState::
    log(const std::string& msg) const
    {
        Logger::getInstance()->msg(*this, msg);
    }
 
    inline LogMessage
    LogContextState::
    log() const
    {
        return LogMessage(this);
    }
 
    template <typename T>
    T
    LogScheme::
    getParameterT(const std::string& name, const T& dvalue)
    {
        // A rudimentary implementation which converts strings
        // to the given type.
        T value;
        std::istringstream text(getParameter(name));
        text >> value;
        if (text.fail())
            value = dvalue;
        return value;
    }
 
}}  // namespace nidas namespace util
 
#endif