Logger.hpp

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                     _     _   _   _     __     _                     |
|                    | |   | | | \_/ |   /  \   | |                    |
|                    | |   | | | |_| |  / /\ \  | |                    |
|                    | |__ | | | | | | / ____ \ | |__                  |
|                    |____||_| |_| |_|/ /    \ \|____|                 |
|                                                                      |
|                             core library                             |
|                                                                      |
|                                         (C) SUSE Linux Products GmbH |
\----------------------------------------------------------------------/

  File:       Logger.hpp

  Author:     Marius Tomaschewski
  Maintainer: Marius Tomaschewski

/-*/
#ifndef LIMAL_LOGGER_HPP
#define LIMAL_LOGGER_HPP

#include  <blocxx/Array.hpp>
#include  <blocxx/String.hpp>
#include  <blocxx/StringStream.hpp>
#include  <blocxx/LogConfig.hpp>
#include  <blocxx/Logger.hpp>
#include  <blocxx/CommonFwd.hpp>
#include  <blocxx/LogAppender.hpp>
#include  <blocxx/AppenderLogger.hpp>
#include  <limal/config.h>


#define LIMAL_LOG(logger, level, message)                         \
do                                                                \
{                                                                 \
        int err = errno;                                          \
        if( (logger).isEnabledFor(level))                         \
        {                                                         \
                (logger).logMessage((level), (message),           \
                                    __FILE__, __LINE__,           \
                         BLOCXX_LOGGER_PRETTY_FUNCTION);          \
        }                                                         \
        errno = err;                                              \
} while(0) // note the missing semicolon


#define LIMAL_SLOG(logger, level, message)                        \
do                                                                \
{                                                                 \
        int err = errno;                                          \
        if( (logger).isEnabledFor(level))                         \
        {                                                         \
                blocxx::OStringStream _buf;                       \
                _buf << message;                                  \
                (logger).logMessage((level), _buf.toString(),     \
                                    __FILE__, __LINE__,           \
                         BLOCXX_LOGGER_PRETTY_FUNCTION);          \
        }                                                         \
        errno = err;                                              \
} while(0) // note the missing semicolon


#define LIMAL_LOG_FATAL(logger, logMessage) \
        LIMAL_LOG(logger, blocxx::E_FATAL_ERROR_LEVEL, logMessage)

#define LIMAL_SLOG_FATAL(logger, logMessage) \
        LIMAL_SLOG(logger, blocxx::E_FATAL_ERROR_LEVEL, logMessage)


#define LIMAL_LOG_ERROR(logger, logMessage) \
        LIMAL_LOG(logger, blocxx::E_ERROR_LEVEL, logMessage)

#define LIMAL_SLOG_ERROR(logger, logMessage) \
        LIMAL_SLOG(logger, blocxx::E_ERROR_LEVEL, logMessage)


#define LIMAL_LOG_INFO(logger, logMessage) \
        LIMAL_LOG(logger, blocxx::E_INFO_LEVEL, logMessage)

#define LIMAL_SLOG_INFO(logger, logMessage) \
        LIMAL_SLOG(logger, blocxx::E_INFO_LEVEL, logMessage)


#define LIMAL_LOG_DEBUG(logger, logMessage) \
        LIMAL_LOG(logger, blocxx::E_DEBUG_LEVEL, logMessage)

#define LIMAL_SLOG_DEBUG(logger, logMessage) \
        LIMAL_SLOG(logger, blocxx::E_DEBUG_LEVEL, logMessage)


namespace LIMAL_NAMESPACE
{

class Logger
{
public:
        typedef blocxx::ELogLevel       ELogLevel;

        static blocxx::LoggerRef createCerrLogger(
                const blocxx::String                &component,
                const blocxx::Array<blocxx::String> &components,
                const blocxx::Array<blocxx::String> &categories,
                const blocxx::String                &messageFormat
        );

        static blocxx::LoggerRef createSyslogLogger(
                const blocxx::String                &component,
                const blocxx::Array<blocxx::String> &components,
                const blocxx::Array<blocxx::String> &categories,
                const blocxx::String                &messageFormat,
                const blocxx::String                &identity,
                const blocxx::String                &facility
        );


        static blocxx::LoggerRef createFileLogger(
                const blocxx::String                &component,
                const blocxx::Array<blocxx::String> &components,
                const blocxx::Array<blocxx::String> &categories,
                const blocxx::String                &messageFormat,
                const blocxx::String                &filename,
                blocxx::UInt64                      maxLogFileSize = 0,
                blocxx::UInt32                      maxBackupIndex = 0
        );

        static blocxx::LoggerRef createNullLogger(
                const blocxx::String                &component,
                const blocxx::Array<blocxx::String> &components,
                const blocxx::Array<blocxx::String> &categories,
                const blocxx::String                &messageFormat
        );

        Logger(const blocxx::String &component = "");


        ~Logger();


        inline static bool
        setDefaultLogger(const blocxx::LoggerRef &ref)
        {
                return limal::Logger::setDefaultFromLoggerRef(ref);
        }

        inline static bool
        setThreadLogger(const blocxx::LoggerRef &ref)
        {
                return limal::Logger::setThreadFromLoggerRef(ref);
        }

        inline static blocxx::LoggerRef getDefaultLogger()
        {
                return limal::Logger::getDefaultAsLoggerRef();
        }

        inline static blocxx::LoggerRef getCurrentLogger()
        {
                return limal::Logger::getCurrentAsLoggerRef();
        }

        void
        logMessage(ELogLevel             level,
                   const blocxx::String &message,
                   const char           *filename = 0,
                   int                   fileline = -1,
                   const char           *methodname = 0) const;


        void
        logMessage(const blocxx::String &category,
                   const blocxx::String &message,
                   const char           *filename = 0,
                   int                   fileline = -1,
                   const char           *methodname = 0) const;


        bool
        isEnabledFor(const ELogLevel level) const;


        bool
        isEnabledFor(const blocxx::String &category) const;


private:
        static bool setDefaultFromLoggerRef(const blocxx::LoggerRef &ref);
        static bool setThreadFromLoggerRef(const blocxx::LoggerRef &ref);
        static blocxx::LoggerRef getDefaultAsLoggerRef();
        static blocxx::LoggerRef getCurrentAsLoggerRef();

        blocxx::String m_component;

};


}      // LIMAL_NAMESPACE


#endif // LIMAL_LOGGER_HPP
/* vim: set ts=8 sts=8 sw=8 ai noet: */

---