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 "ThreadSupport.h"

#include <cstdarg>
#include <syslog.h>

#include <iostream>
#include <string>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <map>

#if !defined(SVR4) && ( defined(__GNUC__) && __GNUC__ < 2)
#include <varargs.h>
#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 {                                                                \
        static 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 Mutex;

    class LogContext
    {
    public:

        LogContext (int level, const char* file, const char* function, int line,
                    const char* tags = 0);

        ~LogContext();

        bool
        active() const
        {
            return _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;

    private:
        int _level;
        const char* _file;
        const char* _function;
        int _line;
        const char* _tags;

        bool _active;

        pthread_t _threadId;

        friend class nidas::util::Logger;
        friend class nidas::util::LoggerPrivate;

        LogContext (const LogContext&);

        LogContext& operator= (const LogContext&);
    };


    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(LogContext& lp);

        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 LogContext* 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 LogContext* _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();

#if defined(SVR4) || ( defined(__GNUC__) && __GNUC__ > 1 )
        void
        log(int severity, const char* file, const char* fn,
            int line, const char *fmt, ...);
#elif defined(__GNUC__)
        void
        log(...);
#else
        void
        log(va_alist);
#endif

        void
        msg(const LogContext& lc, const std::string& msg);

        inline void
        msg(const LogContext& 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:

        void
        msg_locked(const nidas::util::LogContext& lc, const std::string& msg);

        static Logger*
        get_instance_locked(std::ostream* out = 0);

        friend class nidas::util::LogContext;
        friend class nidas::util::LogScheme;

        static nidas::util::Mutex mutex;

        ~Logger();

        Logger(const Logger&);

        Logger& operator=(const Logger&);
    };

    inline void
    LogContext::
    log(const std::string& msg) const
    {
        Logger::getInstance()->msg (*this, msg);
    }

    inline LogMessage
    LogContext::
    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