eonc::log Namespace Reference

Namespaces
namespace	detail

Classes
struct	Scoped
	RAII helper for class-scoped logging. More...
struct	FileScoped
	RAII helper for file-based logging in a class. More...

Functions
quill::Logger *	get () noexcept
	Get or create the default "combi" logger.
quill::Logger *	traceback () noexcept
	Get or create the "_traceback" logger for traceback logging.
quill::Logger *	get_file (std::string_view name, std::string_view filename, std::string_view pattern="%(message)")
	Get or create a named logger with a file sink.

Function Documentation

get()

quill::Logger * eonc::log::get ( )

inlinenodiscardnoexcept

Get or create the default "combi" logger.

This is the primary logger used throughout eOn. Returns a raw pointer (quill's API) that is valid for the lifetime of the program.

Usage: auto* log = eonc::log::get(); QUILL_LOG_INFO(log, "message");

Definition at line 44 of file EonLogger.h.

                                                 {
  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;
}

get_file()

quill::Logger * eonc::log::get_file ( std::string_view name, std::string_view filename, std::string_view pattern = "%(message)" )

inlinenodiscard

Get or create a named logger with a file sink.

Creates a logger that writes to the specified file with the given pattern. If the logger already exists, returns the existing instance.

Parameters

name	Logger name (must be unique)
filename	Output file path
pattern	Quill format pattern (default: "%(message)")

Returns

Raw pointer to the logger (valid for program lifetime)

Definition at line 111 of file EonLogger.h.

                                              {
  // 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
  }
}

traceback()

quill::Logger * eonc::log::traceback ( )

inlinenodiscardnoexcept

Get or create the "_traceback" logger for traceback logging.

This logger is used for detailed traceback and debugging information. Returns a raw pointer (quill's API) valid for the lifetime of the program.

Usage: auto* log = eonc::log::traceback(); QUILL_LOG_INFO(log, "traceback message");

Definition at line 88 of file EonLogger.h.

                                                       {
  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;
}