From 34cf7fc8f10be257a2fb2882c69635134cb9a9f4 Mon Sep 17 00:00:00 2001 From: gabime Date: Sun, 7 Jun 2020 23:12:50 +0300 Subject: [PATCH] Removed backtrace support --- CMakeLists.txt | 1 - README.md | 19 --------- example/example.cpp | 11 ----- include/spdlog/details/backtracer.h | 41 ------------------ include/spdlog/details/registry.h | 1 - include/spdlog/logger.h | 44 ++++++------------- include/spdlog/spdlog.h | 9 ---- src/backtracer.cpp | 66 ----------------------------- src/details/registry.cpp | 26 ------------ src/logger.cpp | 42 +----------------- src/spdlog-inl.cpp | 15 ------- tests/CMakeLists.txt | 1 - tests/test_backtrace.cpp | 65 ---------------------------- 13 files changed, 14 insertions(+), 327 deletions(-) delete mode 100644 include/spdlog/details/backtracer.h delete mode 100644 src/backtracer.cpp delete mode 100644 tests/test_backtrace.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 215e753d..a80905fa 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -129,7 +129,6 @@ set(SPDLOG_SRCS src/spdlog-inl.cpp src/async.cpp src/async_logger.cpp - src/backtracer.cpp src/common.cpp src/fmt.cpp diff --git a/README.md b/README.md index fc92a161..b18d7096 100644 --- a/README.md +++ b/README.md @@ -49,7 +49,6 @@ $ cmake .. && make -j * Easily extendable with custom log targets (just implement a single function in the [sink](include/spdlog/sinks/sink.h) interface). * Log filtering - log levels can be modified in runtime as well as in compile time. * Support for loading log levels from argv or from environment var. -* [Backtrace](#backtrace-support) support - store debug messages in a ring buffer and display later on demand. ## Usage samples @@ -142,24 +141,6 @@ void daily_example() ``` ---- -#### Backtrace support -```c++ -// Loggers can store in a ring buffer all messages (including debug/trace) and display later on demand. -// When needed, call dump_backtrace() to see them - -spdlog::enable_backtrace(32); // Store the latest 32 messages in a buffer. Older messages will be dropped. -// or my_logger->enable_backtrace(32).. -for(int i = 0; i < 100; i++) -{ - spdlog::debug("Backtrace message {}", i); // not logged yet.. -} -// e.g. if some error happened: -spdlog::dump_backtrace(); // log them now! show the last 32 messages - -// or my_logger->dump_backtrace(32).. -``` - --- #### Periodic flush ```c++ diff --git a/example/example.cpp b/example/example.cpp index 5be28b43..0adcd93e 100644 --- a/example/example.cpp +++ b/example/example.cpp @@ -48,17 +48,6 @@ int main(int, char *[]) spdlog::set_pattern("%+"); // back to default format spdlog::set_level(spdlog::level::info); - // Backtrace support - // Loggers can store in a ring buffer all messages (including debug/trace) for later inspection. - // When needed, call dump_backtrace() to see what happened: - spdlog::enable_backtrace(10); // create ring buffer with capacity of 10 messages - for (int i = 0; i < 100; i++) - { - spdlog::debug("Backtrace message {}", i); // not logged.. - } - // e.g. if some error happened: - spdlog::dump_backtrace(); // log them now! - try { stdout_logger_example(); diff --git a/include/spdlog/details/backtracer.h b/include/spdlog/details/backtracer.h deleted file mode 100644 index d295f88e..00000000 --- a/include/spdlog/details/backtracer.h +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include -#include - -#include -#include -#include - -// Store log messages in circular buffer. -// Useful for storing debug data in case of error/warning happens. - -namespace spdlog { -namespace details { -class SPDLOG_API backtracer -{ - mutable std::mutex mutex_; - std::atomic enabled_{false}; - circular_q messages_; - -public: - backtracer() = default; - backtracer(const backtracer &other); - - backtracer(backtracer &&other) noexcept; - backtracer &operator=(backtracer other); - - void enable(size_t size); - void disable(); - bool enabled() const; - void push_back(const log_msg &msg); - - // pop all items in the q and apply the given fun on each of them. - void foreach_pop(std::function fun); -}; - -} // namespace details -} // namespace spdlog diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h index c6a012a0..99455368 100644 --- a/include/spdlog/details/registry.h +++ b/include/spdlog/details/registry.h @@ -101,7 +101,6 @@ private: std::unique_ptr periodic_flusher_; std::shared_ptr default_logger_; bool automatic_registration_ = true; - size_t backtrace_n_messages_ = 0; }; } // namespace details diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h index 92c82b11..d596d568 100644 --- a/include/spdlog/logger.h +++ b/include/spdlog/logger.h @@ -16,7 +16,6 @@ #include #include -#include #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #include @@ -148,27 +147,26 @@ public: 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) + + if (!log_enabled) { return; } details::log_msg log_msg(log_time, loc, name_, lvl, msg); - log_it_(log_msg, log_enabled, traceback_enabled); + log_it_(log_msg, log_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) + if (!log_enabled) { return; } details::log_msg log_msg(loc, name_, lvl, msg); - log_it_(log_msg, log_enabled, traceback_enabled); + log_it_(log_msg, log_enabled); } void log(level::level_enum lvl, string_view_t msg) @@ -230,8 +228,7 @@ public: void log(source_loc loc, level::level_enum lvl, wstring_view_t fmt, const Args &... args) { bool log_enabled = should_log(lvl); - bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) + if (!log_enabled) { return; } @@ -244,7 +241,7 @@ public: 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); + log_it_(log_msg, log_enabled); } SPDLOG_LOGGER_CATCH() } @@ -254,8 +251,7 @@ public: 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) + if (!log_enabled) { return; } @@ -265,7 +261,7 @@ public: 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); + log_it_(log_msg, log_enabled); } SPDLOG_LOGGER_CATCH() } @@ -278,12 +274,6 @@ public: 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; @@ -296,12 +286,6 @@ public: 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); @@ -324,15 +308,13 @@ protected: 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 void log_(source_loc loc, level::level_enum lvl, const FormatString &fmt, const Args &... args) { bool log_enabled = should_log(lvl); - bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) + if (!log_enabled) { return; } @@ -341,17 +323,15 @@ protected: memory_buf_t buf; fmt::format_to(buf, fmt, args...); details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); - log_it_(log_msg, log_enabled, traceback_enabled); + log_it_(log_msg, log_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); + void log_it_(const details::log_msg &log_msg, bool log_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. diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index 1a72f723..831212f9 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -58,15 +58,6 @@ SPDLOG_API void set_formatter(std::unique_ptr formatter); // example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v"); SPDLOG_API void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local); -// enable global backtrace support -SPDLOG_API void enable_backtrace(size_t n_messages); - -// disable global backtrace support -SPDLOG_API void disable_backtrace(); - -// call dump backtrace on default logger -SPDLOG_API void dump_backtrace(); - // Set global logging level SPDLOG_API void set_level(level::level_enum log_level); diff --git a/src/backtracer.cpp b/src/backtracer.cpp deleted file mode 100644 index a8bcf21b..00000000 --- a/src/backtracer.cpp +++ /dev/null @@ -1,66 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#include - -namespace spdlog { -namespace details { -SPDLOG_INLINE backtracer::backtracer(const backtracer &other) -{ - std::lock_guard lock(other.mutex_); - enabled_ = other.enabled(); - messages_ = other.messages_; -} - -SPDLOG_INLINE backtracer::backtracer(backtracer &&other) noexcept -{ - std::lock_guard lock(other.mutex_); - enabled_ = other.enabled(); - messages_ = std::move(other.messages_); -} - -SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other) -{ - std::lock_guard lock(mutex_); - enabled_ = other.enabled(); - messages_ = std::move(other.messages_); - return *this; -} - -SPDLOG_INLINE void backtracer::enable(size_t size) -{ - std::lock_guard lock{mutex_}; - enabled_.store(true, std::memory_order_relaxed); - messages_ = circular_q{size}; -} - -SPDLOG_INLINE void backtracer::disable() -{ - std::lock_guard lock{mutex_}; - enabled_.store(false, std::memory_order_relaxed); -} - -SPDLOG_INLINE bool backtracer::enabled() const -{ - return enabled_.load(std::memory_order_relaxed); -} - -SPDLOG_INLINE void backtracer::push_back(const log_msg &msg) -{ - std::lock_guard lock{mutex_}; - messages_.push_back(log_msg_buffer{msg}); -} - -// pop all items in the q and apply the given fun on each of them. -SPDLOG_INLINE void backtracer::foreach_pop(std::function fun) -{ - std::lock_guard lock{mutex_}; - while (!messages_.empty()) - { - auto &front_msg = messages_.front(); - fun(front_msg); - messages_.pop_front(); - } -} -} // namespace details -} // namespace spdlog diff --git a/src/details/registry.cpp b/src/details/registry.cpp index eff47654..222a2235 100644 --- a/src/details/registry.cpp +++ b/src/details/registry.cpp @@ -65,11 +65,6 @@ SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr new_logge new_logger->set_level(levels_.get(new_logger->name())); new_logger->flush_on(flush_level_); - if (backtrace_n_messages_ > 0) - { - new_logger->enable_backtrace(backtrace_n_messages_); - } - if (automatic_registration_) { register_logger_(std::move(new_logger)); @@ -138,27 +133,6 @@ SPDLOG_INLINE void registry::set_formatter(std::unique_ptr formatter) } } -SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) -{ - std::lock_guard lock(logger_map_mutex_); - backtrace_n_messages_ = n_messages; - - for (auto &l : loggers_) - { - l.second->enable_backtrace(n_messages); - } -} - -SPDLOG_INLINE void registry::disable_backtrace() -{ - std::lock_guard lock(logger_map_mutex_); - backtrace_n_messages_ = 0; - for (auto &l : loggers_) - { - l.second->disable_backtrace(); - } -} - SPDLOG_INLINE void registry::set_level(level::level_enum log_level) { std::lock_guard lock(logger_map_mutex_); diff --git a/src/logger.cpp b/src/logger.cpp index c7cd18e2..9117ac4e 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -3,10 +3,10 @@ #include #include -#include #include #include +#include #include namespace spdlog { @@ -18,7 +18,6 @@ SPDLOG_INLINE logger::logger(const logger &other) , 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) noexcept @@ -27,8 +26,6 @@ SPDLOG_INLINE logger::logger(logger &&other) noexcept , 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) noexcept @@ -47,13 +44,10 @@ SPDLOG_INLINE void logger::swap(spdlog::logger &other) noexcept 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) @@ -101,23 +95,6 @@ SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type ti 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() { @@ -160,16 +137,12 @@ SPDLOG_INLINE std::shared_ptr logger::clone(std::string logger_name) } // protected methods -SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool log_enabled, bool traceback_enabled) +SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool log_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) @@ -204,17 +177,6 @@ SPDLOG_INLINE void logger::flush_() } } -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); diff --git a/src/spdlog-inl.cpp b/src/spdlog-inl.cpp index 32806ac1..aeb5a53f 100644 --- a/src/spdlog-inl.cpp +++ b/src/spdlog-inl.cpp @@ -27,21 +27,6 @@ SPDLOG_INLINE void set_pattern(std::string pattern, pattern_time_type time_type) set_formatter(std::unique_ptr(new pattern_formatter(std::move(pattern), time_type))); } -SPDLOG_INLINE void enable_backtrace(size_t n_messages) -{ - details::registry::instance().enable_backtrace(n_messages); -} - -SPDLOG_INLINE void disable_backtrace() -{ - details::registry::instance().disable_backtrace(); -} - -SPDLOG_INLINE void dump_backtrace() -{ - default_logger_raw()->dump_backtrace(); -} - SPDLOG_INLINE void set_level(level::level_enum log_level) { details::registry::instance().set_level(log_level); diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index fcfd8898..1ff88b94 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -30,7 +30,6 @@ set(SPDLOG_UTESTS_SOURCES test_dup_filter.cpp test_fmt_helper.cpp test_stdout_api.cpp - test_backtrace.cpp test_create_dir.cpp test_cfg.cpp test_time_point.cpp) diff --git a/tests/test_backtrace.cpp b/tests/test_backtrace.cpp deleted file mode 100644 index 89f4426d..00000000 --- a/tests/test_backtrace.cpp +++ /dev/null @@ -1,65 +0,0 @@ -#include "includes.h" -#include "test_sink.h" -#include "spdlog/async.h" - -TEST_CASE("bactrace1", "[bactrace]") -{ - - using spdlog::sinks::test_sink_st; - auto test_sink = std::make_shared(); - size_t backtrace_size = 5; - - spdlog::logger logger("test-backtrace", test_sink); - logger.set_pattern("%v"); - logger.enable_backtrace(backtrace_size); - - logger.info("info message"); - for (int i = 0; i < 100; i++) - logger.debug("debug message {}", i); - - REQUIRE(test_sink->lines().size() == 1); - REQUIRE(test_sink->lines()[0] == "info message"); - - logger.dump_backtrace(); - REQUIRE(test_sink->lines().size() == backtrace_size + 3); - REQUIRE(test_sink->lines()[1] == "****************** Backtrace Start ******************"); - REQUIRE(test_sink->lines()[2] == "debug message 95"); - REQUIRE(test_sink->lines()[3] == "debug message 96"); - REQUIRE(test_sink->lines()[4] == "debug message 97"); - REQUIRE(test_sink->lines()[5] == "debug message 98"); - REQUIRE(test_sink->lines()[6] == "debug message 99"); - REQUIRE(test_sink->lines()[7] == "****************** Backtrace End ********************"); -} - -TEST_CASE("bactrace-async", "[bactrace]") -{ - using spdlog::sinks::test_sink_mt; - auto test_sink = std::make_shared(); - using spdlog::details::os::sleep_for_millis; - - size_t backtrace_size = 5; - - spdlog::init_thread_pool(120, 1); - auto logger = std::make_shared("test-bactrace-async", test_sink, spdlog::thread_pool()); - logger->set_pattern("%v"); - logger->enable_backtrace(backtrace_size); - - logger->info("info message"); - for (int i = 0; i < 100; i++) - logger->debug("debug message {}", i); - - sleep_for_millis(10); - REQUIRE(test_sink->lines().size() == 1); - REQUIRE(test_sink->lines()[0] == "info message"); - - logger->dump_backtrace(); - sleep_for_millis(100); // give time for the async dump to complete - REQUIRE(test_sink->lines().size() == backtrace_size + 3); - REQUIRE(test_sink->lines()[1] == "****************** Backtrace Start ******************"); - REQUIRE(test_sink->lines()[2] == "debug message 95"); - REQUIRE(test_sink->lines()[3] == "debug message 96"); - REQUIRE(test_sink->lines()[4] == "debug message 97"); - REQUIRE(test_sink->lines()[5] == "debug message 98"); - REQUIRE(test_sink->lines()[6] == "debug message 99"); - REQUIRE(test_sink->lines()[7] == "****************** Backtrace End ********************"); -}