diff options
Diffstat (limited to 'src/boost/libs/log/example/event_log/main.cpp')
| -rw-r--r-- | src/boost/libs/log/example/event_log/main.cpp | 190 |
1 files changed, 190 insertions, 0 deletions
diff --git a/src/boost/libs/log/example/event_log/main.cpp b/src/boost/libs/log/example/event_log/main.cpp new file mode 100644 index 00000000..ca02a188 --- /dev/null +++ b/src/boost/libs/log/example/event_log/main.cpp @@ -0,0 +1,190 @@ +/* + * 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; + } +} |