Как запросить повышение:: логику серьезности?

Question

Я использую тривиальное ведение журнала библиотеки boost::log и хочу выполнить некоторый код в зависимости от установленной на данный момент серьезности логгера. Это необходимо для построения сообщения журнала, только если оно будет выведено. Но я не могу найти правильный способ справиться с серьезностью. Код должен быть примерно таким:

if (boost::log::trivial::severity <=
    boost::log::trivial::severity_level::trace)
{
  // construct log message
  BOOST_LOG_TRIVIAL(trace) << message;
}

Кроме того, может быть, есть какой-то способ, когда я знаю, что сообщение будет выведено, чтобы избежать двойной проверки серьезности и вывести его напрямую вместо использования BOOST_LOG_TRIVIAL макрос?

Answer 1

Это не работает так. Вы должны предоставить функцию фильтра для boost:: log:: trivial согласно документации:

http://www.boost.org/doc/libs/1_61_0/libs/log/doc/html/log/tutorial/trivial_filtering.html

void init()
{
    logging::core::get()->set_filter
    (
        // here they've used a constant but you could use a global or
        // a function
        logging::trivial::severity >= logging::trivial::info
    );
}

int main(int, char*[])
{
    init();

    BOOST_LOG_TRIVIAL(trace) << "A trace severity message";
    BOOST_LOG_TRIVIAL(debug) << "A debug severity message";
    BOOST_LOG_TRIVIAL(info) << "An informational severity message";
    BOOST_LOG_TRIVIAL(warning) << "A warning severity message";
    BOOST_LOG_TRIVIAL(error) << "An error severity message";
    BOOST_LOG_TRIVIAL(fatal) << "A fatal severity message";

    return 0;
}

Объект передан logging::core::set_filter имеет тип boost::log::filter

Вы можете так же легко написать:

auto filt = logging::filter(logging::trivial::severity >= logging::trivial::info);
logging::core::get()->set_filter(filt);

filt является легким функциональным объектом, работа которого заключается в проверке отправленных ему атрибутов и возврате, возвращают ли все тесты этих атрибутов true, В этом случае есть только один тест - logging::trivial::severity >= logging::trivial::info,

Задача регистратора - создать набор атрибутов и передать его boost::log::core когда он хочет что-то испустить.

Суть в том, что вы должны отслеживать уровень ведения журнала в своей собственной переменной. Вот один из способов:

#include <iostream>
#include <boost/log/core.hpp>
#include <boost/log/trivial.hpp>
#include <boost/log/expressions.hpp>

namespace logging = boost::log;


int main(int, char*[])
{
    // track your own variable here
    logging::trivial::severity_level my_log_level = logging::trivial::trace;

    // with this filter
    auto filt = logging::filter(logging::trivial::severity >= my_log_level);
    logging::core::get()->set_filter(filt);

    BOOST_LOG_TRIVIAL(trace) << "A trace severity message";
    BOOST_LOG_TRIVIAL(debug) << "A debug severity message";
    BOOST_LOG_TRIVIAL(info) << "An informational severity message";
    BOOST_LOG_TRIVIAL(warning) << "A warning severity message";
    BOOST_LOG_TRIVIAL(error) << "An error severity message";
    BOOST_LOG_TRIVIAL(fatal) << "A fatal severity message";

    // now you have control
    if (my_log_level <= logging::trivial::trace)
    {
        std::cout << "tracing\n";
    }


    return 0;
}

Answer 2

Вот опция, которая добавляет еще один уровень регистрации макросов и оборачивает код для условного вызова в лямбда-функцию, передаваемую этим макросам. Лямбда-функция оценивается, только если соблюдено ограничение уровня серьезности.

Насколько я понимаю, этот метод является поточно-ориентированным, но мое понимание boost::log... ограничено. Я не тестировал в многопоточной среде.

 //g++ -std=gnu++11  -DBOOST_LOG_DYN_LINK main.cpp -lboost_log -lpthread -o lambda_demo                    

 #include <boost/log/core.hpp>
 #include <boost/log/trivial.hpp>
 #include <boost/log/expressions.hpp>

 namespace logging = boost::log;

 #define LOG_TRACE(ARG) BOOST_LOG_TRIVIAL(trace) << ARG;
 #define LOG_INFO(ARG) BOOST_LOG_TRIVIAL(info) << ARG;

 const std::string complicated_function(const std::string &message)
 {
     std::cout << "\nInside complicated_function.\n" << std::flush;
     return "Returning from complicated_function (" + message + ").\n";
 }

 int main(int, char*[])
 {
     std::cout << "\n" << complicated_function("called from std::cout") << "\n" << std::flush;

     BOOST_LOG_TRIVIAL(trace) << "A trace severity message";
     BOOST_LOG_TRIVIAL(debug) << "A debug severity message";
     BOOST_LOG_TRIVIAL(info) << "An informational severity message";
     BOOST_LOG_TRIVIAL(warning) << "A warning severity message";
     BOOST_LOG_TRIVIAL(error) << "An error severity message";
     BOOST_LOG_TRIVIAL(fatal) << "A fatal severity message\n";

     LOG_TRACE ("Coming up: a trace message with a lambda function:");

     LOG_TRACE (
         [=]() {
             return complicated_function("(called from LOG_TRACE");
         }()
         );

     logging::core::get()->set_filter
         (
             logging::trivial::severity >= logging::trivial::info
             );

     BOOST_LOG_TRIVIAL(trace) << "After setting filter, another trace severity message";
     BOOST_LOG_TRIVIAL(debug) << "After setting filter, another debug severity message";
     BOOST_LOG_TRIVIAL(info) << "After setting filter, another informational severity message";
     BOOST_LOG_TRIVIAL(warning) << "After setting filter, another warning severity message";
     BOOST_LOG_TRIVIAL(error) << "After setting filter, anothern error severity message";
     BOOST_LOG_TRIVIAL(fatal) << "After setting filter, another fatal severity message\n";

     LOG_TRACE ("Coming up: a trace message with a lambda function:");
     LOG_TRACE (
         [=]() {
             return complicated_function("called from LOG_TRACE");
         }()
         );

     LOG_INFO ("Coming up: an info message with a lambda function:");
     LOG_INFO (
         [=]() {
             return complicated_function("called from LOG_INFO");
         }()
         );

     return 0;
 }