測試環境：

[1]boost 1.57

[2]VS2013Update3

主要來源
[1]boost官網，做了些微小的改動。

最簡單的示例

// TestBoostLog.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <iostream>

#include <boost/log/trivial.hpp>

//////////////////////////////////////////////////////////////////////////
// Title: Test Boost Log, Example 1
// Environment: VS2013Upate4, boost 1.57
// description: output trace to the console!
//////////////////////////////////////////////////////////////////////////
// The example dependent 6 boost library
// boost_chrono
// boost_date_time
// boost_filesystem
// boost_log
// boost_system
// boost_thread
//////////////////////////////////////////////////////////////////////////

namespace logging = boost::log;
namespace src = boost::log::sources;
namespace expr = boost::log::expressions;
namespace sinks = boost::log::sinks;
namespace attrs = boost::log::attributes;
namespace keywords = boost::log::keywords;


int _tmain(int argc, _TCHAR* argv[])
{
	BOOST_LOG_TRIVIAL(trace) << "測試中文能否正確輸出（GBK編碼）";

	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";


	std::cin.get();

	return 0;
}
 

最實用的示例

#include "KagulaLog.h"


#include <boost/log/core.hpp>
#include <boost/log/trivial.hpp>
#include <boost/log/expressions.hpp>
#include <boost/log/sinks/text_file_backend.hpp>
#include <boost/log/utility/setup/file.hpp>
#include <boost/log/utility/setup/common_attributes.hpp>
#include <boost/log/sources/severity_logger.hpp>
#include <boost/log/sources/record_ostream.hpp>

namespace logging = boost::log;
namespace src = boost::log::sources;
namespace sinks = boost::log::sinks;
namespace keywords = boost::log::keywords;


//[ example_tutorial_file_advanced
void init()
{
	auto file_sink = logging::add_file_log
		(
		keywords::file_name = "sample_%N.log",                                        /*< file name pattern >*/
		keywords::rotation_size = 10 * 1024 * 1024,                                   /*< rotate files every 10 MiB... >*/
		keywords::time_based_rotation = sinks::file::rotation_at_time_point(0, 0, 0), /*< ...or at midnight >*/
		keywords::format = "[%TimeStamp%]: %Message%"                                 /*< log record format >*/
		);

	file_sink->locked_backend()->set_file_collector(sinks::file::make_collector(
		keywords::target = "logs",        //folder name.
		keywords::max_size = 50 * 1024 * 1024,    //The maximum amount of space of the folder.
		keywords::min_free_space = 100 * 1024 * 1024  //Reserved disk space minimum.
		));

	file_sink->locked_backend()->scan_for_files();
	
	logging::core::get()->set_filter
	(
		logging::trivial::severity >= logging::trivial::info
	);
}
//]


namespace kagula
{
	void test()
	{
		init();
		logging::add_common_attributes();

		using namespace logging::trivial;
		src::severity_logger< severity_level > lg;

		BOOST_LOG_SEV(lg, trace) << "A trace severity message (測試中文能否正確輸出（GBK編碼）)";
		BOOST_LOG_SEV(lg, debug) << "A debug severity message";
		BOOST_LOG_SEV(lg, info) << "An informational severity message";
		BOOST_LOG_SEV(lg, warning) << "A warning severity message";
		BOOST_LOG_SEV(lg, error) << "An error severity message";
		BOOST_LOG_SEV(lg, fatal) << "A fatal severity message";
		BOOST_LOG_SEV(lg, fatal) << "測試中文能否正確輸出（GBK編碼）";
	}
}
 

多執行緒示例

/*
*          Copyright Andrey Semashev 2007 - 2013.
* 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   30.08.2009
*
* \brief  An example of asynchronous logging with bounded log record queue in multiple threads.
*/

// #define BOOST_LOG_DYN_LINK 1

#include <stdexcept>
#include <string>
#include <iostream>
#include <fstream>
#include <functional>
#include <boost/ref.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/barrier.hpp>

#include <boost/log/common.hpp>
#include <boost/log/expressions.hpp>
#include <boost/log/attributes.hpp>
#include <boost/log/sinks.hpp>
#include <boost/log/sources/logger.hpp>
#include <boost/log/utility/empty_deleter.hpp>
#include <boost/log/utility/record_ordering.hpp>

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;

using boost::shared_ptr;

enum
{
	LOG_RECORDS_TO_WRITE = 10000,
	THREAD_COUNT = 2
};

BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(test_lg, src::logger_mt)

//! This function is executed in multiple threads
void thread_fun(boost::barrier& bar)
{
	// Wait until all threads are created
	bar.wait();

	// Here we go. First, identify the thread.
	BOOST_LOG_SCOPED_THREAD_TAG("ThreadID", boost::this_thread::get_id());

	// Now, do some logging
	for (unsigned int i = 0; i < LOG_RECORDS_TO_WRITE; ++i)
	{
		BOOST_LOG(test_lg::get()) << "Log record " << i;
	}
}

int main(int argc, char* argv[])
{
	try
	{
		// Open a rotating text file
		shared_ptr< std::ostream > strm(new std::ofstream("test.log"));
		if (!strm->good())
			throw std::runtime_error("Failed to open a text log file");

		// Create a text file sink
		typedef sinks::text_ostream_backend backend_t;
		typedef sinks::asynchronous_sink<
			backend_t,
			sinks::bounded_ordering_queue<
			logging::attribute_value_ordering< unsigned int, std::less< unsigned int > >,
			128,                        // queue no more than 128 log records
			sinks::block_on_overflow    // wait until records are processed
			>
		> sink_t;
		shared_ptr< sink_t > sink(new sink_t(
			boost::make_shared< backend_t >(),
			// We'll apply record ordering to ensure that records from different threads go sequentially in the file
			keywords::order = logging::make_attr_ordering("RecordID", std::less< unsigned int >())));

		sink->locked_backend()->add_stream(strm);

		sink->set_formatter
			(
			expr::format("%1%: [%2%] [%3%] - %4%")
			% expr::attr< unsigned int >("RecordID")
			% expr::attr< boost::posix_time::ptime >("TimeStamp")
			% expr::attr< boost::thread::id >("ThreadID")
			% expr::smessage
			);

		// Add it to the core
		logging::core::get()->add_sink(sink);

		// Add some attributes too
		logging::core::get()->add_global_attribute("TimeStamp", attrs::local_clock());
		logging::core::get()->add_global_attribute("RecordID", attrs::counter< unsigned int >());

		// Create logging threads
		boost::barrier bar(THREAD_COUNT);
		boost::thread_group threads;
		for (unsigned int i = 0; i < THREAD_COUNT; ++i)
			threads.create_thread(boost::bind(&thread_fun, boost::ref(bar)));

		// Wait until all action ends
		threads.join_all();

		// Flush all buffered records
		sink->stop();
		sink->flush();

		return 0;
	}
	catch (std::exception& e)
	{
		std::cout << "FAILURE: " << e.what() << std::endl;
		return 1;
	}
}