wip backtracer

bench/bench.cpp

@@ -59,7 +59,6 @@ void bench_threaded_logging(int threads, int iters)
     daily_mt_tracing->enable_backtrace(32);
     bench_mt(iters, std::move(daily_mt_tracing), threads);
 
-
     spdlog::info("");
     auto empty_logger = std::make_shared<spdlog::logger>("level-off");
     empty_logger->set_level(spdlog::level::off);
@@ -68,7 +67,6 @@ void bench_threaded_logging(int threads, int iters)
     empty_logger_tracing->set_level(spdlog::level::off);
     empty_logger_tracing->enable_backtrace(32);
     bench(iters, empty_logger_tracing);
-
 }
 
 void bench_single_threaded(int iters)
@@ -77,7 +75,6 @@ void bench_single_threaded(int iters)
     spdlog::info("Single threaded: {:n} messages", iters);
     spdlog::info("**************************************************************");
 
-
     auto basic_st = spdlog::basic_logger_st("basic_st", "logs/basic_st.log", true);
     bench(iters, std::move(basic_st));
 

include/spdlog/details/backtracer-inl.h

+// 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/details/backtracer.h"
+#endif
+namespace spdlog {
+namespace details {
+SPDLOG_INLINE backtracer::backtracer(const backtracer &other)
+{
+    std::lock_guard<std::mutex> lock(other.mutex_);
+    enabled_ = other.enabled();
+    messages_ = other.messages_;
+}
+
+SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT
+{
+    std::lock_guard<std::mutex> lock(other.mutex_);
+    enabled_ = other.enabled();
+    messages_ = std::move(other.messages_);
+}
+
+SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other)
+{
+    std::lock_guard<std::mutex> lock(mutex_);
+    enabled_ = other.enabled();
+    messages_ = other.messages_;
+    return *this;
+}
+
+SPDLOG_INLINE void backtracer::enable(size_t size)
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    enabled_.store(true, std::memory_order_relaxed);
+    messages_ = circular_q<log_msg_buffer>{size};
+}
+
+SPDLOG_INLINE void backtracer::disable()
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    enabled_.store(false, std::memory_order_relaxed);
+}
+
+SPDLOG_INLINE bool backtracer::enabled() const
+{
+    return enabled_.load(std::memory_order_relaxed);
+}
+
+SPDLOG_INLINE backtracer::operator bool() const
+{
+    return enabled();
+}
+
+SPDLOG_INLINE void backtracer::push_back(const log_msg &msg)
+{
+    std::lock_guard<std::mutex> 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<void(const details::log_msg &)> fun)
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    while (!messages_.empty())
+    {
+        log_msg_buffer popped;
+        messages_.pop_front(popped);
+        fun(popped);
+    }
+}
+} // namespace details
+} // namespace spdlog

include/spdlog/details/backtracer.h

@@ -12,80 +12,34 @@
 // Useful for storing debug data in case of error/warning happens.
 
 namespace spdlog {
-    namespace details {
-        class backtracer
-        {
+namespace details {
+class backtracer
+{
     mutable std::mutex mutex_;
-            std::atomic<bool> enabled_ {false};      
+    std::atomic<bool> enabled_{false};
     circular_q<log_msg_buffer> messages_;
 
-        public:
+public:
     backtracer() = default;
-            backtracer(const backtracer& other)
-            {
-                std::lock_guard<std::mutex> lock(other.mutex_);
-                enabled_ = other.enabled();
-                messages_ = other.messages_;
-            }
+    backtracer(const backtracer &other);
 
-            backtracer(backtracer&& other) SPDLOG_NOEXCEPT             
-            {
-                std::lock_guard<std::mutex> lock(other.mutex_);
-                enabled_ = other.enabled();
-                messages_ = std::move(other.messages_);
-            }
 
-            backtracer& operator=(backtracer other)
-            {
-                std::lock_guard<std::mutex> lock(mutex_);
-                enabled_ = other.enabled();
-                messages_ = other.messages_;
-                return *this;
-            }
-
-            void enable(size_t size)
-            {
-                std::lock_guard<std::mutex> lock{ mutex_ };
-                enabled_.store(true, std::memory_order_relaxed);
-                messages_ = circular_q<log_msg_buffer>{ size };
-            }
-
-
-            void disable()
-            {
-                std::lock_guard<std::mutex> lock{ mutex_ };
-                enabled_.store(false, std::memory_order_relaxed);
-            }
-
-
-            bool enabled() const
-            {
-                return enabled_.load(std::memory_order_relaxed);
-            }
-
-            explicit operator bool() const
-            {
-                return enabled();
-            }
-
-            void push_back(const log_msg &msg)
-            {
-                std::lock_guard<std::mutex> lock{ mutex_ };
-                messages_.push_back(log_msg_buffer{ msg });
-            }
+    backtracer(backtracer &&other) SPDLOG_NOEXCEPT;
+    backtracer &operator=(backtracer other);
+    void enable(size_t size);
+    void disable();
+    bool enabled() const;
+    explicit operator bool() 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<void(const details::log_msg &)> fun)
-            {
-                std::lock_guard<std::mutex> lock{ mutex_ };
-                while (!messages_.empty())
-                {
-                    log_msg_buffer popped;
-                    messages_.pop_front(popped);
-                    fun(popped);
-                }
-            }
-        };
+    void foreach_pop(std::function<void(const details::log_msg &)> fun);
 
-    } // namespace details
+};
+
+} // namespace details
 } // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "backtracer-inl.h"
