#include <boost/log/attributes/constant.hpp>

Наиболее простым и часто используемым типом атрибутов является постоянное значение какого-либо типа. Этот тип атрибута реализован с шаблоном классаконстанта. Шаблон параметризируется с типом значения атрибута. Постоянное значение должно быть передано конструктору атрибутов. Вот пример:

void foo()
{
    src::logger lg;
    // Register a constant attribute that always yields value -5
    lg.add_attribute("MyInteger", attrs::constant< int >(-5));
    // Register another constant attribute. Make it a string this time.
    lg.add_attribute("MyString", attrs::constant< std::string >("Hello world!"));
    // There is also a convenience generator function. "MyInteger2" is constant< int > here.
    lg.add_attribute("MyInteger2", attrs::make_constant(10));
}

Вот и все, ничего нельзя сделать с постоянным атрибутом. Константы очень полезны, когда вы хотите выделить некоторые записи журнала или просто передать некоторые данные на фон раковины (например, передать статистические параметры коллектору).

#include <boost/log/attributes/mutable_constant.hpp>

Этот тип атрибута является расширением дляпостоянного атрибута. В дополнение к возможности хранить некоторое значение, шаблон классаmutable_constantимеет два различия:

Чтобы изменить сохраненное значение атрибута, необходимо назвать методset:

void foo()
{
    src::logger lg;
    // Register a mutable constant attribute that always yields value -5
    attrs::mutable_constant< int > attr(-5);
    lg.add_attribute("MyInteger", attr);
    BOOST_LOG(lg) << "This record has MyInteger == -5";
    // Change the attribute value
    attr.set(100);
    BOOST_LOG(lg) << "This record has MyInteger == 100";
}

В многопоточных приложениях вызовы метода, установленные, должны быть сериализованы с вызовамиget_value(которые, вообще говоря, происходят в каждой сделанной записи журнала). По умолчаниюmutable_constantникак не сериализует вызовы, предполагая, что пользователь сделает это внешне. Тем не менее, шаблонmutable_constantпредоставляет три дополнительных аргумента шаблона: примитивный тип синхронизации, эксклюзивный тип блокировки и общий тип блокировки. Если указан примитивный тип синхронизации, то используемый эксклюзивный тип блокировки является обязательным параметром. Если тип совместно используемого замка не указан, атрибут вернется к эксклюзивному замку вместо общих замков. Например:

// This mutable constant will always lock exclusively
// either for reading or storing the value
typedef attrs::mutable_constant<
    int,                                        // attribute value type
    boost::mutex,                               // synchronization primitive
    boost::lock_guard< boost::mutex >           // exclusive lock type
> exclusive_mc;
exclusive_mc my_int1(10);
// This mutable constant will use shared clocking for reading the value
// and exclusive locking for storing
typedef attrs::mutable_constant<
    int,                                        // attribute value type
    boost::shared_mutex,                        // synchronization primitive
    boost::unique_lock< boost::shared_mutex >,  // exclusive lock type
    boost::shared_lock< boost::shared_mutex >   // shared lock type
> shared_mc;
shared_mc my_int2(20);
BOOST_LOG_INLINE_GLOBAL_LOGGER_INIT(my_logger, src::logger_mt)
{
    src::logger_mt lg;
    lg.add_attribute("MyInteger1", my_int1);
    lg.add_attribute("MyInteger2", my_int2);
    return lg;
}
void foo()
{
    src::logger_mt& lg = get_my_logger();
    // This is safe, even if executed in multiple threads
    my_int1.set(200);
    BOOST_LOG(lg) << "This record has MyInteger1 == 200";
    my_int2.set(300);
    BOOST_LOG(lg) << "This record has MyInteger2 == 300";
}

Изменяемые константы часто используются в качестве вспомогательных атрибутов внутри регистраторов для хранения атрибутов, которые могут изменяться на некоторых событиях. В отличие от обычных констант, которые требуют перерегистрации в случае изменения стоимости, изменчивые константы позволяют изменять значение на месте.

#include <boost/log/attributes/counter.hpp>

Счетчики являются одним из самых простых атрибутов, которые генерируют новое значение при каждом запросе. Счетчики часто используются для идентификации записей журнала или для подсчета некоторых событий, например, принятых сетевых соединений. Шаблон классасчетчикобеспечивает такую функциональность. Данный шаблон параметризируется типом счетчика, который должен поддерживать арифметические операции, такие какоператор+иоператор-. Атрибут счетчика позволяет уточнить начальное значение и шаг (который может быть отрицательным) на конструкцию.

BOOST_LOG_INLINE_GLOBAL_LOGGER_INIT(my_logger, src::logger_mt)
{
    src::logger_mt lg;
    // This counter will count lines, starting from 0
    lg.add_attribute("LineCounter", attrs::counter< unsigned int >());
    // This counter will count backwards, starting from 100 with step -5
    lg.add_attribute("CountDown", attrs::counter< int >(100, -5));
    return lg;
}
void foo()
{
    src::logger_mt& lg = get_my_logger();
    BOOST_LOG(lg) << "This record has LineCounter == 0, CountDown == 100";
    BOOST_LOG(lg) << "This record has LineCounter == 1, CountDown == 95";
    BOOST_LOG(lg) << "This record has LineCounter == 2, CountDown == 90";
}

