log sinks synchronous_sink Sınıfı

Giriş
Şu satırı dahil ederiz.

#include <boost/log/sinks/sync_frontend.hpp>

Kolay kullanım için şöyle yaparız.

namespace logging = boost::log;

Sink ve Core
Sink yaratılıp ayarlandıktan sonra core'a eklenir. Şöyle yaparız. text_sink_type kendi tanımımız.

boost::shared_ptr<text_sink_type> sink = boost::make_shared<text_sink_type>();
...
boost::log::core::get()->add_sink (sink);

Tanımlama
Açıklaması şöyle. Bu sınıfı front_end olarak düşünmek lazım.

Sink frontends implement thread synchronization, so if multiple frontends share a backend
the backend becomes unprotected.

1. text_file_backend
text_file_backend kullanır.

2.text_multifile_backend
text_multfile_backend kullanılır. Şöyle yaparız.

typedef sinks::synchronous_sink< sinks::text_multifile_backend > sink_t;

3. text_ostream_backend

text_ostream_backend kullanan bir sink tanımlamak için şu satırı dahil ederiz.

#include <boost/log/sinks/text_ostream_backend.hpp>

Şöyle yaparız.

using text_sink_type =
  logging::sinks::synchronous_sink<logging::sinks::text_ostream_backend>;

4. syslog_backend
Şöyle yaparız.

namespace logging = boost::log;
namespace sinks = boost::log::sinks;
namespace keywords = boost::log::keywords;
using namespace boost::log::sinks::syslog;

boost::shared_ptr< logging::core > core = logging::core::get();

boost::shared_ptr< sinks::syslog_backend > backend =
    boost::make_shared< sinks::syslog_backend >(
        keywords::use_impl = sinks::syslog::udp_socket_based,
        keywords::facility = sinks::syslog::local0
    );


// Create and fill in another level translator for "MyLevel" attribute of type string
sinks::syslog::custom_severity_mapping< std::string > mapping("MyLevel");
mapping["debug"] = sinks::syslog::debug;
mapping["info"] = sinks::syslog::info;
mapping["warning"] = sinks::syslog::warning;
mapping["error"] = sinks::syslog::error;
backend->set_severity_mapper(mapping);
backend->set_target_address("localhost");

// Wrap it into the frontend and register in the core.
// The backend requires synchronization in the frontend.
typedef sinks::synchronous_sink< sinks::syslog_backend > sink_t;
boost::shared_ptr< sink_t > sink(new sink_t(backend));

core->add_sink(sink);

Singleton
Sink singleton olarak kullanılabilir. Şöyle yaparız.

class Logger {
public:
  static const Logger& GetInstance() {
    static Logger logger;
    return logger;
  }

  void Log(const std::wstring& message) const {
    src::wseverity_logger< logging::trivial::severity_level > slg;
    BOOST_LOG_SEV(slg, logging::trivial::error) << message;
  }

private:
  Logger() {
    auto sink = logging::add_file_log(keywords::file_name = "sample.log");

    std::locale loc = boost::locale::generator()("en_US.UTF-8");
    sink->imbue(loc);

    logging::add_common_attributes();
  }
};

Constructor - default

Şöyle yaparız. text_sink_type bizim kendi typedef'imiz

auto sink = boost::make_shared<text_sink_type> ();

Şöyle yaparız. text_sink bizim kendi typedef'imiz.

boost::shared_ptr<text_sink> sink = boost::make_shared<text_sink>();

Constructor - backend
Şöyle yaparız.

boost::shared_ptr<sinks::text_multifile_backend> backend = ...

typedef sinks::synchronous_sink< sinks::text_multifile_backend > sink_t;
boost::shared_ptr< sink_t > sink(new sink_t(backend));

lock_backend metodu
backend'e erişmek için kullanılır. backend'e stream eklemek için şöyle yaparız.

sink->locked_backend ()->
  add_stream (boost::shared_ptr<std::ostream>(&std::clog, boost::null_deleter()));

Şöyle yaparız.

sink->locked_backend()->
  add_stream(boost::shared_ptr<std::ostream>(&std::cout, boost::null_deleter()));

Şöyle yaparız.

sink->locked_backend()->add_stream(
  boost::make_shared< std::ofstream >("regular.log"));

set_formatter metodu - boost::log::formatter
boost::log::formatter olak boost::log::expressions::stream nesnesi veririz. Şöyle yaparız.

sink->set_formatter(
  logging::expressions::stream
  << logging::expressions::format_date_time<boost::posix_time::ptime>
        ("TimeStamp", "%Y-%m-%d %H:%M:%S.%f") << " :: "
  << '[' << logging::trivial::severity << " - " <<
      logging::expressions::attr<std::string>("Channel") << "] "
  << logging::expressions::smessage
);

Şöyle yaparız.

// Set the formatter
sink->set_formatter (
  boost::log::expressions::stream
  ...
);

set_formatter metodu - lambda
Şöyle yaparız.

logging::formatting_ostream& severity_wrap_prefix (
  logging::formatting_ostream& strm,
  const logging::trivial::severity_level& sev)
{
  ...
  return strm;
}

logging::formatting_ostream& severity_wrap_suffix
(logging::formatting_ostream& strm,
 const logging::trivial::severity_level& sev)
{
  ...
  return strm;
}

sink->set_formatter([&](logging::record_view const& rec,
  logging::formatting_ostream& strm)
{
  const b_logging::trivial::severity_level& sev = 
    *logging::extract<b_logging::trivial::severity_level>("Severity", rec);

  const boost::posix_time::ptime &pt = 
    *logging::extract<boost::posix_time::ptime>("TimeStamp", rec);

  severity_wrap_prefix(strm,sev);
  strm << ptime_to_string(pt) << ": "
                     << rec[expr::smessage];
  strm << expr::xml_decor[expr::stream << expr::smessage];
  severity_wrap_suffix(strm,sev);
});

set_filter metodu

Örnek
Şöyle yaparız.

sink->set_filter(boost::log::trivial::severity >= boost::log::trivial::info
        &&
        boost::log::expressions::has_attr(tag_attr) == false);

Örnek
Şöyle yaparız.

sink->set_filter(expr::has_attr(tag_attr) 
  && (tag_attr == "action" || tag_attr == "warning"));

Örnek
Şöyle yaparız.

// Set the special filter to the frontend
// in order to skip the sink when no debugger is available
sink->set_filter(expr::is_debugger_present());