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>
#include <vector>

// 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_DEFAULT_NAME() lsst::log::Log::getDefaultLoggerName()

#define LOG_GET(logger) lsst::log::Log::getLogger(logger)

#define LOG_PUSHCTX(name) lsst::log::Log::pushContext(name)

#define LOG_POPCTX() lsst::log::Log::popContext()

#define LOG_MDC(key, value) lsst::log::Log::MDC(key, value)

#define LOG_MDC_REMOVE(key) lsst::log::Log::MDCRemove(key)

#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
#define LOG_CTX lsst::log::LogContext

namespace lsst {
namespace log {

class Log {
public:

    /***
     *  Default constructor creates an instance of "current" logger.
     *
     *  Initially current logger is the same as root logger, but
     *  current can be changed via pushContext()/popContext().
     */
    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;

    static Log getDefaultLogger() { return Log(_defaultLogger()); }
    static std::string getDefaultLoggerName();

    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 void pushContext(std::string const& name);
    static void popContext();
    static void 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(log4cxx::LoggerPtr const& newDefault=log4cxx::LoggerPtr());

    Log(log4cxx::LoggerPtr const& logger) : Log() { _logger = logger; }

    log4cxx::LoggerPtr _logger;
};

class LogContext {
public:
    explicit LogContext(std::string const& name) {
        Log::pushContext(name);
    }
    ~LogContext() {
        Log::popContext();
    }

private:
    // cannot copy instances
    LogContext(const LogContext&);
    LogContext& operator=(const LogContext&);
};


unsigned lwpID();

}} // namespace lsst::log

#endif // LSST_LOG_LOG_H