Note

Не ожидайте, что записи журнала с атрибутомвсегда будут иметь значения восходящего или нисходящего счетчика в полученном журнале. В многопоточных приложениях встречные значения, полученные различными потоками, могут поступать в раковину в любом порядке.Обоснованиедля более подробного объяснения того, почему это может произойти. По этой причине правильнее сказать, что атрибутгенерирует идентификатор в порядке восходящего или нисходящего, а не считает записи журнала в любом порядке.

#include <boost/log/attributes/clock.hpp>

Одной из «обязательных» особенностей любой библиотеки журналов является поддержка прикрепления метки времени к каждой записи журнала. Библиотека предоставляет для этой цели два атрибута:utc_clockиlocal_clock. Первый возвращает текущее время UTC, а второй возвращает текущее местное время. В любом случае возвращаемая временная метка приобретается с максимальной точностью для целевой платформы. Значение атрибутаповышает::posix_time::ptime(см.Boost.DateTime). Использование довольно простое:

BOOST_LOG_DECLARE_GLOBAL_LOGGER(my_logger, src::logger_mt)
void foo()
{
    logging::core::get()->add_global_attribute(
        "TimeStamp",
        attrs::local_clock());
    // Now every log record ever made will have a time stamp attached
    src::logger_mt& lg = get_my_logger();
    BOOST_LOG(lg) << "This record has a time stamp";
}

#include <boost/log/attributes/timer.hpp>

Атрибуттаймераочень полезен, когда есть необходимость оценить продолжительность какого-то длительного процесса. Атрибут возвращает время, прошедшее с момента построения атрибута. Тип значения атрибута —boost::posix_time::ptime::time_duration_type(см.Boost.DateTime).

// The class represents a single peer-to-peer connection
class network_connection
{
    src::logger m_logger;
public:
    network_connection()
    {
        m_logger.add_attribute("Duration", attrs::timer());
        BOOST_LOG(m_logger) << "Connection established";
    }
    ~network_connection()
    {
        // This log record will show the whole life time duration of the connection
        BOOST_LOG(m_logger) << "Connection closed";
    }
};

Атрибут обеспечивает высокое разрешение оценки времени и может даже использоваться в качестве простого инструмента профилирования производительности на месте.

	Tip
	Атрибуттаймераможет даже использоваться для профилирования кода в различных модулях без их повторной компиляции. Хитрость заключается в том, чтобы обернуть дорогостоящий вызов на иностранный модуль с помощью специфичного для потокатаймераприложенного атрибута, который разметит все записи журнала, сделанные внутри модуля, с показаниями времени.

#include <boost/log/attributes/named_scope.hpp>
// Supporting headers
#include <boost/log/support/exception.hpp>

Библиотека журналов поддерживает отслеживание стека областей во время выполнения приложения. Этот стек может быть записан для входа в систему или использоваться для других нужд (например, для сохранения точной последовательности вызовов, которая привела к исключению при броске). Каждый элемент стека содержит следующую информацию (см. определение шаблона структурыnamed_scope_entry):

Стек области применения реализуется в качестве глобального хранилища, специфичного для потоков. Существует атрибутnamed_scope, который позволяет подключать этот стек в лесозаготовительный трубопровод. Этот атрибут генерирует значение вложенного типаnamed_scope::scope_stack, которое является экземпляром стека scope. Атрибут может быть зарегистрирован следующим образом:

logging::core::get()->add_global_attribute("Scope", attrs::named_scope());

Обратите внимание, что это совершенно правильно, чтобы зарегистрировать атрибут глобально, потому что стек области действия является потоковой локальной в любом случае. Это также косвенно добавит отслеживание объема ко всем потокам приложения, что часто именно то, что необходимо.

Теперь мы можем отметить области выполнения макросамиBOOST_LOG_FUNCTIONиBOOST_LOG_NAMED_SCOPE(последний принимает название области в качестве аргумента). Эти макросы автоматически добавляют информацию о местоположении источника к каждой позиции области. Ниже приводится пример:

void foo(int n)
{
    // Mark the scope of the function foo
    BOOST_LOG_FUNCTION();
    switch (n)
    {
    case 0:
        {
            // Mark the current scope
            BOOST_LOG_NAMED_SCOPE("case 0");
            BOOST_LOG(lg) << "Some log record";
            bar(); // call some function
        }
        break;
    case 1:
        {
            // Mark the current scope
            BOOST_LOG_NAMED_SCOPE("case 1");
            BOOST_LOG(lg) << "Some log record";
            bar(); // call some function
        }
        break;
    default:
        {
            // Mark the current scope
            BOOST_LOG_NAMED_SCOPE("default");
            BOOST_LOG(lg) << "Some log record";
            bar(); // call some function
        }
        break;
    }
}

