1 /*
2 * Copyright Andrey Semashev 2007 - 2015.
3 * Distributed under the Boost Software License, Version 1.0.
4 * (See accompanying file LICENSE_1_0.txt or copy at
5 * http://www.boost.org/LICENSE_1_0.txt)
6 */
7
8 #include <string>
9 #include <fstream>
10 #include <iostream>
11 #include <functional>
12 #include <boost/smart_ptr/shared_ptr.hpp>
13 #include <boost/core/null_deleter.hpp>
14 #include <boost/date_time/posix_time/posix_time_types.hpp>
15 #include <boost/log/core.hpp>
16 #include <boost/log/expressions.hpp>
17 #include <boost/log/sinks/async_frontend.hpp>
18 #include <boost/log/sinks/unbounded_ordering_queue.hpp>
19 #include <boost/log/sinks/text_ostream_backend.hpp>
20 #include <boost/log/sources/severity_channel_logger.hpp>
21 #include <boost/log/sources/record_ostream.hpp>
22 #include <boost/log/utility/record_ordering.hpp>
23 #include <boost/log/utility/setup/common_attributes.hpp>
24
25 namespace logging = boost::log;
26 namespace src = boost::log::sources;
27 namespace expr = boost::log::expressions;
28 namespace sinks = boost::log::sinks;
29 namespace keywords = boost::log::keywords;
30
31 enum severity_level
32 {
33 normal,
34 warning,
35 error
36 };
37
38 //[ example_sinks_ordering_async_init
39 // Complete sink type
40 typedef sinks::asynchronous_sink<
41 sinks::text_ostream_backend,
42 sinks::unbounded_ordering_queue< /*< log record queueing strategy >*/
43 logging::attribute_value_ordering< /*< log record ordering predicate type >*/
44 unsigned int, /*< attribute value type >*/
45 std::less< unsigned int > /*< optional, attribute value comparison predicate; `std::less` equivalent is used by default >*/
46 >
47 >
48 > sink_t;
49
init_logging()50 boost::shared_ptr< sink_t > init_logging()
51 {
52 boost::shared_ptr< logging::core > core = logging::core::get();
53
54 // Create a backend and initialize it with a stream
55 boost::shared_ptr< sinks::text_ostream_backend > backend =
56 boost::make_shared< sinks::text_ostream_backend >();
57 backend->add_stream(
58 boost::shared_ptr< std::ostream >(&std::clog, boost::null_deleter()));
59
60 // Wrap it into the frontend and register in the core
61 boost::shared_ptr< sink_t > sink(new sink_t(
62 backend, /*< pointer to the pre-initialized backend >*/
63 keywords::order =
64 logging::make_attr_ordering("LineID", std::less< unsigned int >()), /*< log record ordering predicate >*/
65 keywords::ordering_window = boost::posix_time::seconds(1) /*< latency of log record processing >*/
66 ));
67 core->add_sink(sink);
68
69 // You can manage filtering and formatting through the sink interface
70 sink->set_filter(expr::attr< severity_level >("Severity") >= warning);
71 sink->set_formatter
72 (
73 expr::stream
74 << "Level: " << expr::attr< severity_level >("Severity")
75 << " Message: " << expr::smessage
76 );
77
78 // You can also manage backend in a thread-safe manner
79 {
80 sink_t::locked_backend_ptr p = sink->locked_backend();
81 p->add_stream(boost::make_shared< std::ofstream >("sample.log"));
82 } // the backend gets released here
83
84 return sink;
85 }
86 //]
87
88 //[ example_sinks_ordering_async_stop
stop_logging(boost::shared_ptr<sink_t> & sink)89 void stop_logging(boost::shared_ptr< sink_t >& sink)
90 {
91 boost::shared_ptr< logging::core > core = logging::core::get();
92
93 // Remove the sink from the core, so that no records are passed to it
94 core->remove_sink(sink);
95
96 // Break the feeding loop
97 sink->stop();
98
99 // Flush all log records that may have left buffered
100 sink->flush();
101
102 sink.reset();
103 }
104 //]
105
main(int,char * [])106 int main(int, char*[])
107 {
108 boost::shared_ptr< sink_t > sink = init_logging();
109 logging::add_common_attributes();
110
111 src::severity_channel_logger< severity_level > lg(keywords::channel = "net");
112 BOOST_LOG_SEV(lg, warning) << "Hello world!";
113
114 stop_logging(sink);
115
116 return 0;
117 }
118