EonLogger.h

Go to the documentation of this file.

/*
** This file is part of eOn.
**
** SPDX-License-Identifier: BSD-3-Clause
**
** Copyright (c) 2010--present, eOn Development Team
** All rights reserved.
**
** Repo:
** https://github.com/TheochemUI/eOn
*/
#pragma once
 
#include "quill/Backend.h"
#include "quill/Frontend.h"
#include "quill/LogMacros.h"
#include "quill/Logger.h"
#include "quill/sinks/ConsoleSink.h"
#include "quill/sinks/FileSink.h"
#include <atomic>
#include <filesystem>
#include <mutex>
#include <source_location>
#include <string>
#include <string_view>
#include <system_error>
 
namespace eonc::log {
 
// Logger name constants for internal use
namespace detail {
inline constexpr std::string_view kDefaultLoggerName{"combi"};
inline constexpr std::string_view kTracebackLoggerName{"_traceback"};
} // namespace detail

[[nodiscard]] inline quill::Logger *get() noexcept {
  static std::atomic<quill::Logger *> cached_logger{nullptr};
  if (quill::Logger *l = cached_logger.load(std::memory_order_relaxed)) {
    return l;
  }
 
  if (auto *logger = quill::Frontend::get_logger(
          std::string(detail::kDefaultLoggerName))) {
    cached_logger.store(logger, std::memory_order_relaxed);
    return logger;
  }
 
  // Fallback for Python bindings/tests that didn't run ClientEON's main()
  static quill::Logger *fallback = []() -> quill::Logger * {
    try {
      quill::Backend::start();
    } catch (...) {
    } // Ignore if backend already started
 
    try {
      auto console_sink =
          quill::Frontend::create_or_get_sink<quill::ConsoleSink>(
              "fallback_console");
      return quill::Frontend::create_or_get_logger(
          "combi", std::move(console_sink),
          quill::PatternFormatterOptions{"%(message)"},
          quill::ClockSourceType::System);
    } catch (...) {
      return nullptr;
    }
  }();
  if (fallback)
    cached_logger.store(fallback, std::memory_order_relaxed);
  return fallback;
}

[[nodiscard]] inline quill::Logger *traceback() noexcept {
  static std::atomic<quill::Logger *> cached{nullptr};
  if (quill::Logger *l = cached.load(std::memory_order_relaxed)) {
    return l;
  }
  if (auto *logger = quill::Frontend::get_logger(
          std::string(detail::kTracebackLoggerName))) {
    cached.store(logger, std::memory_order_relaxed);
    return logger;
  }
  return nullptr;
}

[[nodiscard]] inline quill::Logger *
get_file(std::string_view name, std::string_view filename,
         std::string_view pattern = "%(message)") {
  // If the logger already exists, return it immediately.
  // Quill strictly checks configuration matches on recreation and throws if
  // PatternFormatterOptions differ, which crashes instances (like
  // Dimer/Optimizers) that are created multiple times in loops (e.g., NEB).
  if (auto *existing = quill::Frontend::get_logger(std::string(name))) {
    return existing;
  }
  static std::mutex file_logger_mutex;
  std::lock_guard<std::mutex> lock(file_logger_mutex);
  if (auto *existing = quill::Frontend::get_logger(std::string(name))) {
    return existing;
  }
 
  try {
    // Durable absolute path: optimizers open "_lbfgs.log" etc. under CWD.
    // Job integration fixtures chdir into /tmp/eon_test_job_* then delete that
    // tree when the case ends, while Quill's process-lifetime FileSink still
    // flushes — "fopen failed after 3 attempts". Keep logs under a stable
    // temp subdir instead of the disposable workdir.
    namespace fs = std::filesystem;
    fs::path path{std::string(filename)};
    if (!path.is_absolute()) {
      static const fs::path log_dir = [] {
        fs::path d = fs::temp_directory_path() / "eon_logs";
        std::error_code ec;
        fs::create_directories(d, ec);
        return d;
      }();
      path = log_dir / path.filename();
    }
    quill::FileSinkConfig cfg;
    cfg.set_open_mode('w');
    auto file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(
        path.string(), cfg);
    return quill::Frontend::create_or_get_logger(
        std::string(name), std::move(file_sink),
        quill::PatternFormatterOptions{std::string(pattern)},
        quill::ClockSourceType::System);
  } catch (...) {
    return get(); // Fallback to default combi logger if creation fails
  }
}

struct Scoped {
  [[no_unique_address]] quill::Logger *logger{nullptr};
 
  Scoped() noexcept
      : logger(get()) {}
 
  // Implicit conversion to Logger* for seamless use with QUILL_LOG_* macros
  operator quill::Logger *() const noexcept { return logger; }
 
  // Support QUILL_LOG_ macro pointer dereference
  quill::Logger *operator->() const noexcept { return logger; }
 
  // Allow dynamic re-assignment (e.g. switching to _traceback logger)
  Scoped &operator=(quill::Logger *l) noexcept {
    logger = l;
    return *this;
  }
 
  // Explicit access if needed
  [[nodiscard]] quill::Logger *ptr() const noexcept { return logger; }
};

struct FileScoped {
  [[no_unique_address]] quill::Logger *logger{nullptr};
 
  FileScoped(std::string_view name, std::string_view filename,
             std::string_view pattern = "%(message)") noexcept
      : logger(get_file(name, filename, pattern)) {}
 
  operator quill::Logger *() const noexcept { return logger; }
  // Support QUILL_LOG_ macro pointer dereference
  quill::Logger *operator->() const noexcept { return logger; }
  FileScoped &operator=(quill::Logger *l) noexcept {
    logger = l;
    return *this;
  }
  [[nodiscard]] quill::Logger *ptr() const noexcept { return logger; }
};
 
} // namespace eonc::log
 
// Force MSVC to evaluate __VA_ARGS__ properly
#define EONC_EXPAND(x) x

#define EONC_LOG_TRACE(...)                                                    \
  do {                                                                         \
    if (auto *l = eonc::log::get()) {                                          \
      EONC_EXPAND(QUILL_LOG_TRACE_L1(l, __VA_ARGS__));                         \
    }                                                                          \
  } while (0)
#define EONC_LOG_DEBUG(...)                                                    \
  do {                                                                         \
    if (auto *l = eonc::log::get()) {                                          \
      EONC_EXPAND(QUILL_LOG_DEBUG(l, __VA_ARGS__));                            \
    }                                                                          \
  } while (0)
#define EONC_LOG_INFO(...)                                                     \
  do {                                                                         \
    if (auto *l = eonc::log::get()) {                                          \
      EONC_EXPAND(QUILL_LOG_INFO(l, __VA_ARGS__));                             \
    }                                                                          \
  } while (0)
#define EONC_LOG_WARNING(...)                                                  \
  do {                                                                         \
    if (auto *l = eonc::log::get()) {                                          \
      EONC_EXPAND(QUILL_LOG_WARNING(l, __VA_ARGS__));                          \
    }                                                                          \
  } while (0)
#define EONC_LOG_ERROR(...)                                                    \
  do {                                                                         \
    if (auto *l = eonc::log::get()) {                                          \
      EONC_EXPAND(QUILL_LOG_ERROR(l, __VA_ARGS__));                            \
    }                                                                          \
  } while (0)
#define EONC_LOG_CRITICAL(...)                                                 \
  do {                                                                         \
    if (auto *l = eonc::log::get()) {                                          \
      EONC_EXPAND(QUILL_LOG_CRITICAL(l, __VA_ARGS__));                         \
    }                                                                          \
  } while (0)