Log.h

Go to the documentation of this file.

/*
 * LSST Data Management System
 * Copyright 2013-2014 LSST Corporation.
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * 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 3 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.
 *
 * You should have received a copy of the LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
 
#ifndef LSST_LOG_LOG_H
#define LSST_LOG_LOG_H
 
 
// System headers
#include <functional>
#include <sstream>
#include <stdarg.h>
#include <string>
 
// Third-party headers
#include <log4cxx/logger.h>
#include <boost/format.hpp>
 
#define LOG_CONFIG(filename) lsst::log::Log::configure(filename)
 
#define LOG_CONFIG_PROP(string) lsst::log::Log::configure_prop(string)
 
#define LOG_GET(logger) lsst::log::Log::getLogger(logger)
 
#define LOG_GET_CHILD(logger, suffix) lsst::log::Log::getLogger(logger).getChild(suffix)
 
#define LOG_MDC(key, value) lsst::log::Log::MDC(key, value)
 
#define LOG_MDC_REMOVE(key) lsst::log::Log::MDCRemove(key)
 
// These two macros generate unique variable name using __COUNTER__ built-in
// macro. Two levels of calls is needed to use __COUNTER__ macro value instead
// of the macro name in concatenation.
#define LOG_CONCAT_IMPL(a, b) a ## b
#define LOG_CONCAT_IMPL2(a, b) LOG_CONCAT_IMPL(a, b)
#define LOG_MDC_SCOPE(key, value) lsst::log::LogMDCScope LOG_CONCAT_IMPL2(_log_mdc_scope_, __COUNTER__)(key, value);
 
#define LOG_MDC_INIT(func) lsst::log::Log::MDCRegisterInit(std::function<void()>(func))
 
#define LOG_SET_LVL(logger, level) \
    lsst::log::Log::getLogger(logger).setLevel(level)
 
#define LOG_GET_LVL(logger) \
    lsst::log::Log::getLogger(logger).getLevel()
 
#define LOG_GETEFF_LVL(logger) \
    lsst::log::Log::getLogger(logger).getEffectiveLevel()
 
#define LOG_CHECK_LVL(logger, level) \
    lsst::log::Log::getLogger(logger).isEnabledFor(level)
 
#define LOG_CHECK_TRACE() \
    LOG4CXX_UNLIKELY(lsst::log::Log::getDefaultLogger().isTraceEnabled())
 
#define LOG_CHECK_DEBUG() \
    LOG4CXX_UNLIKELY(lsst::log::Log::getDefaultLogger().isDebugEnabled())
 
#define LOG_CHECK_INFO() \
        lsst::log::Log::getDefaultLogger().isInfoEnabled()
 
#define LOG_CHECK_WARN() \
        lsst::log::Log::getDefaultLogger().isWarnEnabled()
 
#define LOG_CHECK_ERROR() \
        lsst::log::Log::getDefaultLogger().isErrorEnabled()
 
#define LOG_CHECK_FATAL() \
        lsst::log::Log::getDefaultLogger().isFatalEnabled()
 
#define LOG(logger, level, message...) \
    do { \
        lsst::log::Log log(lsst::log::Log::getLogger(logger)); \
        if (log.isEnabledFor(level)) { \
            log.log(log4cxx::Level::toLevel(level), LOG4CXX_LOCATION, message); } \
    } while (false)
 
#define LOG_TRACE(message...) \
    do { \
        lsst::log::Log log; \
        if (LOG4CXX_UNLIKELY(log.isTraceEnabled())) { \
            log.log(log4cxx::Level::getTrace(), LOG4CXX_LOCATION, message); } \
    } while (false)
 
#define LOG_DEBUG(message...) \
    do { \
        lsst::log::Log log; \
        if (LOG4CXX_UNLIKELY(log.isDebugEnabled())) { \
            log.log(log4cxx::Level::getDebug(), LOG4CXX_LOCATION, message); } \
    } while (false)
 
#define LOG_INFO(message...) \
    do { \
        lsst::log::Log log; \
        if (log.isInfoEnabled()) { \
            log.log(log4cxx::Level::getInfo(), LOG4CXX_LOCATION, message); } \
    } while (false)
 
#define LOG_WARN(message...) \
    do { \
        lsst::log::Log log; \
        if (log.isWarnEnabled()) { \
            log.log(log4cxx::Level::getWarn(), LOG4CXX_LOCATION, message); } \
    } while (false)
 
#define LOG_ERROR(message...) \
    do { \
        lsst::log::Log log; \
        if (log.isErrorEnabled()) { \
            log.log(log4cxx::Level::getError(), LOG4CXX_LOCATION, message); } \
    } while (false)
 
#define LOG_FATAL(message...) \
    do { \
        lsst::log::Log log; \
        if (log.isFatalEnabled()) { \
            log.log(log4cxx::Level::getFatal(), LOG4CXX_LOCATION, message); } \
    } while (false)
 
 
// small internal utility macro, not for regular clients
#define LOG_MESSAGE_VIA_STREAM_(logger, level, message) \
    std::ostringstream stream_; \
    stream_ << message; \
    logger.logMsg(level, LOG4CXX_LOCATION, stream_.str())
 
#define LOGS(logger, level, message) \
    do { \
        lsst::log::Log log(lsst::log::Log::getLogger(logger)); \
        if (log.isEnabledFor(level)) { \
            LOG_MESSAGE_VIA_STREAM_(log, log4cxx::Level::toLevel(level), message); \
        } \
    } while (false)
 
#define LOGS_TRACE(message) \
    do { \
        lsst::log::Log log; \
        if (LOG4CXX_UNLIKELY(log.isTraceEnabled())) { \
            LOG_MESSAGE_VIA_STREAM_(log, log4cxx::Level::getTrace(), message); \
        } \
    } while (false)
 
#define LOGS_DEBUG(message) \
    do { \
        lsst::log::Log log; \
        if (LOG4CXX_UNLIKELY(log.isDebugEnabled())) { \
            LOG_MESSAGE_VIA_STREAM_(log, log4cxx::Level::getDebug(), message); \
        } \
    } while (false)
 
#define LOGS_INFO(message) \
    do { \
        lsst::log::Log log; \
        if (log.isInfoEnabled()) { \
            LOG_MESSAGE_VIA_STREAM_(log, log4cxx::Level::getInfo(), message); \
        } \
    } while (false)
 
#define LOGS_WARN(message) \
    do { \
        lsst::log::Log log; \
        if (log.isWarnEnabled()) { \
            LOG_MESSAGE_VIA_STREAM_(log, log4cxx::Level::getWarn(), message); \
        } \
    } while (false)
 
#define LOGS_ERROR(message) \
    do { \
        lsst::log::Log log; \
        if (log.isErrorEnabled()) { \
            LOG_MESSAGE_VIA_STREAM_(log, log4cxx::Level::getError(), message); \
        } \
    } while (false)
 
#define LOGS_FATAL(message) \
    do { \
        lsst::log::Log log; \
        if (log.isFatalEnabled()) { \
            LOG_MESSAGE_VIA_STREAM_(log, log4cxx::Level::getFatal(), message); \
        } \
    } while (false)
 
#define LOGL_TRACE(logger, message...) \
    do { \
        lsst::log::Log log(lsst::log::Log::getLogger(logger)); \
        if (LOG4CXX_UNLIKELY(log.isTraceEnabled())) { \
            log.log(log4cxx::Level::getTrace(), LOG4CXX_LOCATION, message);\
        } \
    } while (false)
 
#define LOGL_DEBUG(logger, message...) \
    do { \
        lsst::log::Log log(lsst::log::Log::getLogger(logger)); \
        if (LOG4CXX_UNLIKELY(log.isDebugEnabled())) { \
            log.log(log4cxx::Level::getDebug(), LOG4CXX_LOCATION, message); \
        } \
    } while (false)
 
#define LOGL_INFO(logger, message...) \
    do { \
        lsst::log::Log log(lsst::log::Log::getLogger(logger)); \
        if (log.isInfoEnabled()) { \
            log.log(log4cxx::Level::getInfo(), LOG4CXX_LOCATION, message); \
        } \
    } while (false)
 
#define LOGL_WARN(logger, message...) \
    do { \
        lsst::log::Log log(lsst::log::Log::getLogger(logger)); \
        if (log.isWarnEnabled()) { \
            log.log(log4cxx::Level::getWarn(), LOG4CXX_LOCATION, message); \
        } \
    } while (false)
 
#define LOGL_ERROR(logger, message...) \
    do { \
        lsst::log::Log log(lsst::log::Log::getLogger(logger)); \
        if (log.isErrorEnabled()) { \
            log.log(log4cxx::Level::getError(), LOG4CXX_LOCATION, message); \
        } \
    } while (false)
 
#define LOGL_FATAL(logger, message...) \
    do { \
        lsst::log::Log log(lsst::log::Log::getLogger(logger)); \
        if (log.isFatalEnabled()) { \
            log.log(log4cxx::Level::getFatal(), LOG4CXX_LOCATION, message); \
        } \
    } while (false)
 
#define LOGLS_TRACE(logger, message) \
    do { \
        lsst::log::Log log(lsst::log::Log::getLogger(logger)); \
        if (LOG4CXX_UNLIKELY(log.isTraceEnabled())) { \
            LOG_MESSAGE_VIA_STREAM_(log, log4cxx::Level::getTrace(), message); \
        } \
    } while (false)
 
#define LOGLS_DEBUG(logger, message) \
    do { \
        lsst::log::Log log(lsst::log::Log::getLogger(logger)); \
        if (LOG4CXX_UNLIKELY(log.isDebugEnabled())) { \
            LOG_MESSAGE_VIA_STREAM_(log, log4cxx::Level::getDebug(), message); \
        } \
    } while (false)
 
#define LOGLS_INFO(logger, message) \
    do { \
        lsst::log::Log log(lsst::log::Log::getLogger(logger)); \
        if (log.isInfoEnabled()) { \
            LOG_MESSAGE_VIA_STREAM_(log, log4cxx::Level::getInfo(), message); \
        } \
    } while (false)
 
#define LOGLS_WARN(logger, message) \
    do { \
        lsst::log::Log log(lsst::log::Log::getLogger(logger)); \
        if (log.isWarnEnabled()) { \
            LOG_MESSAGE_VIA_STREAM_(log, log4cxx::Level::getWarn(), message); \
        } \
    } while (false)
 
#define LOGLS_ERROR(logger, message) \
    do { \
        lsst::log::Log log(lsst::log::Log::getLogger(logger)); \
        if (log.isErrorEnabled()) { \
            LOG_MESSAGE_VIA_STREAM_(log, log4cxx::Level::getError(), message); \
        } \
    } while (false)
 
#define LOGLS_FATAL(logger, message) \
    do { \
        lsst::log::Log log(lsst::log::Log::getLogger(logger)); \
        if (log.isFatalEnabled()) { \
            LOG_MESSAGE_VIA_STREAM_(log, log4cxx::Level::getFatal(), message); \
        } \
    } while (false)
 
#define LOG_LVL_TRACE static_cast<int>(log4cxx::Level::TRACE_INT)
#define LOG_LVL_DEBUG static_cast<int>(log4cxx::Level::DEBUG_INT)
#define LOG_LVL_INFO static_cast<int>(log4cxx::Level::INFO_INT)
#define LOG_LVL_WARN static_cast<int>(log4cxx::Level::WARN_INT)
#define LOG_LVL_ERROR static_cast<int>(log4cxx::Level::ERROR_INT)
#define LOG_LVL_FATAL static_cast<int>(log4cxx::Level::FATAL_INT)
 
#define LOG_LOGGER lsst::log::Log
 
namespace lsst {
namespace log {
 
class Log {
public:
 
    /***
     *  Default constructor creates an instance of root logger.
     */
    Log() : _logger(_defaultLogger()) { }
 
    bool isDebugEnabled() const { return _logger->isDebugEnabled(); }
    bool isErrorEnabled() const { return _logger->isErrorEnabled(); }
    bool isFatalEnabled() const { return _logger->isFatalEnabled(); }
    bool isInfoEnabled() const { return _logger->isInfoEnabled(); }
    bool isTraceEnabled() const { return _logger->isTraceEnabled(); }
    bool isWarnEnabled() const { return _logger->isWarnEnabled(); }
 
    std::string getName() const;
    void setLevel(int level);
    int getLevel() const;
    int getEffectiveLevel() const;
    bool isEnabledFor(int level) const;
 
    Log getChild(std::string const& suffix) const;
 
    static Log getDefaultLogger() { return Log(); }
 
    static void configure();
    static void configure(std::string const& filename);
    static void configure_prop(std::string const& properties);
 
    static Log getLogger(Log const& logger) { return logger; }
    static Log getLogger(std::string const& loggername);
 
    static std::string MDC(std::string const& key, std::string const& value);
    static void MDCRemove(std::string const& key);
    static int MDCRegisterInit(std::function<void()> function);
 
    void log(log4cxx::LevelPtr level,
             log4cxx::spi::LocationInfo const& location,
             char const* fmt, ...);
    void logMsg(log4cxx::LevelPtr level,
                log4cxx::spi::LocationInfo const& location,
                std::string const& msg);
 
