Question

我有一个从WPF和C ++ \ CLI应用程序使用的本机C ++库。我需要在本机库中实现日志记录，该日志库可以与WPF应用程序中的日志记录合并。

我正在尝试使用Boost LogV2来创建一个'可观察的接收器'，我可以在其中注册一个监听器来传播本机日志消息。

我主要关注的一个问题是来自Boost示例的评论：'我们为了简洁而跳过实际的同步代码'。我不确定是什么，如果有任何同步我应该做。

此外，使用同一个接收器有多个日志源会有任何问题吗？我希望将不同属性的不同记录器添加到记录器中（即从中提取日志消息的模块）。

日志侦听器

class ILogListener
{
public:
  virtual ~ILogListener() = default;
  virtual void onMessageLogged(const std::string& message) = 0;

protected:
  ILogListener() {};

private:
  // Disabling default copy constructor and default 
  // assignment operator.
  ILogListener(const ILogListener& copy) = delete;
  ILogListener& operator=(const ILogListener& copy) = delete;
};

class MyLogListener : public ILogListener
{
  void onMessageLogged(const std::string& message) override
  {
    std::cout << message << "\n";
  }
};

日志接收器

class ObservableLogSink : public sinks::basic_sink_backend< sinks::concurrent_feeding >
{
public:
  // The function is called for every log record to be written to log
  void consume(logging::record_view const& rec)
  {
    auto message = rec[expr::smessage];
    auto message_value = message.get();

    notifyListeners(message_value);
  }

  template <typename container, typename T>
  void addIfNotInContainer(container& c, T item)
  {
    typename container::iterator iter = find(c.begin(), c.end(), item);

    // Only add the listener if we don't have it in the container
    if (iter == c.end())
    {
      c.push_back(item);
    }
  }

  void notifyListeners(const std::string& message)
  {
    for (std::vector<ILogListener*>::iterator begin = listeners_.begin(), end = listeners_.end(); begin != end; ++begin)
    {
      (*begin)->onMessageLogged(message);
    }
  }

  void registerListener(ILogListener* listener)
  {
    addIfNotInContainer(listeners_, listener);
  }

  void removeListener(ILogListener* listener)
  {
    std::vector<ILogListener*>::iterator iter = find(listeners_.begin(), listeners_.end(), listener);

    // Only delete the listener if we have it in the container
    if (iter != listeners_.end())
    {
      listeners_.erase(iter);
    }
  }

private:
  std::vector<ILogListener*> listeners_;
};

记录器

class Logger
{
public:
  Logger() : sink_backend_(new ObservableLogSink())
  {
    init();
  }
  ~Logger(){}

  void registerListener(ILogListener* listener)
  {
    sink_backend_->registerListener(listener);
  }
  void removeListener(ILogListener* listener)
  {
    // TODO
  }

  void init()
  {
    logging::add_common_attributes();

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

    boost::shared_ptr<sinks::unlocked_sink<ObservableLogSink>> sink(new sinks::unlocked_sink<ObservableLogSink>(sink_backend_));

    core->add_sink(sink);
  }

  template <typename ... args >
  void log(args ... to_print)
  {

    logging::record rec = main_log_.open_record();
    if (rec)
    {
      logging::record_ostream strm(rec);

      print(strm, to_print...);

      render_log_.push_record(boost::move(rec));
    }
  }

private:
  boost::log::sources::logger_mt main_log_;

  boost::shared_ptr<ObservableLogSink> sink_backend_;

  template <typename T >
  void print(logging::record_ostream& stream, T only)
  {
    stream << only;
    stream.flush();
  }

  template <typename T, typename ... args >
  void print(logging::record_ostream& stream, T current, args... next)
  {
    stream << current << ' ';
    print(stream, next...);
  }
};

在行动

int main()
{
  Logger logger;

  std::unique_ptr<ILogListener> listener(new MyLogListener);

  logger.registerListener(listener.get());
  logger.log("Hello", "from", "logging");
}

Answer 1

如果使用unlocked_sink前端，就像在代码中一样，并且在example中完成，那么可以从可能发出日志记录的多个线程同时调用后端。后端本身必须实施措施以保护其数据免受并发访问。通常，您需要一个互斥锁。有些情况下您不需要同步，例如后端只是将日志记录转发到系统调用或其他同步API; unlocked_sink主要用于此类案件。

但是，如果您的后端有需要保护的数据，更好的方法是使用为您执行线程同步的synchronous_sink前端。要表达您的后端需要外部同步的要求，您应该从sinks::basic_sink_backend< sinks::synchronized_feeding >派生。这样，用户就无法在后端使用unlocked_sink前端。

此外，如果您希望观察者接收格式化的消息而不仅仅是消息文本，您可能希望为后端启用格式。您可以通过将formatted_records添加到后端要求来执行此操作。

class ObservableLogSink :
    public sinks::basic_sink_backend<
        sinks::combine_requirements<
            sinks::synchronized_feeding,
            sinks::formatted_records
        >::type
    >
{
public:
    // Define types for characters and strings consumed by this backend
    typedef char char_type;
    typedef std::basic_string< char_type > string_type;

    // The function is called for every log record to be written to log
    void consume(logging::record_view const& rec,
        string_type const& formatted_message)
    {
        // Pass formatted_message to the observers
    }
};

然后，您可以为接收器similar配置格式化程序，以了解如何为其他接收器执行此操作。

Boost Log需要什么同步？

日志侦听器

日志接收器

记录器

在行动

1 个答案: