libs/log/example/event_log/main.cpp
/* * Copyright Andrey Semashev 2007 - 2015. * Distributed under the Boost Software License, Version 1.0. * (See accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) */ /*! * \file main.cpp * \author Andrey Semashev * \date 16.11.2008 * * \brief An example of logging into Windows event log. * * The example shows the basic usage of the Windows NT event log backend. * The code defines custom severity levels, initializes the sink and a couple of * attributes to test with, and writes several records at different levels. * As a result the written records should appear in the Application log, and * should be displayed correctly with the Windows event log viewer. */ #include <stdexcept> #include <string> #include <iostream> #include <boost/smart_ptr/shared_ptr.hpp> #include <boost/date_time/posix_time/posix_time_types.hpp> #include <boost/log/common.hpp> #include <boost/log/attributes.hpp> #include <boost/log/expressions.hpp> #include <boost/log/sinks/sync_frontend.hpp> #include <boost/log/sinks/event_log_backend.hpp> #if !defined(WIN32_LEAN_AND_MEAN) #define WIN32_LEAN_AND_MEAN #endif #include <windows.h> #include "event_log_messages.h" namespace logging = boost::log; namespace attrs = boost::log::attributes; namespace src = boost::log::sources; namespace sinks = boost::log::sinks; namespace expr = boost::log::expressions; namespace keywords = boost::log::keywords; //[ example_sinks_event_log_severity // Define application-specific severity levels enum severity_level { normal, warning, error }; //] void init_logging() { //[ example_sinks_event_log_create_backend // Create an event log sink boost::shared_ptr< sinks::event_log_backend > backend( new sinks::event_log_backend(( keywords::message_file = "%SystemDir%\\event_log_messages.dll", keywords::log_name = "My Application", keywords::log_source = "My Source" )) ); //] //[ example_sinks_event_log_event_composer // Create an event composer. It is initialized with the event identifier mapping. sinks::event_log::event_composer composer( sinks::event_log::direct_event_id_mapping< int >("EventID")); // For each event described in the message file, set up the insertion string formatters composer[LOW_DISK_SPACE_MSG] // the first placeholder in the message // will be replaced with contents of the "Drive" attribute % expr::attr< std::string >("Drive") // the second placeholder in the message // will be replaced with contents of the "Size" attribute % expr::attr< boost::uintmax_t >("Size"); composer[DEVICE_INACCESSIBLE_MSG] % expr::attr< std::string >("Drive"); composer[SUCCEEDED_MSG] % expr::attr< unsigned int >("Duration"); // Then put the composer to the backend backend->set_event_composer(composer); //] //[ example_sinks_event_log_mappings // We'll have to map our custom levels to the event log event types sinks::event_log::custom_event_type_mapping< severity_level > type_mapping("Severity"); type_mapping[normal] = sinks::event_log::make_event_type(MY_SEVERITY_INFO); type_mapping[warning] = sinks::event_log::make_event_type(MY_SEVERITY_WARNING); type_mapping[error] = sinks::event_log::make_event_type(MY_SEVERITY_ERROR); backend->set_event_type_mapper(type_mapping); // Same for event categories. // Usually event categories can be restored by the event identifier. sinks::event_log::custom_event_category_mapping< int > cat_mapping("EventID"); cat_mapping[LOW_DISK_SPACE_MSG] = sinks::event_log::make_event_category(MY_CATEGORY_1); cat_mapping[DEVICE_INACCESSIBLE_MSG] = sinks::event_log::make_event_category(MY_CATEGORY_2); cat_mapping[SUCCEEDED_MSG] = sinks::event_log::make_event_category(MY_CATEGORY_3); backend->set_event_category_mapper(cat_mapping); //] //[ example_sinks_event_log_register_sink // Create the frontend for the sink boost::shared_ptr< sinks::synchronous_sink< sinks::event_log_backend > > sink( new sinks::synchronous_sink< sinks::event_log_backend >(backend)); // Set up filter to pass only records that have the necessary attribute sink->set_filter(expr::has_attr< int >("EventID")); logging::core::get()->add_sink(sink); //] } //[ example_sinks_event_log_facilities BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(event_logger, src::severity_logger_mt< severity_level >) // The function raises an event of the disk space depletion void announce_low_disk_space(std::string const& drive, boost::uintmax_t size) { BOOST_LOG_SCOPED_THREAD_TAG("EventID", (int)LOW_DISK_SPACE_MSG); BOOST_LOG_SCOPED_THREAD_TAG("Drive", drive); BOOST_LOG_SCOPED_THREAD_TAG("Size", size); // Since this record may get accepted by other sinks, // this message is not completely useless BOOST_LOG_SEV(event_logger::get(), warning) << "Low disk " << drive << " space, " << size << " Mb is recommended"; } // The function raises an event of inaccessible disk drive void announce_device_inaccessible(std::string const& drive) { BOOST_LOG_SCOPED_THREAD_TAG("EventID", (int)DEVICE_INACCESSIBLE_MSG); BOOST_LOG_SCOPED_THREAD_TAG("Drive", drive); BOOST_LOG_SEV(event_logger::get(), error) << "Cannot access drive " << drive; } // The structure is an activity guard that will emit an event upon the activity completion struct activity_guard { activity_guard() { // Add a stop watch attribute to measure the activity duration m_it = event_logger::get().add_attribute("Duration", attrs::timer()).first; } ~activity_guard() { BOOST_LOG_SCOPED_THREAD_TAG("EventID", (int)SUCCEEDED_MSG); BOOST_LOG_SEV(event_logger::get(), normal) << "Activity ended"; event_logger::get().remove_attribute(m_it); } private: logging::attribute_set::iterator m_it; }; //] int main(int argc, char* argv[]) { try { // Initialize the library init_logging(); // Make some events { activity_guard activity; announce_low_disk_space("C:", 2 * 1024 * 1024); announce_device_inaccessible("D:"); } return 0; } catch (std::exception& e) { std::cout << "FAILURE: " << e.what() << std::endl; return 1; } }