log_sink.h

Go to the documentation of this file.

#ifndef SNIFF_LOG_SINK
#define SNIFF_LOG_SINK
 
#include "log_queue.h"
#include "proto/service.pb.h"
#include <google/protobuf/util/time_util.h>
#include <spdlog/details/null_mutex.h>
#include <spdlog/logger.h>
#include <spdlog/sinks/base_sink.h>
#include <spdlog/sinks/sink.h>
#include <spdlog/sinks/stdout_color_sinks.h>
#include <spdlog/spdlog.h>
 
namespace yarilo {
 
namespace log {
 
template <typename Mutex>
class ProtoSink : public spdlog::sinks::base_sink<Mutex> {
public:
  ProtoSink(uint64_t max_entries = 50)
      : max_entries(max_entries), queue(max_entries) {}
 
  ~ProtoSink() override = default;
 
  std::vector<proto::LogEntry *> get_entries() {
    std::lock_guard<Mutex> lock(spdlog::sinks::base_sink<Mutex>::mutex_);
    std::vector<proto::LogEntry *> result;
    queue.fetch_all(result);
    return result;
  }
 
  void stop() { queue.stop(); }
 
  bool is_stopped() { return queue.is_stopped(); }
 
protected:
  void sink_it_(const spdlog::details::log_msg &msg) override {
    auto entry = std::make_unique<proto::LogEntry>();
    auto timestamp = std::make_unique<google::protobuf::Timestamp>(
        google::protobuf::util::TimeUtil::NanosecondsToTimestamp(
            msg.time.time_since_epoch().count()));
    entry->set_allocated_timestamp(timestamp.release());
    entry->set_scope(
        std::string(msg.logger_name.begin(), msg.logger_name.end()));
    entry->set_payload(std::string(msg.payload.begin(), msg.payload.end()));
 
    switch (msg.level) {
    case spdlog::level::level_enum::trace:
      entry->set_level(proto::LogEntry::TRACE);
      break;
 
    case spdlog::level::level_enum::debug:
      entry->set_level(proto::LogEntry::DEBUG);
      break;
 
    case spdlog::level::level_enum::info:
      entry->set_level(proto::LogEntry::INFO);
      break;
 
    case spdlog::level::level_enum::warn:
      entry->set_level(proto::LogEntry::WARN);
      break;
 
    case spdlog::level::level_enum::err:
      entry->set_level(proto::LogEntry::ERR);
      break;
 
    case spdlog::level::level_enum::critical:
      entry->set_level(proto::LogEntry::CRITICAL);
      break;
    }
 
    queue.insert(entry.release());
  }
 
  void flush_() override {}
 
private:
  LogQueue queue;
  uint64_t max_entries;
};
 
using ProtoSinkMt = ProtoSink<std::mutex>;
 
using ProtoSinkSt = ProtoSink<spdlog::details::null_mutex>;
 
extern std::shared_ptr<ProtoSinkMt> global_proto_sink;
 
extern spdlog::level::level_enum global_log_level;
 
std::shared_ptr<spdlog::logger> get_logger(const std::string &name);
 
} // namespace log
 
} // namespace yarilo
 
#endif // SNIFF_LOG_SINK