Handler method threading safety

[diehard2]

I have a custom handler for a logging platform. The basic outline is below. My questions are

1. Can write be called simultaneously from different threads, or is it one write() at a time
2. Can write be called while a flush() is happening

Thanks for the help. Just checking if I need a lock in there.

class CLPHandler final : public quill::Handler
{
 public:
  explicit CLPHandler(const std::string& clp_header) : m_clp_header(clp_header){};

  void write(quill::fmt_buffer_t const& formatted_log_message, quill::TransitEvent const& log_event) override
  {
     m_formatted_messages.emplace_back({formatted_log_message.begin(), formatted_log_message.size()});
  }

  void flush() noexcept override
  {
    if (m_formatted_messages.empty())
      return;

    auto request_body = fmt::format("{}", fmt::join(m_formatted_messages, ""));
    uint64_t body_size = request_body.size();
    auto request = fmt::format("{} Content-Length: {} Connection:close \r\n {}", m_clp_header, body_size, request_body);

    Send(request);

    m_formatted_messages.clear();
  }

 private:
  std::vector<std::string> m_formatted_messages;
  std::string m_clp_header;
};

[odygrd]

1. write is only called by a single thread the backend logging thread.
2. flush is also called by a single thread the backend logging thread therefore you should not except a write while flush is happening

You only need single thread code for the handler, no locks or anything.

Each frontend user thread has it's own SPSC queue and when you log or flush a message is pushed to that queue. Then the backend logging thread reads all the queues and the messages are forwarded to the handlers. It is not possible to spawn more than one backend logging thread