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_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;
    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