Logging.h

Go to the documentation of this file.

 
#pragma once
#include "PathUtils.h"
#include <boost/log/attributes/constant.hpp>
#include <boost/log/core.hpp>
#include <boost/log/detail/light_rw_mutex.hpp>
#include <boost/log/sources/global_logger_storage.hpp>
#include <boost/log/sources/threading_models.hpp>
#include <boost/log/trivial.hpp>
#include <boost/thread/lock_guard.hpp>
 
namespace catapult { namespace utils {
 
    // region LogLevel
 
    enum class LogLevel {
        Trace = boost::log::trivial::trace,
 
        Debug = boost::log::trivial::debug,
 
        Info = boost::log::trivial::info,
 
        Warning = boost::log::trivial::warning,
 
        Error = boost::log::trivial::error,
 
        Fatal = boost::log::trivial::fatal,
 
        Min = Trace,
 
        Max = Fatal,
    };
 
    // endregion
 
    // region LogSinkType
 
    enum class LogSinkType {
        Sync,
 
        Async
    };
 
    // endregion
 
    // region LogColorMode
 
    enum class LogColorMode {
        Ansi,
 
        AnsiBold,
 
        None
    };
 
    // endregion
 
    // region LogFilter
 
    struct LogFilter {
    public:
        explicit LogFilter(LogLevel level);
 
        ~LogFilter();
 
    public:
        boost::log::filter toBoostFilter() const;
 
    public:
        void setLevel(const char* name, LogLevel level);
 
    private:
        class Impl;
        std::unique_ptr<Impl> m_pImpl;
    };
 
    // endregion
 
    // region [Basic|File]LoggerOptions
 
    struct BasicLoggerOptions {
    public:
        BasicLoggerOptions()
                : SinkType(LogSinkType::Async)
                , ColorMode(LogColorMode::None)
        {}
 
        LogSinkType SinkType;
 
        LogColorMode ColorMode;
    };
 
    struct FileLoggerOptions : public BasicLoggerOptions {
        explicit FileLoggerOptions(const std::string& directory, const std::string& filePattern)
                : Directory(directory)
                , FilePattern(filePattern)
        {}
 
        std::string Directory;
 
        std::string FilePattern;
 
        uint64_t RotationSize = 25u * 1024 * 1024;
 
        uint64_t MaxTotalSize = 100u * 25 * 1024 * 1024;
 
        uint64_t MinFreeSpace = 100u * 1024 * 1024;
    };
 
    // endregion
 
    // region LoggingBootstrapper
 
    class LoggingBootstrapper final {
    public:
        LoggingBootstrapper();
 
        ~LoggingBootstrapper();
 
    public:
        void addConsoleLogger(const BasicLoggerOptions& options, const LogFilter& filter);
 
        void addFileLogger(const FileLoggerOptions& options, const LogFilter& filter);
 
    private:
        class Impl;
        std::unique_ptr<Impl> m_pImpl;
    };
 
    // endregion
 
    void CatapultLogFlush();
 
    // region boost logging configuration and utils
 
    namespace log {
        template<typename TAttributes>
        class EraseOnExit {
        private:
            using IteratorType = typename std::remove_reference_t<TAttributes>::iterator;
 
        public:
            EraseOnExit(TAttributes& attrs, IteratorType& iter) : m_attrs(attrs), m_iter(iter)
            {}
 
            ~EraseOnExit() {
                if (m_iter != m_attrs.end())
                    m_attrs.erase(m_iter);
            }
 
        private:
            TAttributes& m_attrs;
            IteratorType& m_iter;
        };
 
        template<typename TBase, typename TTraits>
        class custom_info_tagger_feature : public TBase {
        public:
            using char_type = typename TBase::char_type;
            using threading_model = typename TBase::threading_model;
 
        public:
            custom_info_tagger_feature()
            {}
 
            custom_info_tagger_feature(const custom_info_tagger_feature& rhs) : TBase(static_cast<const TBase&>(rhs))
            {}
 
            template<typename TArgs>
            custom_info_tagger_feature(const TArgs& args) : TBase(args)
            {}
 
