logger.h

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <deque>
#include <filesystem>
#include <fstream>
#include <memory>
#include <mutex>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
#include <rex/logging/log_category.h>
#include <rex/module.h>
#include <rex/platform.h>
#include <rex/result.h>
#include <rex/setting.h>
#include <rex/types.h>
#include <rex/utility.h>
 
namespace rex::log {

enum class TimestampStyle : u8 {
  kNone,
  kClock,    
  kDateTime, 
  kElapsed,  
};

struct LineFormat {
  TimestampStyle timestamp = TimestampStyle::kNone;
  bool category = true;
  bool thread = false; 
  bool color = true;   
};

struct Message {
  Level level = Level::kInfo;
  std::string_view category;
  std::string_view text;
  std::chrono::system_clock::time_point time;
  u32 thread_id = 0;
  u64 sequence = 0; 
};

REX_API std::string FormatLine(const Message& message, const LineFormat& format);

inline constexpr std::string_view kColorReset = "\x1b[0m";

REX_API std::string_view LevelColor(Level level);

REX_API char LevelLetter(Level level);
 
}  // namespace rex::log
 
namespace rex::log {

class ILogSink : public NonCopyable {
 public:
  virtual ~ILogSink() = default;
 
  virtual void Write(const Message& message) = 0;
 
  virtual void Flush() = 0;
};

class REX_API LogFileSink final : public ILogSink {
 public:
  [[nodiscard]] static Result<std::unique_ptr<LogFileSink>> Open(const std::filesystem::path& path,
                                                                 LineFormat format);
 
  void Write(const Message& message) override;
 
  void Flush() override;

  const std::filesystem::path& GetPath() const;

  LogFileSink(std::filesystem::path path, std::ofstream file, LineFormat format);
 
 private:
  std::filesystem::path path_;
  std::ofstream file_;
  LineFormat format_;
};

struct CapturedMessage {
  Level level = Level::kInfo;
  std::string category;
  std::string text;
  std::chrono::system_clock::time_point time;
  u32 thread_id = 0;
  u64 sequence = 0;
};

class REX_API LogCaptureSink final : public ILogSink {
 public:
  static constexpr size_t kCapacity = 4096;

  void Write(const Message& message) override;

  void Flush() override;

  u64 CopySince(u64 after, std::vector<CapturedMessage>& out) const;

  u64 GetLatestSequence() const;
 
 private:
  mutable std::mutex mutex_;
  std::deque<CapturedMessage> messages_;
};
 
}  // namespace rex::log
 
namespace rex {
 
class ProcessLoggerControl;

REX_DECLARE_INTERFACE(ILogger, 2)
  [[nodiscard]] virtual Result<void> AddCategories(
      std::span<const log::LogCategory* const> categories) = 0;

  virtual void RemoveCategories(std::span<const log::LogCategory* const> categories) = 0;

  [[nodiscard]] virtual ScopeGuard AddSink(log::ILogSink& sink) = 0;

  virtual void Flush() = 0;

  virtual void Emit(const log::Message& message) = 0;
};

class REX_API Logger final : public SettingOwner, public ILogger {
 public:
  ~Logger() override;
 
  REX_SETTING(std::string, level, "info",
              "Lowest level written by a category without its own level",
              Allowed("trace", "dev", "debug", "info", "warn", "error", "critical", "off"));
  REX_SETTING(std::string, flush_level, "warn", "Lowest level that flushes every sink at once",
              Allowed("trace", "dev", "debug", "info", "warn", "error", "critical", "off"),
              kStartupOnly);
  REX_SETTING(i32, flush_interval, 1, "Seconds between flushes", Range{0, 60}, kStartupOnly);
  REX_SETTING(bool, console, true, "Write to the console", kStartupOnly);
  REX_SETTING(bool, debugger, true, "Write to an attached debugger", kStartupOnly);
  REX_SETTING(bool, file, true, "Write a log file under app.log_root", kStartupOnly);
  REX_SETTING(std::string, file_name, "", "File name, the app name when empty", kStartupOnly);
  REX_SETTING(i64, folder_budget, 0, "Bytes of old log files kept, 0 keeps all",
              Range{0, 9007199254740992.0}, kStartupOnly);
  REX_SETTING(std::string, pattern, "%^%Y-%m-%d %H:%M:%S.%e %Q %-10n %j %v%$",
              "Layout of each line, an spdlog pattern with %Q for the level letter and %j for the "
              "thread",
              kStartupOnly);
  REX_SETTING(bool, color, false, "Color the console", kStartupOnly);
 
  [[nodiscard]] Result<void> AddCategories(
      std::span<const log::LogCategory* const> categories) override;
 
  void RemoveCategories(std::span<const log::LogCategory* const> categories) override;
 
  [[nodiscard]] ScopeGuard AddSink(log::ILogSink& sink) override;
 
  void Flush() override;
 
  void Emit(const log::Message& message) override;
 
  struct State;
 
 private:
  Logger();
  friend REX_API Logger& GetLogger();
  friend class ProcessLoggerControl;
 
  void ApplySettled();
  [[nodiscard]] Result<void> OpenFile(const std::filesystem::path& log_root,
                                      std::string_view app_name);
  void EndSession();
 
  std::unique_ptr<State> state_;
};

REX_API Logger& GetLogger();
 
#define REX_LOGGER() ::rex::GetLogger()
 
}  // namespace rex