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 <stack>
#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_SET_LVL(logger, level) \
    lsst::log::Log::setLevel(logger, level)

#define LOG_GET_LVL(logger) \
    lsst::log::Log::getLevel(logger)

#define LOG_CHECK_LVL(logger, level) \
    lsst::log::Log::isEnabledFor(logger, level)

#define LOG_CHECK_TRACE() \
    LOG4CXX_UNLIKELY(lsst::log::Log::defaultLogger->isTraceEnabled())

#define LOG_CHECK_DEBUG() \
    LOG4CXX_UNLIKELY(lsst::log::Log::defaultLogger->isDebugEnabled())

#define LOG_CHECK_INFO() \
        lsst::log::Log::defaultLogger->isInfoEnabled()

#define LOG_CHECK_WARN() \
        lsst::log::Log::defaultLogger->isWarnEnabled()

#define LOG_CHECK_ERROR() \
        lsst::log::Log::defaultLogger->isErrorEnabled()

#define LOG_CHECK_FATAL() \
        lsst::log::Log::defaultLogger->isFatalEnabled()

#define LOGF(logger, level, message) \
    do { if (lsst::log::Log::isEnabledFor(logger, level)) { \
        lsst::log::detail::LogFormatter fmter_; \
        lsst::log::Log::getLogger(logger)->forcedLog( \
            log4cxx::Level::toLevel(level), (fmter_ % message).str(), \
            LOG4CXX_LOCATION); } \
    } while (false)

#define LOGF_TRACE(message) \
    do { if (LOG4CXX_UNLIKELY(lsst::log::Log::defaultLogger->isTraceEnabled())) { \
        lsst::log::detail::LogFormatter fmter_; \
        lsst::log::Log::defaultLogger->forcedLog( \
            log4cxx::Level::getTrace(), (fmter_ % message).str(), \
            LOG4CXX_LOCATION); } \
    } while (false)

#define LOGF_DEBUG(message) \
    do { if (LOG4CXX_UNLIKELY(lsst::log::Log::defaultLogger->isDebugEnabled())) { \
        lsst::log::detail::LogFormatter fmter_; \
        lsst::log::Log::defaultLogger->forcedLog( \
            log4cxx::Level::getDebug(), (fmter_ % message).str(), \
            LOG4CXX_LOCATION); } \
    } while (false)

#define LOGF_INFO(message) \
    do { if (lsst::log::Log::defaultLogger->isInfoEnabled()) { \
        lsst::log::detail::LogFormatter fmter_; \
        lsst::log::Log::defaultLogger->forcedLog( \
            log4cxx::Level::getInfo(), (fmter_ % message).str(), \
            LOG4CXX_LOCATION); } \
    } while (false)

#define LOGF_WARN(message) \
    do { if (lsst::log::Log::defaultLogger->isWarnEnabled()) { \
        lsst::log::detail::LogFormatter fmter_; \
        lsst::log::Log::defaultLogger->forcedLog( \
            log4cxx::Level::getWarn(), (fmter_ % message).str(), \
            LOG4CXX_LOCATION); } \
    } while (false)

#define LOGF_ERROR(message) \
    do { if (lsst::log::Log::defaultLogger->isErrorEnabled()) { \
        lsst::log::detail::LogFormatter fmter_; \
        lsst::log::Log::defaultLogger->forcedLog( \
            log4cxx::Level::getError(), (fmter_ % message).str(), \
            LOG4CXX_LOCATION); } \
    } while (false)

#define LOGF_FATAL(message) \
    do { if (lsst::log::Log::defaultLogger->isFatalEnabled()) { \
        lsst::log::detail::LogFormatter fmter_; \
        lsst::log::Log::defaultLogger->forcedLog( \
            log4cxx::Level::getFatal(), (fmter_ % message).str(), \
            LOG4CXX_LOCATION); } \
    } while (false)

#define LOG(logger, level, message...) \
    do { if (lsst::log::Log::isEnabledFor(logger, level)) { \
        lsst::log::Log::log(logger, log4cxx::Level::toLevel(level), \
        __BASE_FILE__, __PRETTY_FUNCTION__, __LINE__, message); } \
    } while (false)