private:
 
    static log4cxx::LoggerPtr const& _defaultLogger();
 
    Log(log4cxx::LoggerPtr const& logger) : Log() { _logger = logger; }
 
    log4cxx::LoggerPtr _logger;
};
 
class LogMDCScope {
public:
 
    LogMDCScope(std::string const& key, std::string const& value)
      : _key(key)
    {
        _oldValue = Log::MDC(key, value);
    }
 
    // no copy allowed
    LogMDCScope(LogMDCScope const&) = delete;
    LogMDCScope& operator=(LogMDCScope const&) = delete;
 
    LogMDCScope(LogMDCScope&& other) {
        _key = other._key;
        _oldValue = other._oldValue;
        other._key.clear();
    }
 
    LogMDCScope& operator=(LogMDCScope&& other) {
        if (not _key.empty()) {
            if (_oldValue.empty()) {
                Log::MDCRemove(_key);
            } else {
                Log::MDC(_key, _oldValue);
            }
        }
        _key = other._key;
        _oldValue = other._oldValue;
        other._key.clear();
        return *this;
    }
 
    ~LogMDCScope() {
        if (not _key.empty()) {
            if (_oldValue.empty()) {
                Log::MDCRemove(_key);
            } else {
                Log::MDC(_key, _oldValue);
            }
        }
    }
 
private:
    std::string _key;
    std::string _oldValue;
};
 
unsigned lwpID();
 
}} // namespace lsst::log
 
#endif // LSST_LOG_LOG_H