diff options
Diffstat (limited to 'primedev/thirdparty/spdlog/logger.h')
| -rw-r--r-- | primedev/thirdparty/spdlog/logger.h | 366 |
1 files changed, 366 insertions, 0 deletions
diff --git a/primedev/thirdparty/spdlog/logger.h b/primedev/thirdparty/spdlog/logger.h new file mode 100644 index 00000000..a34c5221 --- /dev/null +++ b/primedev/thirdparty/spdlog/logger.h @@ -0,0 +1,366 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) + +#pragma once + +// Thread safe logger (except for set_error_handler()) +// Has name, log level, vector of std::shared sink pointers and formatter +// Upon each log write the logger: +// 1. Checks if its log level is enough to log the message and if yes: +// 2. Call the underlying sinks to do the job. +// 3. Each sink use its own private copy of a formatter to format the message +// and send to its destination. +// +// The use of private formatter per sink provides the opportunity to cache some +// formatted data, and support for different format per sink. + +#include <spdlog/common.h> +#include <spdlog/details/log_msg.h> +#include <spdlog/details/backtracer.h> + +#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT +#include <spdlog/details/os.h> +#endif + +#include <vector> +#ifndef SPDLOG_NO_EXCEPTIONS +#define SPDLOG_LOGGER_CATCH() \ + catch (const std::exception &ex) \ + { \ + err_handler_(ex.what()); \ + } \ + catch (...) \ + { \ + err_handler_("Unknown exception in logger"); \ + } +#else +#define SPDLOG_LOGGER_CATCH() +#endif + +namespace spdlog { + +class SPDLOG_API logger +{ +public: + // Empty logger + explicit logger(std::string name) + : name_(std::move(name)) + , sinks_() + {} + + // Logger with range on sinks + template<typename It> + logger(std::string name, It begin, It end) + : name_(std::move(name)) + , sinks_(begin, end) + {} + + // Logger with single sink + logger(std::string name, sink_ptr single_sink) + : logger(std::move(name), {std::move(single_sink)}) + {} + + // Logger with sinks init list + logger(std::string name, sinks_init_list sinks) + : logger(std::move(name), sinks.begin(), sinks.end()) + {} + + virtual ~logger() = default; + + logger(const logger &other); + logger(logger &&other) SPDLOG_NOEXCEPT; + logger &operator=(logger other) SPDLOG_NOEXCEPT; + + void swap(spdlog::logger &other) SPDLOG_NOEXCEPT; + + // FormatString is a type derived from fmt::compile_string + template<typename FormatString, typename std::enable_if<fmt::is_compile_string<FormatString>::value, int>::type = 0, typename... Args> + void log(source_loc loc, level::level_enum lvl, const FormatString &fmt, Args&&...args) + { + log_(loc, lvl, fmt, std::forward<Args>(args)...); + } + + // FormatString is NOT a type derived from fmt::compile_string but is a string_view_t or can be implicitly converted to one + template<typename... Args> + void log(source_loc loc, level::level_enum lvl, string_view_t fmt, Args&&...args) + { + log_(loc, lvl, fmt, std::forward<Args>(args)...); + } + + template<typename FormatString, typename... Args> + void log(level::level_enum lvl, const FormatString &fmt, Args&&...args) + { + log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); + } + + template<typename FormatString, typename... Args> + void trace(const FormatString &fmt, Args&&...args) + { + log(level::trace, fmt, std::forward<Args>(args)...); + } + + template<typename FormatString, typename... Args> + void debug(const FormatString &fmt, Args&&...args) + { + log(level::debug, fmt, std::forward<Args>(args)...); + } + + template<typename FormatString, typename... Args> + void info(const FormatString &fmt, Args&&...args) + { + log(level::info, fmt, std::forward<Args>(args)...); + } + + template<typename FormatString, typename... Args> + void warn(const FormatString &fmt, Args&&...args) + { + log(level::warn, fmt, std::forward<Args>(args)...); + } + + template<typename FormatString, typename... Args> + void error(const FormatString &fmt, Args&&...args) + { + log(level::err, fmt, std::forward<Args>(args)...); + } + + template<typename FormatString, typename... Args> + void critical(const FormatString &fmt, Args&&...args) + { + log(level::critical, fmt, std::forward<Args>(args)...); + } + + template<typename T> + void log(level::level_enum lvl, const T &msg) + { + log(source_loc{}, lvl, msg); + } + + // T can be statically converted to string_view and isn't a fmt::compile_string + template<class T, typename std::enable_if< + std::is_convertible<const T &, spdlog::string_view_t>::value && !fmt::is_compile_string<T>::value, int>::type = 0> + void log(source_loc loc, level::level_enum lvl, const T &msg) + { + log(loc, lvl, string_view_t{msg}); + } + + void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, string_view_t msg) + { + bool log_enabled = should_log(lvl); + bool traceback_enabled = tracer_.enabled(); + if (!log_enabled && !traceback_enabled) + { + return; + } + + details::log_msg log_msg(log_time, loc, name_, lvl, msg); + log_it_(log_msg, log_enabled, traceback_enabled); + } + + void log(source_loc loc, level::level_enum lvl, string_view_t msg) + { + bool log_enabled = should_log(lvl); + bool traceback_enabled = tracer_.enabled(); + if (!log_enabled && !traceback_enabled) + { + return; + } + + details::log_msg log_msg(loc, name_, lvl, msg); + log_it_(log_msg, log_enabled, traceback_enabled); + } + + void log(level::level_enum lvl, string_view_t msg) + { + log(source_loc{}, lvl, msg); + } + + // T cannot be statically converted to string_view or wstring_view + template<class T, typename std::enable_if<!std::is_convertible<const T &, spdlog::string_view_t>::value && + !is_convertible_to_wstring_view<const T &>::value, + int>::type = 0> + void log(source_loc loc, level::level_enum lvl, const T &msg) + { + log(loc, lvl, "{}", msg); + } + + template<typename T> + void trace(const T &msg) + { + log(level::trace, msg); + } + + template<typename T> + void debug(const T &msg) + { + log(level::debug, msg); + } + + template<typename T> + void info(const T &msg) + { + log(level::info, msg); + } + + template<typename T> + void warn(const T &msg) + { + log(level::warn, msg); + } + + template<typename T> + void error(const T &msg) + { + log(level::err, msg); + } + + template<typename T> + void critical(const T &msg) + { + log(level::critical, msg); + } + +#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT +#ifndef _WIN32 +#error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows +#else + + template<typename... Args> + void log(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args&&...args) + { + bool log_enabled = should_log(lvl); + bool traceback_enabled = tracer_.enabled(); + if (!log_enabled && !traceback_enabled) + { + return; + } + SPDLOG_TRY + { + // format to wmemory_buffer and convert to utf8 + fmt::wmemory_buffer wbuf; + fmt::format_to(wbuf, fmt, std::forward<Args>(args)...); + + memory_buf_t buf; + details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf); + details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); + log_it_(log_msg, log_enabled, traceback_enabled); + } + SPDLOG_LOGGER_CATCH() + } + + // T can be statically converted to wstring_view + template<class T, typename std::enable_if<is_convertible_to_wstring_view<const T &>::value, int>::type = 0> + void log(source_loc loc, level::level_enum lvl, const T &msg) + { + bool log_enabled = should_log(lvl); + bool traceback_enabled = tracer_.enabled(); + if (!log_enabled && !traceback_enabled) + { + return; + } + + SPDLOG_TRY + { + memory_buf_t buf; + details::os::wstr_to_utf8buf(msg, buf); + details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); + log_it_(log_msg, log_enabled, traceback_enabled); + } + SPDLOG_LOGGER_CATCH() + } +#endif // _WIN32 +#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT + + // return true logging is enabled for the given level. + bool should_log(level::level_enum msg_level) const + { + return msg_level >= level_.load(std::memory_order_relaxed); + } + + // return true if backtrace logging is enabled. + bool should_backtrace() const + { + return tracer_.enabled(); + } + + void set_level(level::level_enum log_level); + + level::level_enum level() const; + + const std::string &name() const; + + // set formatting for the sinks in this logger. + // each sink will get a separate instance of the formatter object. + void set_formatter(std::unique_ptr<formatter> f); + + void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local); + + // backtrace support. + // efficiently store all debug/trace messages in a circular buffer until needed for debugging. + void enable_backtrace(size_t n_messages); + void disable_backtrace(); + void dump_backtrace(); + + // flush functions + void flush(); + void flush_on(level::level_enum log_level); + level::level_enum flush_level() const; + + // sinks + const std::vector<sink_ptr> &sinks() const; + + std::vector<sink_ptr> &sinks(); + + // error handler + void set_error_handler(err_handler); + + // create new logger with same sinks and configuration. + virtual std::shared_ptr<logger> clone(std::string logger_name); + +protected: + std::string name_; + std::vector<sink_ptr> sinks_; + spdlog::level_t level_{level::info}; + spdlog::level_t flush_level_{level::off}; + err_handler custom_err_handler_{nullptr}; + details::backtracer tracer_; + + // common implementation for after templated public api has been resolved + template<typename FormatString, typename... Args> + void log_(source_loc loc, level::level_enum lvl, const FormatString &fmt, Args&&...args) + { + bool log_enabled = should_log(lvl); + bool traceback_enabled = tracer_.enabled(); + if (!log_enabled && !traceback_enabled) + { + return; + } + SPDLOG_TRY + { + memory_buf_t buf; + fmt::format_to(buf, fmt, std::forward<Args>(args)...); + details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); + log_it_(log_msg, log_enabled, traceback_enabled); + } + SPDLOG_LOGGER_CATCH() + } + + // log the given message (if the given log level is high enough), + // and save backtrace (if backtrace is enabled). + void log_it_(const details::log_msg &log_msg, bool log_enabled, bool traceback_enabled); + virtual void sink_it_(const details::log_msg &msg); + virtual void flush_(); + void dump_backtrace_(); + bool should_flush_(const details::log_msg &msg); + + // handle errors during logging. + // default handler prints the error to stderr at max rate of 1 message/sec. + void err_handler_(const std::string &msg); +}; + +void swap(logger &a, logger &b); + +} // namespace spdlog + +#ifdef SPDLOG_HEADER_ONLY +#include "logger-inl.h" +#endif |