#define LOG_TRACE(message...) \
    do { if (LOG4CXX_UNLIKELY(lsst::log::Log::defaultLogger->isTraceEnabled())) { \
        lsst::log::Log::log(lsst::log::Log::defaultLogger, \
            log4cxx::Level::getTrace(), __BASE_FILE__, __PRETTY_FUNCTION__, \
            __LINE__, message); } \
    } while (false)

#define LOG_DEBUG(message...) \
    do { if (LOG4CXX_UNLIKELY(lsst::log::Log::defaultLogger->isDebugEnabled())) { \
        lsst::log::Log::log(lsst::log::Log::defaultLogger, \
            log4cxx::Level::getDebug(), __BASE_FILE__, __PRETTY_FUNCTION__, \
            __LINE__, message); } \
    } while (false)

#define LOG_INFO(message...) \
    do { if (lsst::log::Log::defaultLogger->isInfoEnabled()) { \
        lsst::log::Log::log(lsst::log::Log::defaultLogger, \
            log4cxx::Level::getInfo(), __BASE_FILE__, __PRETTY_FUNCTION__, \
            __LINE__, message); } \
    } while (false)

#define LOG_WARN(message...) \
    do { if (lsst::log::Log::defaultLogger->isWarnEnabled()) { \
        lsst::log::Log::log(lsst::log::Log::defaultLogger, \
            log4cxx::Level::getWarn(), __BASE_FILE__, __PRETTY_FUNCTION__, \
            __LINE__, message); } \
    } while (false)

#define LOG_ERROR(message...) \
    do { if (lsst::log::Log::defaultLogger->isErrorEnabled()) { \
        lsst::log::Log::log(lsst::log::Log::defaultLogger, \
            log4cxx::Level::getError(), __BASE_FILE__, __PRETTY_FUNCTION__, \
            __LINE__, message); } \
    } while (false)

#define LOG_FATAL(message...) \
    do { if (lsst::log::Log::defaultLogger->isFatalEnabled()) { \
        lsst::log::Log::log(lsst::log::Log::defaultLogger, \
            log4cxx::Level::getFatal(), __BASE_FILE__, __PRETTY_FUNCTION__, \
            __LINE__, 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 log4cxx::LoggerPtr
#define LOG_CTX lsst::log::LogContext

namespace lsst {
namespace log {

namespace detail {
class LogFormatter {
public:

    LogFormatter() : _fmter(0) {}

    ~LogFormatter() {
      delete _fmter;
    }

    template <typename T>
    boost::format& operator %(T fmt) {
        // we do not delete old _fmtiter because this method
        // will not be called more than once per instance
        _fmter = new boost::format(fmt);
        return *_fmter;
    }

private:
    boost::format* _fmter;

    // instances cannot be copied
    LogFormatter(const LogFormatter&);
    LogFormatter& operator=(const LogFormatter&);
};

} // namespace detail

class Log {
public:
    static log4cxx::LoggerPtr defaultLogger;
    static void initLog(void);
    static void configure(void);
    static void configure(std::string const& filename);
    static void configure_prop(std::string const& properties);
    static std::string getDefaultLoggerName(void);
    static log4cxx::LoggerPtr getLogger(log4cxx::LoggerPtr logger);
    static log4cxx::LoggerPtr getLogger(std::string const& loggername);
    static void pushContext(std::string const& name);
    static void popContext(void);
    static void MDC(std::string const& key, std::string const& value);
    static void MDCRemove(std::string const& key);
    static void setLevel(log4cxx::LoggerPtr logger, int level);
    static void setLevel(std::string const& loggername, int level);
    static int getLevel(log4cxx::LoggerPtr logger);
    static int getLevel(std::string const& loggername);
    static bool isEnabledFor(log4cxx::LoggerPtr logger, int level);
    static bool isEnabledFor(std::string const& loggername, int level);
    static void vlog(log4cxx::LoggerPtr logger, log4cxx::LevelPtr level,
                     std::string const& filename, std::string const& funcname,
                     unsigned int lineno, char const* fmt, va_list args);
    static void log(std::string const& loggername, log4cxx::LevelPtr level,
                    std::string const& filename, std::string const& funcname,
                    unsigned int lineno, char const* fmt, ...);
    static void log(log4cxx::LoggerPtr logger, log4cxx::LevelPtr level,
                    std::string const& filename, std::string const& funcname,
                    unsigned int lineno, char const* fmt, ...);
};

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&);
};


}} // namespace lsst::log

#endif // LSST_LOG_LOG_H