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

@@ -0,0 +1,74 @@
+// 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

@@ -21,71 +21,25 @@ namespace spdlog {
 
 public:
     backtracer() = default;
-            backtracer(const backtracer& other)
-            {
-                std::lock_guard<std::mutex> lock(other.mutex_);
-                enabled_ = other.enabled();
-                messages_ = other.messages_;
-            }
-
-            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 };
-            }
+    backtracer(const backtracer &other);
 
 
-            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 spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "backtracer-inl.h"
+#endif

include/spdlog/details/circular_q.h

@@ -28,8 +28,6 @@ namespace spdlog {
         , v_(max_items_)
     {}
 
-
-
     circular_q(const circular_q &) = default;
     circular_q &operator=(const circular_q &) = default;
 
@@ -46,7 +44,6 @@ namespace spdlog {
         return *this;
     }
 
-
     // push back, overrun (oldest) item if no room left
     void push_back(T &&item)
     {
@@ -96,11 +93,9 @@ namespace spdlog {
         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 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);
     }
 };
 

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)
 {