log.h

Go to the documentation of this file.

#ifndef YAZE_UTIL_LOG_H
#define YAZE_UTIL_LOG_H
 
#include <atomic>
#include <fstream>
#include <functional>
#include <set>
#include <string>
#include <utility>
 
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "absl/strings/string_view.h"
#include "core/features.h"
 
namespace yaze {
namespace util {
 
enum class LogLevel { YAZE_DEBUG, INFO, WARNING, ERROR, FATAL };
 
class LogManager {
 public:
  // Singleton access
  static LogManager& instance();
 
  // Deleted constructors for singleton pattern
  LogManager(const LogManager&) = delete;
  void operator=(const LogManager&) = delete;
 
  void configure(LogLevel level, const std::string& file_path,
                 const std::set<std::string>& categories);
 
  void log(LogLevel level, absl::string_view category,
           absl::string_view message);
 
  void Flush();
 
  bool ShouldLog(LogLevel level) const {
    return level >= min_level_.load(std::memory_order_relaxed);
  }
 
  bool ShouldLog(LogLevel level, absl::string_view category) const;
 
  void SetLogLevel(LogLevel level) { min_level_.store(level); }
  LogLevel GetLogLevel() const { return min_level_.load(); }
 
  void EnableDebugLogging() { min_level_.store(LogLevel::YAZE_DEBUG); }
  void DisableDebugLogging() { min_level_.store(LogLevel::INFO); }
  bool IsDebugEnabled() const {
    return min_level_.load() == LogLevel::YAZE_DEBUG;
  }
 
 private:
  LogManager();
  ~LogManager();
 
  // Configuration state
  std::atomic<LogLevel> min_level_;
  // Transparent comparator: lookup with absl::string_view without allocating.
  std::set<std::string, std::less<>> enabled_categories_;
  std::set<std::string, std::less<>> disabled_categories_;
  std::atomic<bool> all_categories_enabled_;
 
  // Output sink
  std::ofstream log_stream_;
  std::string log_file_path_;
};
 
// --- Public Logging Macros ---
// These macros provide a convenient and efficient API for logging.
// The `do-while(0)` loop ensures they behave like a single statement.
// The level check avoids the cost of string formatting if the message won't be
// logged.
 
// `category` is bound once, so the guard and the log call never evaluate the
// caller's expression twice. It is bound with `auto&&` rather than
// absl::string_view: callers may pass a std::string temporary (for example
// absl::StrCat(...)), and a string_view would dangle for the rest of the block.
// The formatted message is built only when the message will be emitted, so
// arguments with side effects do not run for a filtered level or category.
#define YAZE_LOG_IMPL(level, category, format, ...)                  \
  do {                                                               \
    auto&& yaze_log_category_ = (category);                          \
    auto& yaze_log_manager_ = ::yaze::util::LogManager::instance();  \
    if (yaze_log_manager_.ShouldLog(level, yaze_log_category_)) {    \
      yaze_log_manager_.log(level, yaze_log_category_,               \
                            absl::StrFormat(format, ##__VA_ARGS__)); \
    }                                                                \
  } while (0)
 
#define LOG_DEBUG(category, format, ...)                            \
  YAZE_LOG_IMPL(yaze::util::LogLevel::YAZE_DEBUG, category, format, \
                ##__VA_ARGS__)
#define LOG_INFO(category, format, ...) \
  YAZE_LOG_IMPL(yaze::util::LogLevel::INFO, category, format, ##__VA_ARGS__)
#define LOG_WARN(category, format, ...) \
  YAZE_LOG_IMPL(yaze::util::LogLevel::WARNING, category, format, ##__VA_ARGS__)
#define LOG_ERROR(category, format, ...) \
  YAZE_LOG_IMPL(yaze::util::LogLevel::ERROR, category, format, ##__VA_ARGS__)
#define LOG_FATAL(category, format, ...) \
  YAZE_LOG_IMPL(yaze::util::LogLevel::FATAL, category, format, ##__VA_ARGS__)
 
template <typename... Args>
inline void logf(const absl::FormatSpec<Args...>& format, Args&&... args) {
  LogManager::instance().log(
      LogLevel::INFO, "General",
      absl::StrFormat(format, std::forward<Args>(args)...));
}
 
inline void logf(absl::string_view message) {
  LogManager::instance().log(LogLevel::INFO, "General", message);
}
 
}  // namespace util
}  // namespace yaze
 
#endif  // YAZE_UTIL_LOG_H