Boost-Log 2.0 : leer Schweregrad in logs

Lief in das gleiche problem (leere %Schwere% in der log-Datei UND die gleichen compiler-Fehler, wenn Sie versuchen, um die Funktion register).
Ich fand, dass der Aufruf zu register_simple_formatter_factory werden sollte:

boost::log::register_simple_formatter_factory< boost::log::trivial::severity_level, char >("Severity");

Können Sie Ihr eigenes backend und rufen set_formatter auf Sie. Hier ist mein code, die zeigen, wie es zu tun, plus ein paar Ergänzungen, wie die log-Datei "cleanup" und " auto-flush:

BOOST_LOG_DECLARE_GLOBAL_LOGGER(db_logger, src::severity_logger_mt< dreambridge::log::LogLevel >);

#define LOGGER(level) BOOST_LOG_STREAM_SEV(db_logger::get(), level)
    void InitializeFileLog(const std::string & logDir)
    {   
        boost::shared_ptr< logging::core > loggingCore = logging::core::get();

        db_logger::get().add_attribute(
            "TimeStamp",
            boost::make_shared< attrs::local_clock >());

        string logPath = logDir + "/DreamBridgeSapi2MrcpTts_%N.log";

        boost::shared_ptr< sinks::text_file_backend > backend =
            boost::make_shared< sinks::text_file_backend >(
                //file name pattern
                keywords::file_name = logPath,
                //rotate the file upon reaching 5 MiB size...
                keywords::rotation_size = 5 * 1024 * 1024,
                //...or at midnight, whichever comes first
                keywords::time_based_rotation = sinks::file::rotation_at_time_point(0, 0, 0)                    
            );

        backend->auto_flush(true);

        //Wrap it into the frontend and register in the core.
        //The backend requires synchronization in the frontend.
        typedef sinks::synchronous_sink< sinks::text_file_backend > sink_t;
        boost::shared_ptr< sink_t > sink(new sink_t(backend));

        loggingCore->add_sink(sink);

        backend->set_formatter(fmt::stream
                        << fmt::date_time< boost::posix_time::ptime >("TimeStamp")
                        << " : [" << fmt::attr< dreambridge::log::LogLevel >("Severity")
                        << "] " << fmt::message()
                        );

        backend->set_file_collector(sinks::file::make_collector(
            //rotated logs will be moved here
            keywords::target = logDir + "/old_logs",
            //oldest log files will be removed if the total size reaches 100 MiB...
            keywords::max_size = 100 * 1024 * 1024,
            //...or the free space in the target directory comes down to 50 MiB
            keywords::min_free_space = 50 * 1024 * 1024
        ));

        try
        {
            backend->scan_for_files(sinks::file::scan_all);
        }
        catch(std::exception & e)
        {
            LOGGER(emergency) << "exception during scanning : " << e.what();

        }

    }

außerdem können Sie den Protokolliergrad festlegen als:

void SetLogLevel(dreambridge::log::LogLevel logLevel)
    {
        boost::shared_ptr< logging::core > loggingCore = logging::core::get();

        loggingCore->set_filter
        (
            flt::attr< dreambridge::log::LogLevel >("Severity") <= logLevel
        );
    }

Hinweis: Dieser code ist aus meiner eigenen repository. dreamdridge ist der Produkt-name, daher der namespaces.

Korrigiert wird, wie der Aufruf zum registrieren des formatter (d.h. operator<<), wie hingewiesen, durch die Antworten von W. Merrt und Matt Yang ist alles, was Sie brauchen, um Ihren aktuellen code zu kompilieren und korrekt ausgeführt werden.

Jedoch, um den vollen nutzen der Boost-Log-Filterung Funktionen, die Sie auch brauchen, um zu definieren operator>> für Ihre individuelle Schweregrade und dann zu registrieren, die Methode mit der filter-factory.

template< typename CharT, typename TraitsT>
inline std::basic_istream< CharT, TraitsT >& operator>> (
    std::basic_istream< CharT, TraitsT >& strm, severity_level &lvl)
{
    std::string tmp;
    strm >> tmp;

    //can make it case insensitive to allow 'warning' instead of only 'WARNING'
    //std::transform(tmp.begin(), tmp.end(), tmp.begin(), ::toupper);

    //if you have a lot of levels you may want use a map instead
    if (tmp.compare("DEBUG") == 0) lvl = DEBUG;
    else if (tmp.compare("INFO") == 0) lvl = INFO;
    else if (tmp.compare("WARNING") == 0) lvl = WARNING;
    else if (tmp.compare("ERROR") == 0) lvl = ERROR;
    else if (tmp.compare("CRITICAL") == 0) lvl = CRITICAL;
    //provide a default value for invalid strings
    else lvl = DEBUG;
    //or you could throw an exception
    //else tmp.append(" is not a valid severity level."), throw std::invalid_argument(tmp);

    return strm;
}

void init() {
    //register operator<< for severity_level
    logging::register_simple_formatter_factory< severity_level, char >("Severity");
    //register operator>> for severity_level
    logging::register_simple_filter_factory< severity_level >("Severity");
    logging::add_file_log(
            keywords::file_name = "blop.log",
            keywords::auto_flush = true,
            keywords::open_mode = (std::ios::out | std::ios::app),
            keywords::format = "%TimeStamp% [%Uptime%] (%LineID%) <%Severity%>: %Message%",
            //now you can filter using the name of the severity level
            keywords::filter = "%Severity% >= INFO"                );
    logging::add_common_attributes();
    logging::core::get()->add_global_attribute("Uptime", attrs::timer());
}