diff options
Diffstat (limited to 'thirdparty/spdlog/logger-inl.h')
| -rw-r--r-- | thirdparty/spdlog/logger-inl.h | 257 |
1 files changed, 257 insertions, 0 deletions
diff --git a/thirdparty/spdlog/logger-inl.h b/thirdparty/spdlog/logger-inl.h new file mode 100644 index 00000000..d01c08da --- /dev/null +++ b/thirdparty/spdlog/logger-inl.h @@ -0,0 +1,257 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. +// Distributed under the MIT License (http://opensource.org/licenses/MIT) + +#pragma once + +#ifndef SPDLOG_HEADER_ONLY +#include <spdlog/logger.h> +#endif + +#include <spdlog/sinks/sink.h> +#include <spdlog/details/backtracer.h> +#include <spdlog/pattern_formatter.h> + +#include <cstdio> + +namespace spdlog { + +// public methods +SPDLOG_INLINE logger::logger(const logger &other) + : name_(other.name_) + , sinks_(other.sinks_) + , level_(other.level_.load(std::memory_order_relaxed)) + , flush_level_(other.flush_level_.load(std::memory_order_relaxed)) + , custom_err_handler_(other.custom_err_handler_) + , tracer_(other.tracer_) +{} + +SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT : name_(std::move(other.name_)), + sinks_(std::move(other.sinks_)), + level_(other.level_.load(std::memory_order_relaxed)), + flush_level_(other.flush_level_.load(std::memory_order_relaxed)), + custom_err_handler_(std::move(other.custom_err_handler_)), + tracer_(std::move(other.tracer_)) + +{} + +SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT +{ + this->swap(other); + return *this; +} + +SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT +{ + name_.swap(other.name_); + sinks_.swap(other.sinks_); + + // swap level_ + auto other_level = other.level_.load(); + auto my_level = level_.exchange(other_level); + other.level_.store(my_level); + + // swap flush level_ + other_level = other.flush_level_.load(); + my_level = flush_level_.exchange(other_level); + other.flush_level_.store(my_level); + + custom_err_handler_.swap(other.custom_err_handler_); + std::swap(tracer_, other.tracer_); +} + +SPDLOG_INLINE void swap(logger &a, logger &b) +{ + a.swap(b); +} + +SPDLOG_INLINE void logger::set_level(level::level_enum log_level) +{ + level_.store(log_level); +} + +SPDLOG_INLINE level::level_enum logger::level() const +{ + return static_cast<level::level_enum>(level_.load(std::memory_order_relaxed)); +} + +SPDLOG_INLINE const std::string &logger::name() const +{ + return name_; +} + +// set formatting for the sinks in this logger. +// each sink will get a separate instance of the formatter object. +SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f) +{ + for (auto it = sinks_.begin(); it != sinks_.end(); ++it) + { + if (std::next(it) == sinks_.end()) + { + // last element - we can be move it. + (*it)->set_formatter(std::move(f)); + break; // to prevent clang-tidy warning + } + else + { + (*it)->set_formatter(f->clone()); + } + } +} + +SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) +{ + auto new_formatter = details::make_unique<pattern_formatter>(std::move(pattern), time_type); + set_formatter(std::move(new_formatter)); +} + +// create new backtrace sink and move to it all our child sinks +SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) +{ + tracer_.enable(n_messages); +} + +// restore orig sinks and level and delete the backtrace sink +SPDLOG_INLINE void logger::disable_backtrace() +{ + tracer_.disable(); +} + +SPDLOG_INLINE void logger::dump_backtrace() +{ + dump_backtrace_(); +} + +// flush functions +SPDLOG_INLINE void logger::flush() +{ + flush_(); +} + +SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) +{ + flush_level_.store(log_level); +} + +SPDLOG_INLINE level::level_enum logger::flush_level() const +{ + return static_cast<level::level_enum>(flush_level_.load(std::memory_order_relaxed)); +} + +// sinks +SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const +{ + return sinks_; +} + +SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks() +{ + return sinks_; +} + +// error handler +SPDLOG_INLINE void logger::set_error_handler(err_handler handler) +{ + custom_err_handler_ = std::move(handler); +} + +// create new logger with same sinks and configuration. +SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name) +{ + auto cloned = std::make_shared<logger>(*this); + cloned->name_ = std::move(logger_name); + return cloned; +} + +// protected methods +SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool log_enabled, bool traceback_enabled) +{ + if (log_enabled) + { + sink_it_(log_msg); + } + if (traceback_enabled) + { + tracer_.push_back(log_msg); + } +} + +SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) +{ + for (auto &sink : sinks_) + { + if (sink->should_log(msg.level)) + { + SPDLOG_TRY + { + sink->log(msg); + } + SPDLOG_LOGGER_CATCH() + } + } + + if (should_flush_(msg)) + { + flush_(); + } +} + +SPDLOG_INLINE void logger::flush_() +{ + for (auto &sink : sinks_) + { + SPDLOG_TRY + { + sink->flush(); + } + SPDLOG_LOGGER_CATCH() + } +} + +SPDLOG_INLINE void logger::dump_backtrace_() +{ + using details::log_msg; + if (tracer_.enabled()) + { + sink_it_(log_msg{name(), level::info, "****************** Backtrace Start ******************"}); + tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); }); + sink_it_(log_msg{name(), level::info, "****************** Backtrace End ********************"}); + } +} + +SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) +{ + auto flush_level = flush_level_.load(std::memory_order_relaxed); + return (msg.level >= flush_level) && (msg.level != level::off); +} + +SPDLOG_INLINE void logger::err_handler_(const std::string &msg) +{ + if (custom_err_handler_) + { + custom_err_handler_(msg); + } + else + { + using std::chrono::system_clock; + static std::mutex mutex; + static std::chrono::system_clock::time_point last_report_time; + static size_t err_counter = 0; + std::lock_guard<std::mutex> lk{mutex}; + auto now = system_clock::now(); + err_counter++; + if (now - last_report_time < std::chrono::seconds(1)) + { + return; + } + last_report_time = now; + auto tm_time = details::os::localtime(system_clock::to_time_t(now)); + char date_buf[64]; + std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); +#if defined(USING_R) && defined(R_R_H) // if in R environment + REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] {%s}\n", err_counter, date_buf, name().c_str(), msg.c_str()); +#else + std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] {%s}\n", err_counter, date_buf, name().c_str(), msg.c_str()); +#endif + } +} +} // namespace spdlog |