+#endif
\ No newline at end of file

include/spdlog/details/circular_q.h

@@ -7,17 +7,17 @@
 #include <vector>
 
 namespace spdlog {
-    namespace details {
-        template<typename T>
-        class circular_q
-        {
+namespace details {
+template<typename T>
+class circular_q
+{
     size_t max_items_ = 0;
     typename std::vector<T>::size_type head_ = 0;
     typename std::vector<T>::size_type tail_ = 0;
     size_t overrun_counter_ = 0;
     std::vector<T> v_;
 
-        public:
+public:
     using item_type = T;
 
     // empty cir
@@ -28,29 +28,26 @@ namespace spdlog {
         , v_(max_items_)
     {}
 
-
-
-            circular_q(const circular_q&) = default;
-            circular_q& operator=(const circular_q&) = default;
+    circular_q(const circular_q &) = default;
+    circular_q &operator=(const circular_q &) = default;
 
     // move cannot be default,
     // since we need to reset head_, tail_, etc to zero in the moved object
-            circular_q(circular_q&& other) SPDLOG_NOEXCEPT
+    circular_q(circular_q &&other) SPDLOG_NOEXCEPT
     {
         copy_moveable(std::move(other));
     }
 
-            circular_q& operator=(circular_q&& other) SPDLOG_NOEXCEPT
+    circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT
     {
         copy_moveable(std::move(other));
         return *this;
     }
 
-
     // push back, overrun (oldest) item if no room left
     void push_back(T &&item)
     {
-                if(max_items_ > 0)
+        if (max_items_ > 0)
         {
             v_[tail_] = std::move(item);
             tail_ = (tail_ + 1) % max_items_;
@@ -67,7 +64,7 @@ namespace spdlog {
     // If there are no elements in the container, the behavior is undefined.
     void pop_front(T &popped_item)
     {
-                if(max_items_ > 0)
+        if (max_items_ > 0)
         {
             popped_item = std::move(v_[head_]);
             head_ = (head_ + 1) % max_items_;
@@ -90,17 +87,15 @@ namespace spdlog {
         return overrun_counter_;
     }
 
-        private:            
-            void copy_moveable(circular_q&& other) SPDLOG_NOEXCEPT
+private:
+    void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT
     {
         max_items_ = other.max_items_;
         head_ = other.head_;
         tail_ = other.tail_;
-                overrun_counter_ = other.overrun_counter_,
-                v_ = std::move(other.v_);                
+        overrun_counter_ = other.overrun_counter_, v_ = std::move(other.v_);
         other.max_items_ = 0; // disable other
     }
-
-        };
-    } // namespace details
+};
+} // namespace details
 } // namespace spdlog

include/spdlog/logger-inl.h

@@ -23,8 +23,7 @@ SPDLOG_INLINE logger::logger(const logger &other)
     , 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_)),

include/spdlog/sinks/daily_file_sink.h

@@ -30,8 +30,8 @@ struct daily_filename_calculator
     {
         filename_t basename, ext;
         std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
-		return fmt::format(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}"), 
-            basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, ext);        
+        return fmt::format(
+            SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}"), basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, ext);
     }
 };
 

include/spdlog/sinks/rotating_file_sink-inl.h

@@ -43,7 +43,7 @@ SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink(
 template<typename Mutex>
 SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::calc_filename(const filename_t &filename, std::size_t index)
 {
-	if(index == 0u)
+    if (index == 0u)
     {
         return filename;
     }

src/spdlog.cpp

@@ -12,7 +12,7 @@
 
 #include "spdlog/spdlog-inl.h"
 #include "spdlog/common-inl.h"
-
+#include "spdlog/details/backtracer-inl.h"
 #include "spdlog/logger-inl.h"
 template spdlog::logger::logger(std::string name, sinks_init_list::iterator begin, sinks_init_list::iterator end);
 

tests/test_misc.cpp

@@ -2,7 +2,6 @@
 #include "test_sink.h"
 #include "spdlog/fmt/bin_to_hex.h"
 
-
 template<class T>
 std::string log_info(const T &what, spdlog::level::level_enum logger_level = spdlog::level::info)
 {
@@ -109,7 +108,7 @@ TEST_CASE("clone-logger", "[clone]")
     logger->info("Some message 1");
     cloned->info("Some message 2");
 
-    REQUIRE(test_sink->lines().size()==2);
+    REQUIRE(test_sink->lines().size() == 2);
     REQUIRE(test_sink->lines()[0] == "Some message 1");
     REQUIRE(test_sink->lines()[1] == "Some message 2");
 
@@ -121,7 +120,7 @@ TEST_CASE("clone async", "[clone]")
     using namespace spdlog;
 
     spdlog::init_thread_pool(4, 1);
-    auto test_sink = std::make_shared<sinks::test_sink_st >();
+    auto test_sink = std::make_shared<sinks::test_sink_st>();
     auto logger = std::make_shared<spdlog::async_logger>("orig", test_sink, spdlog::thread_pool());
     logger->set_pattern("%v");
     auto cloned = logger->clone("clone");
@@ -136,7 +135,7 @@ TEST_CASE("clone async", "[clone]")
 
     spdlog::details::os::sleep_for_millis(10);
 
-    REQUIRE(test_sink->lines().size()==2);
+    REQUIRE(test_sink->lines().size() == 2);
     REQUIRE(test_sink->lines()[0] == "Some message 1");
     REQUIRE(test_sink->lines()[1] == "Some message 2");