log.cc

Go to the documentation of this file.

#include "util/log.h"
 
#include <chrono>
#include <cstdint>
#include <ctime>
#include <filesystem>
#include <iomanip>
#include <iostream>
#include <mutex>
#include <string>
 
#include "absl/strings/str_format.h"
#include "core/features.h"
 
namespace {
 
// Serializes writes: background loaders log from other threads.
std::mutex& LogWriteMutex() {
  static std::mutex mutex;
  return mutex;
}
 
// Keep the log file bounded: at open, a file over 10 MB becomes <file>.1
// (older copies shift to .2 and .3). The yaze.log on a daily-use machine had
// grown to 100 MB across builds.
void RotateLogFileIfLarge(const std::string& path) {
  constexpr std::uintmax_t kMaxBytes = 10u * 1024u * 1024u;
  constexpr int kKeep = 3;
  std::error_code ec;
  const auto size = std::filesystem::file_size(path, ec);
  if (ec || size <= kMaxBytes) {
    return;
  }
  std::filesystem::remove(path + "." + std::to_string(kKeep), ec);
  for (int i = kKeep - 1; i >= 1; --i) {
    std::filesystem::rename(path + "." + std::to_string(i),
                            path + "." + std::to_string(i + 1), ec);
  }
  std::filesystem::rename(path, path + ".1", ec);
}
 
}  // namespace
 
namespace yaze {
namespace util {
 
// Helper function to convert LogLevel enum to a string representation.
static const char* LogLevelToString(LogLevel level) {
  switch (level) {
    case LogLevel::YAZE_DEBUG:
      return "YAZE_DEBUG";
    case LogLevel::INFO:
      return "INFO";
    case LogLevel::WARNING:
      return "WARN";
    case LogLevel::ERROR:
      return "ERROR";
    case LogLevel::FATAL:
      return "FATAL";
  }
  return "UNKN";
}
 
// --- LogManager Implementation ---
 
LogManager& LogManager::instance() {
  static LogManager instance;
  return instance;
}
 
LogManager::LogManager()
    : min_level_(LogLevel::INFO), all_categories_enabled_(true) {}
 
LogManager::~LogManager() {
  if (log_stream_.is_open()) {
    log_stream_.close();
  }
}
 
void LogManager::configure(LogLevel level, const std::string& file_path,
                           const std::set<std::string>& categories) {
  min_level_.store(level);
 
  enabled_categories_.clear();
  disabled_categories_.clear();
 
  for (const auto& cat : categories) {
    if (!cat.empty() && cat[0] == '-') {
      if (cat.length() > 1) {
        disabled_categories_.insert(cat.substr(1));
      }
    } else {
      enabled_categories_.insert(cat);
    }
  }
 
  if (enabled_categories_.empty()) {
    all_categories_enabled_.store(true);
  } else {
    all_categories_enabled_.store(false);
  }
 
  // Log configuration for debugging
  if (!enabled_categories_.empty() || !disabled_categories_.empty()) {
    std::cerr << "Log filtering enabled:" << std::endl;
    if (!enabled_categories_.empty()) {
      std::string list;
      for (const auto& c : enabled_categories_)
        list += (list.empty() ? "" : ", ") + c;
      std::cerr << "  Allow: " << list << std::endl;
    }
    if (!disabled_categories_.empty()) {
      std::string list;
      for (const auto& c : disabled_categories_)
        list += (list.empty() ? "" : ", ") + c;
      std::cerr << "  Block: " << list << std::endl;
    }
  }
 
  // If a file path is provided, close any existing stream and open the new
  // file.
  if (!file_path.empty() && file_path != log_file_path_) {
    if (log_stream_.is_open()) {
      log_stream_.close();
    }
    // Open in append mode to preserve history, after rotating a large file.
    RotateLogFileIfLarge(file_path);
    log_stream_.open(file_path, std::ios::out | std::ios::app);
    log_file_path_ = file_path;
  } else if (file_path.empty() && log_stream_.is_open()) {
    // An empty path means "log to stderr", so release the previous file
    // instead of quietly continuing to write to it. Leaving it open also kept
    // a lock on Windows, where an open file cannot be deleted.
    log_stream_.close();
    log_file_path_.clear();
  }
}
 
void LogManager::Flush() {
  std::lock_guard<std::mutex> lock(LogWriteMutex());
  if (log_stream_.is_open()) {
    log_stream_.flush();
  }
}
 
bool LogManager::ShouldLog(LogLevel level, absl::string_view category) const {
  // 1. Filter by log level.
  if (level < min_level_.load(std::memory_order_relaxed)) {
    return false;
  }
 
  // Fast path: no category filtering configured.
  if (all_categories_enabled_.load(std::memory_order_relaxed) &&
      disabled_categories_.empty()) {
    return true;
  }
 
  // 2. Filter by disabled categories (Blocklist).
  if (disabled_categories_.find(category) != disabled_categories_.end()) {
    return false;
  }
 
  // 3. Filter by enabled categories (Allowlist).
  if (!all_categories_enabled_.load(std::memory_order_relaxed)) {
    if (enabled_categories_.find(category) == enabled_categories_.end()) {
      return false;
    }
  }
 
  return true;
}
 
void LogManager::log(LogLevel level, absl::string_view category,
                     absl::string_view message) {
  if (!ShouldLog(level, category)) {
    return;
  }
 
  // 3. Format the complete log message.
  // [HH:MM:SS.ms] [LEVEL] [category] message
  auto now = std::chrono::system_clock::now();
  auto now_tt = std::chrono::system_clock::to_time_t(now);
  std::tm now_tm{};
#ifdef _WIN32
  localtime_s(&now_tm, &now_tt);
#else
  localtime_r(&now_tt, &now_tm);
#endif
  auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
                now.time_since_epoch()) %
            1000;
 
  std::string final_message = absl::StrFormat(
      "[%02d:%02d:%02d.%03d] [%-5s] [%s] %s\n", now_tm.tm_hour, now_tm.tm_min,
      now_tm.tm_sec, ms.count(), LogLevelToString(level), category, message);
 
  // 4. Write to the configured sink (file and/or stderr). Flush warnings and
  // errors at once; batch other lines and flush at most once a second, so
  // chatty INFO logging does not cost a disk write per line.
  {
    std::lock_guard<std::mutex> lock(LogWriteMutex());
    if (log_stream_.is_open()) {
      log_stream_ << final_message;
      static auto last_flush = std::chrono::steady_clock::now();
      const auto steady_now = std::chrono::steady_clock::now();
      if (level >= LogLevel::WARNING ||
          steady_now - last_flush >= std::chrono::seconds(1)) {
        log_stream_.flush();
        last_flush = steady_now;
      }
    }
 
    // Also write to stderr if no file is open OR if console logging is enabled
    if (!log_stream_.is_open() || core::FeatureFlags::get().kLogToConsole) {
      std::cerr << final_message;
    }
  }
 
  // 5. Abort on FATAL error.
  if (level == LogLevel::FATAL) {
    std::abort();
  }
}
 
}  // namespace util
}  // namespace yaze