logger.h

Go to the documentation of this file.

 
#pragma once
 
// standard includes
#include <cstddef>
#include <cstdint>
#include <deque>
#include <functional>
#include <mutex>
#include <string>
#include <string_view>
#include <vector>
 
namespace logging {
 
  enum class LogLevel {
    trace = 0,  
    debug = 1,  
    info = 2,  
    warning = 3,  
    error = 4,  
    none = 5,  
  };
 
  struct LogTimestamp {
    int year = 0;  
    int month = 0;  
    int day = 0;  
    int hour = 0;  
    int minute = 0;  
    int second = 0;  
    int millisecond = 0;  
  };
 
  struct LogSourceLocation {
    const char *file = nullptr;  
    int line = 0;  
 
    [[nodiscard]] static constexpr LogSourceLocation current(
#if defined(__clang__) || defined(__GNUC__)
      const char *currentFile = __builtin_FILE(),
      int currentLine = __builtin_LINE()
#else
      const char *currentFile = nullptr,
      int currentLine = 0
#endif
    ) noexcept {
      return {currentFile, currentLine};
    }
 
    [[nodiscard]] bool valid() const {
      return file != nullptr && file[0] != '\0' && line > 0;
    }
  };
 
  struct LogEntry {
    uint64_t sequence = 0;  
    LogLevel level = LogLevel::info;  
    std::string category;  
    std::string message;  
    LogTimestamp timestamp {};  
    LogSourceLocation sourceLocation {};  
  };
 
  using LogSink = std::function<void(const LogEntry &entry)>;
 
  using TimestampProvider = std::function<LogTimestamp()>;
 
  class Logger;
 
  namespace detail {
 
    struct GlobalLoggingState {
      inline static Logger *registeredLogger = nullptr;  
      inline static bool startupConsoleEnabled = true;  
    };
 
  }  // namespace detail
 
  const char *to_string(LogLevel level);
 
  std::string format_timestamp(const LogTimestamp &timestamp);
 
  std::string format_source_location(const LogSourceLocation &location);
 
  std::string format_entry(const LogEntry &entry);
 
  void set_global_logger(Logger *logger);
 
  [[nodiscard]] bool has_global_logger();
 
  bool log(LogLevel level, std::string category, std::string message, LogSourceLocation location = LogSourceLocation::current());
 
  bool trace(std::string category, std::string message, LogSourceLocation location = LogSourceLocation::current());
 
  bool debug(std::string category, std::string message, LogSourceLocation location = LogSourceLocation::current());
 
  bool info(std::string category, std::string message, LogSourceLocation location = LogSourceLocation::current());
 
  bool warn(std::string category, std::string message, LogSourceLocation location = LogSourceLocation::current());
 
  bool error(std::string category, std::string message, LogSourceLocation location = LogSourceLocation::current());
 
  void set_minimum_level(LogLevel minimumLevel);
 
  void set_file_sink(LogSink sink);
 
  void set_file_minimum_level(LogLevel minimumLevel);
 
  void set_debugger_console_minimum_level(LogLevel minimumLevel);
 
  void set_startup_debug_enabled(bool enabled);
 
  [[nodiscard]] std::vector<LogEntry> snapshot(LogLevel minimumLevel = LogLevel::trace);
 
  [[nodiscard]] std::string format_startup_console_line(LogLevel level, std::string_view category, std::string_view message);
 
  void set_startup_console_enabled(bool enabled);
 
  [[nodiscard]] bool startup_console_enabled();
 
  void print_startup_console_line(LogLevel level, std::string_view category, std::string_view message);
 
  class Logger {
  public:
    explicit Logger(std::size_t capacity = 256, TimestampProvider timestampProvider = {});
 
    std::size_t capacity() const;
 
    void set_minimum_level(LogLevel minimumLevel);
 
    LogLevel minimum_level() const;
 
    void set_startup_debug_enabled(bool enabled);
 
    bool startup_debug_enabled() const;
 
    void set_file_sink(LogSink sink);
 
    void set_file_minimum_level(LogLevel minimumLevel);
 
    LogLevel file_minimum_level() const;
 
    void set_debugger_console_minimum_level(LogLevel minimumLevel);
 
    LogLevel debugger_console_minimum_level() const;
 
    bool should_log(LogLevel level) const;
 
    bool log(LogLevel level, std::string category, std::string message, LogSourceLocation location = LogSourceLocation::current());
 
    bool trace(std::string category, std::string message, LogSourceLocation location = LogSourceLocation::current());
 
    bool debug(std::string category, std::string message, LogSourceLocation location = LogSourceLocation::current());
 
    bool info(std::string category, std::string message, LogSourceLocation location = LogSourceLocation::current());
 
    bool warn(std::string category, std::string message, LogSourceLocation location = LogSourceLocation::current());
 
    bool error(std::string category, std::string message, LogSourceLocation location = LogSourceLocation::current());
 
    void add_sink(LogSink sink, LogLevel minimumLevel = LogLevel::trace);
 
    const std::deque<LogEntry> &entries() const;
 
    std::vector<LogEntry> snapshot(LogLevel minimumLevel = LogLevel::trace) const;
 
  private:
    struct RegisteredSink {
      LogLevel minimumLevel = LogLevel::trace;  
      LogSink sink;  
    };
 
    bool should_log_unlocked(LogLevel level) const;
 
    std::size_t capacity_;
    mutable std::mutex mutex_;
    LogLevel minimumLevel_ = LogLevel::none;
    bool startupDebugEnabled_ = true;
    LogSink fileSink_;
    LogLevel fileMinimumLevel_ = LogLevel::none;
    LogLevel debuggerConsoleMinimumLevel_ = LogLevel::none;
    uint64_t nextSequence_ = 1;
    TimestampProvider timestampProvider_;
    std::deque<LogEntry> entries_;
    std::vector<RegisteredSink> sinks_;
  };
 
}  // namespace logging