boost log

Giriş
static linklemek için şöyle yaparız.

gcc ... ..../boost_1_61_0_b1/stage/lib/libboost_log.a ...

Dinamik linklemek için şöyle yaparız.

gcc ... -lboost_log ...

Dinamik linklemek için şu macroyu kullanırız.
BOOST_ALL_DYN_LINK

Konuya girmeden önce boost log'lama kütüphanesinin tasarımına bakmak gerekir. Kodlarken şu satırlar faydalı olabilir.

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

Free Style Metodlar
add_common_attributes metodu

Tam ne işe yarar anlamadım. Şöyle yaparız.

#include <boost/log/utility/setup/common_attributes.hpp>
namespace logging = boost::log;
logging::add_common_attributes();

add_console_log metodu
add_console_log metodu yazısına taşıdım.

add_file_log metodu
add_file_log metodu yazısına taşıdım.

Trivial Logger
Şu satırı dahil ederiz.

#include <boost/log/trivial.hpp>

Trivial Logger kullanması en kolay yöntem. trivial.hpp içinde global bir severity_logger_mt logger - yani source - tanımlar ve tüm kod onu kullanır. Verilen log mesajı hemen consolda görülebilir. Örnek:

int main(int, char*[])
{

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

logger Sınıfı
Örnekte lg benim logger nesnem. Gerekli ayar ve değerleri atadıktan sonra şu macro ile kullanılıyor.

src::logger lg;
BOOST_LOG(lg) << "Hello world!";

N tane logger nesnesi yaratabilirim. logging::core nesnesi sadece bir tane.

Logger Çıktısı
İster Trivial Logger ister benim yarattığım logger kullanılsın, ilk çıktının şekli şöyledir. timestamp + current thread id + severity level + log mesajı.

[2016-03-22 13:43:53.481522] [0x80000f4] [info] Hello

Çıktı değiştirmek için şöyle yaparım.

severity_logger_mt Sınıfı
severity seviyesine göre filtreme sağlar. kendi .h dosyama şu tanımı yaparım

typedef src::severity_logger_mt <severity_level> logger_t;

std::wstring kullanabilmek için şöyle yaparız.

typedef src::wseverity_logger_mt <severity_level> logger_t;

Kendi logger .cpp dosyama iskelet olarak şunu yazarım.

BOOST_LOG_GLOBAL_LOGGER_INIT(logger, src::severity_logger_mt)
{
  logger_t lg;
  logging::add_common_attributes();
  ...
}

Tam örnek burada.

severity_channel_logger Sınıfı
Hem severity hem de channel özelliğine sahip bir logger yaratır.

typedef src::severity_channel_logger< severity_level, std::string > logger_type;

logger_type lg_a(keywords::channel = "A");
logger_type lg_b(keywords::channel = "B");

BOOST_LOG_SEV(lg_a, info) << "Hello, A.log!";
BOOST_LOG_SEV(lg_b, info) << "Hello, B.log!";

Eğer sinkeri de channel'ları kullanacak şekilde yaratırsam her sink sadece ilişkili olduğu channel'dan gelen logları alır. Şöyle yaparız.

BOOST_LOG_ATTRIBUTE_KEYWORD(a_severity, "Severity", severity_level)
BOOST_LOG_ATTRIBUTE_KEYWORD(a_channel, "Channel", std::string)

logging::add_file_log(
    keywords::file_name = "A.log",
    keywords::filter = a_channel == "A");

logging::add_file_log(
    keywords::file_name = "B.log",
    keywords::filter = a_channel == "B");

record_view Sınıfı
Elimizde şu iki sınıf olsun

logging::record_view& record = ...;
logging::formatting_ostream stream = ...;

Şöyle yaparız.

stream << record[a_timestamp] << " "
       << record[a_thread_id]
       << " [" << severity << "] "
       << record[logging::expressions::smessage]
       << "\e[0m";

core Sınıfı
remove metodu
Şöyle yaparız.

typedef sinks::synchronous_sink <sinks::text_file_backend> SPFileSink;
SPFileSink logFileSink = ...;
boost::log::core::get()->remove_sink (logFileSink);

Sinkler
Her sink her logger'dan mesaj alabilir.
Şu sinkler var.

synchronous_sink
Bu sınıfı tanımlamak için şöyle yaparız.

typedef sinks::synchronous_sink <sinks::text_file_backend> T;

Sink BackEnd Sınıfları
Şu sink back endleri var.

text_ostream_backend sınıfı
Şöyle kurulur.

// Construct the sink
typedef sinks::synchronous_sink< sinks::text_ostream_backend > text_sink;
boost::shared_ptr< text_sink > sink = boost::make_shared< text_sink >();

ofstream şöyle eklenir.

// Add a stream to write log to
sink->locked_backend()->add_stream(
        boost::make_shared< std::ofstream >("sample.log"));

flush modu şöyle ayarlanır.

sink->locked_backend()->auto_flush(true);

sink logging::core nesnesine şöyle eklenir.

// Register the sink in the logging core
logging::core::get()->add_sink(sink);

text_file_backend sınıfı
text_file_backend Sınıfı yazısına taşıdım.

Kendi Sınıfım İçin Stream Operator
Şöyle yaparım.

boost::log::formatting_ostream& operator<<(boost::log::formatting_ostream& p,
                                          const MyClass& c)
{
  ...
  return p;
}

BOOST_LOG_ATTRIBUTE_KEYWORD 
Şöyle yaparız

BOOST_LOG_ATTRIBUTE_KEYWORD(a_timestamp, "TimeStamp",
 attrs::local_clock::value_type)
BOOST_LOG_ATTRIBUTE_KEYWORD(a_thread_id, "ThreadID",
 attrs::current_thread_id::value_type)