        public:
            // choose the most restrictive lock
            using open_record_lock = typename boost::log::strictest_lock<
                boost::lock_guard<threading_model>,
                typename TBase::open_record_lock,
                typename TBase::add_attribute_lock,
                typename TBase::remove_attribute_lock
            >::type;
 
        protected:
            template<typename TArgs>
            boost::log::record open_record_unlocked(const TArgs& args) {
                // extract value from parameter pack
                const auto& keyword = boost::parameter::keyword<typename TTraits::TagType>::instance;
                const auto& value = args[keyword];
 
                // add as a new attribute
                auto& attrs = TBase::attributes();
                auto result = TBase::add_attribute_unlocked(
                        TTraits::Name,
                        boost::log::attributes::constant<typename TTraits::Type>(value));
                auto iter = result.second ? result.first : attrs.end();
 
                // remove attribute upon scope exit
                EraseOnExit<decltype(attrs)> eraseGuard(attrs, iter);
 
                // forward to the base
                return TBase::open_record_unlocked(args);
            }
        };
 
        template<typename TCustomFeatureTraits>
        struct custom_info_tagger {
            template<typename TBase>
            struct apply {
                using type = custom_info_tagger_feature<TBase, TCustomFeatureTraits>;
            };
        };
 
        namespace keywords {
            BOOST_PARAMETER_KEYWORD(tag, line)
            BOOST_PARAMETER_KEYWORD(tag, file)
            BOOST_PARAMETER_KEYWORD(tag, subcomponent)
        }
 
        struct LineNumberTraits {
            using Type = unsigned int;
            using TagType = keywords::tag::line;
            static constexpr auto Name = "Line";
        };
 
        struct FilenameTraits {
            using Type = const char*;
            using TagType = keywords::tag::file;
            static constexpr auto Name = "File";
        };
 
        struct SubcomponentTraits {
            using Type = RawString;
            using TagType = keywords::tag::subcomponent;
            static constexpr auto Name = "Subcomponent";
        };
 
        class catapult_logger :
                public boost::log::sources::basic_composite_logger<
                        char,
                        catapult_logger,
                        boost::log::sources::multi_thread_model<boost::log::aux::light_rw_mutex>,
                        boost::log::sources::features<
                                boost::log::sources::severity<boost::log::trivial::severity_level>,
                                custom_info_tagger<LineNumberTraits>,
                                custom_info_tagger<FilenameTraits>,
                                custom_info_tagger<SubcomponentTraits>>> {
            // generate forwarding constructors
            BOOST_LOG_FORWARD_LOGGER_MEMBERS_TEMPLATE(catapult_logger)
        };
 
        BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(global_logger, catapult::utils::log::catapult_logger)
    }
 
    // endregion
}}
 
#define CATAPULT_LOG_WITH_LOGGER_LEVEL_TAG(LOGGER, LEVEL, TAG) \
    BOOST_LOG_STREAM_WITH_PARAMS( \
        (LOGGER), \
        (::catapult::utils::log::keywords::file = (::catapult::utils::ExtractFilename(__FILE__))) \
        (::catapult::utils::log::keywords::line = (static_cast<unsigned int>(__LINE__))) \
        (::catapult::utils::log::keywords::subcomponent = (TAG)) \
        (::boost::log::keywords::severity = (static_cast<boost::log::trivial::severity_level>(LEVEL))))
 
#define CATAPULT_LOG_WITH_LOGGER_LEVEL(LOGGER, LEVEL) \
    CATAPULT_LOG_WITH_LOGGER_LEVEL_TAG(LOGGER, LEVEL, (::catapult::utils::ExtractDirectoryName(__FILE__)))
 
#define CATAPULT_LOG_LEVEL(LEVEL) \
    CATAPULT_LOG_WITH_LOGGER_LEVEL(::catapult::utils::log::global_logger::get(), LEVEL)
 
#define CATAPULT_LOG(SEV) \
    CATAPULT_LOG_WITH_LOGGER_LEVEL( \
            ::catapult::utils::log::global_logger::get(), \
            (static_cast<::catapult::utils::LogLevel>(boost::log::trivial::SEV)))