После выполненияfooмы сможем увидеть в журнале, что функцияbarбыла вызвана изfooи, точнее, из утверждения случая, которое соответствует значениюn. Это может быть очень полезно при отслеживании тонких ошибок, которые появляются только тогда, когдабарвызывается из определенного места (например, еслибар)в данном конкретном месте принимаются недействительные аргументы.

Note

BOOST_LOG_FUNCTIONМакро использует расширения, специфичные для компилятора, для генерации имени области действия из прилагаемой функции. C++11 определяет стандартный макрос__func__для этой цели, но он не поддерживается повсеместно. Кроме того, формат строки не стандартизирован и может варьироваться от одного компилятора к другому. По этой причине рекомендуется использоватьBOOST_LOG_NAMED_SCOPE.вместоBOOST_LOG_FUNCTIONдля обеспечения последовательного и портативного поведения.

Другим хорошим вариантом использования является прикрепление информации стека области применения к исключению. С помощьюBoost.Exceptionможно:

void bar(int x)
{
    BOOST_LOG_FUNCTION();
    if (x < 0)
    {
        // Attach a copy of the current scope stack to the exception
        throw boost::enable_error_info(std::range_error("x must not be negative"))
            << logging::current_scope();
    }
}
void foo()
{
    BOOST_LOG_FUNCTION();
    try
    {
        bar(-1);
    }
    catch (std::range_error& e)
    {
        // Acquire the scope stack from the exception object
        BOOST_LOG(lg) << "bar call failed: " << e.what() << ", scopes stack:\n"
            << *boost::get_error_info< logging::current_scope_info >(e);
    }
}

	Note
	Для компиляции этого кода необходимо включить заголовок поддержкиBoost.Exception.

Note

Мы не вводим в исключение атрибутnamed_scope. Поскольку стеки области действия поддерживаются во всем мире, выбрасывание исключения приведет к раскручиванию стека и, как следствие, усечению глобального стека. Вместо этого мы создаем копию стека прицела, позвонивcurrent_scopeна месте броска. Эта копия будет сохранена нетронутой, даже если глобальный экземпляр стека изменится во время раскручивания стека.

#include <boost/log/attributes/current_process_id.hpp>

Часто полезно знать идентификатор процесса, который создает журнал, особенно если журнал может в конечном итоге объединить выход различных процессов. Атрибутcurrent_process_idпредставляет собой константу, которая форматируется в идентификатор текущего процесса. Тип значения атрибута может быть определен посредствомcurrent_process_id::value_typetypedef.

void foo()
{
    logging::core::get()->add_global_attribute(
        "ProcessID",
        attrs::current_process_id());
}

#include <boost/log/attributes/current_process_name.hpp>

current_process_nameпроизводитstd::значения строкис исполняемым названием текущего процесса.

	Note
	Этот атрибут не является универсально портативным, хотя Windows, Linux и OS X поддерживаются. Атрибут может работать и на других системах POSIX, но он не был протестирован. Если имя процесса не может быть получено, атрибут сгенерирует строку с идентификатором процесса.

void foo()
{
    logging::core::get()->add_global_attribute(
        "Process",
        attrs::current_process_name());
}

#include <boost/log/attributes/current_thread_id.hpp>

Многопоточные сборки библиотеки также поддерживают атрибутcurrent_thread_idс типом значенияcurrent_thread_id::value_type. Атрибут будет генерировать значения, специфичные для вызывающей нити. Использование аналогично процессу id.

void foo()
{
    logging::core::get()->add_global_attribute(
        "ThreadID",
        attrs::current_thread_id());
}

	Tip
	Возможно, вы заметили, что атрибут зарегистрирован по всему миру. Это не приведет к тому, что все потоки, имеющие тот же ThreadID в записях журналов, что и атрибут, всегда будут возвращать значение, специфичное для потока. Дополнительным преимуществом является то, что вам не нужно делать что-то в процедурах инициализации потока, чтобы иметь значение атрибута потока в записях журнала.

#include <boost/log/attributes/function.hpp>

Этот атрибут представляет собой простую обертку вокруг определяемого пользователем функционального объекта. Каждая попытка получить значение атрибута приводит к вызову объекта функции. Результат вызова возвращается в качестве значения атрибута (это означает, что функция не должна возвращатьпустоту). Атрибут объекта функции может быть построен с помощью функции помощникаmake_function, такой как:

void foo()
{
    logging::core::get()->add_global_attribute("MyRandomAttr", attrs::make_function(&std::rand));
}

Также поддерживаются автоматически генерируемые функциональные объекты, подобные тем, которые определены вBoost.Bindили STL.

	Note
	Некоторые недостающие компиляторы могут не поддерживатьрезультат_. Эта метафункция используется в функцииmake_functionдля автоматического обнаружения возвращаемого типа функционального объекта. Еслирезультат_нарушает или обнаруживает неправильный тип, можно попытаться явно указать тип возврата объекта функции в качестве аргумента шаблона дляфункции make_function.