Logger.hpp

#pragma once
 
#include <mutex>
 
// clang-format off
#include <wmtk/utils/DisableWarnings.hpp>
#include <spdlog/fmt/bundled/ranges.h>
#include <spdlog/fmt/ostr.h>
#include <spdlog/spdlog.h>
#include <wmtk/utils/EnableWarnings.hpp>
// clang-format on
 
namespace wmtk {
 
namespace detail {
// Component entry points share legacy process-wide loggers. Serialize their setup and
// temporarily use console sinks for a memory call, including messages from worker threads.
// The lock is held for the whole component call, file calls included: component calls in one
// process never run concurrently (see docs/in-memory-io.md).
class ComponentLoggerScope
{
public:
    explicit ComponentLoggerScope(bool memory);
    ~ComponentLoggerScope();
 
private:
    std::unique_lock<std::recursive_mutex> m_lock;
    std::shared_ptr<spdlog::logger> m_previous, m_previous_opt;
    bool m_memory;
};
} // namespace detail
 
bool has_user_overloaded_logger_level();
spdlog::logger& logger();
 
spdlog::logger& opt_logger();
 
void set_logger(std::shared_ptr<spdlog::logger> logger);
 
void set_file_logger(const std::string& log_file);
 
void set_opt_logger(std::shared_ptr<spdlog::logger> logger);
 
[[noreturn]] void log_and_throw_error(const std::string& msg);
 
template <typename... Args>
[[noreturn]] void log_and_throw_error(const std::string& msg, const Args&... args)
{
    log_and_throw_error(fmt::format(fmt::runtime(msg), args...));
}
} // namespace wmtk