Merge branch 'v1.x' into v1.x

include/spdlog/details/pattern_formatter-inl.h

@@ -84,9 +84,7 @@ private:
     const padding_info &padinfo_;
     fmt::memory_buffer &dest_;
     size_t total_pad_;
-    string_view_t spaces_{"                                                                "
-                          "                                                                ",
-        128};
+    string_view_t spaces_{"                                                                ", 64};
 };
 
 class name_formatter : public flag_formatter
@@ -1217,7 +1215,7 @@ SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_(std::stri
 {
     using details::padding_info;
     using details::scoped_pad;
-    const size_t max_width = 128;
+    const size_t max_width = 64;
     if (it == end)
     {
         return padding_info{};

include/spdlog/sinks/ansicolor_sink-inl.h

@@ -16,6 +16,7 @@ template<typename ConsoleMutex>
 SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, color_mode mode)
     : target_file_(target_file)
     , mutex_(ConsoleMutex::mutex())
+    , formatter_(details::make_unique<spdlog::pattern_formatter>())
 
 {
     set_color_mode(mode);

include/spdlog/sinks/ansicolor_sink.h

@@ -79,6 +79,7 @@ private:
     FILE *target_file_;
     mutex_t &mutex_;
     bool should_do_colors_;
+    std::unique_ptr<spdlog::formatter> formatter_;
     std::unordered_map<level::level_enum, string_view_t, level::level_hasher> colors_;
     void print_ccode_(const string_view_t &color_code);
     void print_range_(const fmt::memory_buffer &formatted, size_t start, size_t end);

include/spdlog/sinks/base_sink-inl.h

@@ -10,6 +10,18 @@
 #include "spdlog/common.h"
 #include "spdlog/details/pattern_formatter.h"
 
+#include <memory>
+
+template<typename Mutex>
+SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink()
+    : formatter_{details::make_unique<spdlog::pattern_formatter>()}
+{}
+
+template<typename Mutex>
+SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink(std::unique_ptr<spdlog::formatter> formatter)
+    : formatter_{std::move(formatter)}
+{}
+
 template<typename Mutex>
 void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg)
 {

include/spdlog/sinks/base_sink.h

@@ -19,7 +19,8 @@ template<typename Mutex>
 class base_sink : public sink
 {
 public:
-    base_sink() = default;
+    base_sink();
+    explicit base_sink(std::unique_ptr<spdlog::formatter> formatter);
     base_sink(const base_sink &) = delete;
     base_sink &operator=(const base_sink &) = delete;
     void log(const details::log_msg &msg) final;
@@ -28,11 +29,14 @@ public:
     void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final;
 
 protected:
+    // sink formatter
+    std::unique_ptr<spdlog::formatter> formatter_;
+    Mutex mutex_;
+
     virtual void sink_it_(const details::log_msg &msg) = 0;
     virtual void flush_() = 0;
     virtual void set_pattern_(const std::string &pattern);
     virtual void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter);
-    Mutex mutex_;
 };
 } // namespace sinks
 } // namespace spdlog

include/spdlog/sinks/basic_file_sink-inl.h

@@ -29,7 +29,7 @@ template<typename Mutex>
 SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg)
 {
     fmt::memory_buffer formatted;
-    sink::formatter_->format(msg, formatted);
+    base_sink<Mutex>::formatter_->format(msg, formatted);
     file_helper_.write(formatted);
 }
 

include/spdlog/sinks/daily_file_sink.h

@@ -74,7 +74,7 @@ protected:
             rotation_tp_ = next_rotation_tp_();
         }
         fmt::memory_buffer formatted;
-        sink::formatter_->format(msg, formatted);
+        base_sink<Mutex>::formatter_->format(msg, formatted);
         file_helper_.write(formatted);
     }
 

include/spdlog/sinks/dist_sink.h

@@ -6,6 +6,7 @@
 #include "base_sink.h"
 #include "spdlog/details/log_msg.h"
 #include "spdlog/details/null_mutex.h"
+#include "spdlog/details/pattern_formatter.h"
 
 #include <algorithm>
 #include <memory>

include/spdlog/sinks/dup_filter_sink.h

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include "dist_sink.h"
+#include "spdlog/details/null_mutex.h"
+#include "spdlog/details/log_msg.h"
+
+#include <mutex>
+#include <string>
+#include <chrono>
+
+// Duplicate message removal sink.
+// Skip the message if previous one is identical and less than "max_skip_duration" have passed
+//
+// Example:
+//
+//     #include "spdlog/sinks/dup_filter_sink.h"
+//
+//     int main() {
+//         auto dup_filter = std::make_shared<dup_filter_sink_st>(std::chrono::seconds(5));
+//         dup_filter->add_sink(std::make_shared<stdout_color_sink_mt>());
+//         spdlog::logger l("logger", dup_filter);
+//         l.info("Hello");
+//         l.info("Hello");
+//         l.info("Hello");
+//         l.info("Different Hello");
+//     }
+//
+// Will produce:
+//       [2019-06-25 17:50:56.511] [logger] [info] Hello
+//       [2019-06-25 17:50:56.512] [logger] [info] Skipped 3 duplicate messages..
+//       [2019-06-25 17:50:56.512] [logger] [info] Different Hello
+
+namespace spdlog {
+namespace sinks {
+template<typename Mutex>
+class dup_filter_sink : public dist_sink<Mutex>
+{
+public:
+    template<class Rep, class Period>
+    explicit dup_filter_sink(std::chrono::duration<Rep, Period> max_skip_duration)
+        : max_skip_duration_{max_skip_duration}
+    {}
+
+protected:
+    std::chrono::microseconds max_skip_duration_;
+    log_clock::time_point last_msg_time_;
+    std::string last_msg_payload_;
+    size_t skip_counter_ = 0;
+
+    void sink_it_(const details::log_msg &msg) override
+    {
+        bool filtered = filter_(msg);
+        if (!filtered)
+        {
+            skip_counter_ += 1;
+            return;
+        }
+
+        // log the "skipped.." message
+        if (skip_counter_ > 0)
+        {
+            fmt::basic_memory_buffer<char, 64> buf;
+            fmt::format_to(buf, "Skipped {} duplicate messages..", skip_counter_);
+            details::log_msg skipped_msg{msg.logger_name, msg.level, string_view_t{buf.data(), buf.size()}};
+            dist_sink<Mutex>::sink_it_(skipped_msg);
+        }
+
+        // log current message
+        dist_sink<Mutex>::sink_it_(msg);
+        last_msg_time_ = msg.time;
+        skip_counter_ = 0;
+        last_msg_payload_.assign(msg.payload.data(), msg.payload.data() + msg.payload.size());
+    }
+
+    // return whether the log msg should be displayed (true) or skipped (false)
+    bool filter_(const details::log_msg &msg)
+    {
+        auto filter_duration = msg.time - last_msg_time_;
+        return (filter_duration > max_skip_duration_) || (msg.payload != last_msg_payload_);
+    }
+};
+
+using dup_filter_sink_mt = dup_filter_sink<std::mutex>;
+using dup_filter_sink_st = dup_filter_sink<details::null_mutex>;
+
+} // namespace sinks
+} // namespace spdlog

include/spdlog/sinks/msvc_sink.h

@@ -29,7 +29,7 @@ protected:
     {
 
         fmt::memory_buffer formatted;
-        sink::formatter_->format(msg, formatted);
+        base_sink<Mutex>::formatter_->format(msg, formatted);
         OutputDebugStringA(fmt::to_string(formatted).c_str());
     }
 

include/spdlog/sinks/ostream_sink.h

@@ -26,7 +26,7 @@ protected:
     void sink_it_(const details::log_msg &msg) override
     {
         fmt::memory_buffer formatted;
-        sink::formatter_->format(msg, formatted);
+        base_sink<Mutex>::formatter_->format(msg, formatted);
         ostream_.write(formatted.data(), static_cast<std::streamsize>(formatted.size()));
         if (force_flush_)
         {

include/spdlog/sinks/rotating_file_sink-inl.h

@@ -67,7 +67,7 @@ template<typename Mutex>
 SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &msg)
 {
     fmt::memory_buffer formatted;
-    sink::formatter_->format(msg, formatted);
+    base_sink<Mutex>::formatter_->format(msg, formatted);
     current_size_ += formatted.size();
     if (current_size_ > max_size_)
     {

include/spdlog/sinks/sink-inl.h

@@ -8,15 +8,6 @@
 #endif
 
 #include "spdlog/common.h"
-#include "spdlog/details/pattern_formatter.h"
-
-SPDLOG_INLINE spdlog::sinks::sink::sink()
-    : formatter_{details::make_unique<spdlog::pattern_formatter>()}
-{}
-
-SPDLOG_INLINE spdlog::sinks::sink::sink(std::unique_ptr<spdlog::formatter> formatter)
-    : formatter_{std::move(formatter)}
-{}
 
 SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const
 {
@@ -25,7 +16,7 @@ SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg
 
 SPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level)
 {
-    level_.store(log_level);
+    level_.store(log_level, std::memory_order_relaxed);
 }
 
 SPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const

include/spdlog/sinks/sink.h

@@ -12,27 +12,19 @@ namespace sinks {
 class sink
 {
 public:
-    sink();
-
-    explicit sink(std::unique_ptr<spdlog::formatter> formatter);
     virtual ~sink() = default;
     virtual void log(const details::log_msg &msg) = 0;
     virtual void flush() = 0;
     virtual void set_pattern(const std::string &pattern) = 0;
     virtual void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) = 0;
 
-    bool should_log(level::level_enum msg_level) const;
-
     void set_level(level::level_enum log_level);
-
     level::level_enum level() const;
+    bool should_log(level::level_enum msg_level) const;
 
 protected:
     // sink log level - default is all
     level_t level_{level::trace};
-
-    // sink formatter
-    std::unique_ptr<spdlog::formatter> formatter_;
 };
 
 } // namespace sinks

include/spdlog/sinks/stdout_sinks-inl.h

@@ -3,10 +3,6 @@
 
 #pragma once
 
-#ifndef SPDLOG_HEADER_ONLY
-#include "spdlog/sinks/stdout_sinks.h"
-#endif
-
 #include "spdlog/details/console_globals.h"
 #include <memory>
 
@@ -18,6 +14,7 @@ template<typename ConsoleMutex>
 SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
     : mutex_(ConsoleMutex::mutex())
     , file_(file)
+    , formatter_(details::make_unique<spdlog::pattern_formatter>())
 {}
 
 template<typename ConsoleMutex>

include/spdlog/sinks/stdout_sinks.h

@@ -28,9 +28,10 @@ public:
 
     void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;
 
-private:
+protected:
     mutex_t &mutex_;
     FILE *file_;
+    std::unique_ptr<spdlog::formatter> formatter_;
 };
 
 template<typename ConsoleMutex>
@@ -70,6 +71,5 @@ std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name);
 
 } // namespace spdlog
 
-#ifdef SPDLOG_HEADER_ONLY
 #include "stdout_sinks-inl.h"
-#endif
+

include/spdlog/sinks/syslog_sink.h

@@ -52,7 +52,7 @@ protected:
         if (enable_formatting_)
         {
             fmt::memory_buffer formatted;
-            sink::formatter_->format(msg, formatted);
+            base_sink<Mutex>::formatter_->format(msg, formatted);
             payload = string_view_t(formatted.data(), formatted.size());
         }
         else

include/spdlog/sinks/wincolor_sink-inl.h

@@ -8,6 +8,7 @@
 #endif
 
 #include "spdlog/common.h"
+#include "spdlog/details/pattern_formatter.h"
 
 namespace spdlog {
 namespace sinks {
@@ -16,6 +17,7 @@ template<typename ConsoleMutex>
 SPDLOG_INLINE wincolor_sink<ConsoleMutex>::wincolor_sink(HANDLE out_handle, color_mode mode)
     : out_handle_(out_handle)
     , mutex_(ConsoleMutex::mutex())
+    , formatter_(details::make_unique<spdlog::pattern_formatter>())
 {
     set_color_mode(mode);
     colors_[level::trace] = WHITE;

include/spdlog/sinks/wincolor_sink.h

@@ -45,11 +45,12 @@ public:
     void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override final;
     void set_color_mode(color_mode mode);
 
-private:
+protected:
     using mutex_t = typename ConsoleMutex::mutex_t;
     HANDLE out_handle_;
     mutex_t &mutex_;
     bool should_do_colors_;
+    std::unique_ptr<spdlog::formatter> formatter_;
     std::unordered_map<level::level_enum, WORD, level::level_hasher> colors_;
 
     // set color and return the orig console attributes (for resetting later)

src/spdlog.cpp

@@ -80,30 +80,6 @@ template std::shared_ptr<spdlog::logger> spdlog::stdout_color_st<spdlog::async_f
 template std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt<spdlog::async_factory>(const std::string &logger_name, color_mode mode);
 template std::shared_ptr<spdlog::logger> spdlog::stderr_color_st<spdlog::async_factory>(const std::string &logger_name, color_mode mode);
 
-//
-// stdout/stderr sinks
-//
-#include "spdlog/sinks/stdout_sinks-inl.h"
-
-template class spdlog::sinks::stdout_sink_base<spdlog::details::console_mutex>;
-template class spdlog::sinks::stdout_sink_base<spdlog::details::console_nullmutex>;
-
-template class spdlog::sinks::stdout_sink<spdlog::details::console_mutex>;
-template class spdlog::sinks::stdout_sink<spdlog::details::console_nullmutex>;
-
-template class spdlog::sinks::stderr_sink<spdlog::details::console_mutex>;
-template class spdlog::sinks::stderr_sink<spdlog::details::console_nullmutex>;
-
-// factory methods for stdout/stderr loggers
-template std::shared_ptr<spdlog::logger> spdlog::stdout_logger_mt<spdlog::synchronous_factory>(const std::string &logger_name);
-template std::shared_ptr<spdlog::logger> spdlog::stdout_logger_st<spdlog::synchronous_factory>(const std::string &logger_name);
-template std::shared_ptr<spdlog::logger> spdlog::stdout_logger_mt<spdlog::async_factory>(const std::string &logger_name);
-template std::shared_ptr<spdlog::logger> spdlog::stdout_logger_st<spdlog::async_factory>(const std::string &logger_name);
-
-template std::shared_ptr<spdlog::logger> spdlog::stderr_logger_mt<spdlog::synchronous_factory>(const std::string &logger_name);
-template std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st<spdlog::synchronous_factory>(const std::string &logger_name);
-template std::shared_ptr<spdlog::logger> spdlog::stderr_logger_mt<spdlog::async_factory>(const std::string &logger_name);
-template std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st<spdlog::async_factory>(const std::string &logger_name);
 
 // Slightly modified version of fmt lib's format.cc source file.
 // Copyright (c) 2012 - 2016, Victor Zverovich

tests/CMakeLists.txt

@@ -14,7 +14,8 @@ set(SPDLOG_UTESTS_SOURCES
     test_mpmc_q.cpp
     test_sink.h
     test_fmt_helper.cpp
-    test_stdout_api.cpp)
+  	test_stdout_api.cpp
+    test_dup_filter.cpp)
 
 file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/logs")
 enable_testing()

tests/test_dup_filter.cpp

+#include "includes.h"
+#include "spdlog/sinks/dup_filter_sink.h"
+#include "test_sink.h"
+
+using namespace spdlog;
+using namespace spdlog::sinks;
+
+TEST_CASE("dup_filter_test1", "[dup_filter_sink]")
+{
+    dup_filter_sink_st dup_sink{std::chrono::seconds{5}};
+    auto test_sink = std::make_shared<test_sink_mt>();
+    dup_sink.add_sink(test_sink);
+
+    for (int i = 0; i < 10; i++)
+    {
+        dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+    }
+
+    REQUIRE(test_sink->msg_counter() == 1);
+}
+
+TEST_CASE("dup_filter_test2", "[dup_filter_sink]")
+{
+    dup_filter_sink_st dup_sink{std::chrono::seconds{0}};
+    auto test_sink = std::make_shared<test_sink_mt>();
+    dup_sink.add_sink(test_sink);
+
+    for (int i = 0; i < 10; i++)
+    {
+        dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+        std::this_thread::sleep_for(std::chrono::milliseconds(5));
+    }
+
+    REQUIRE(test_sink->msg_counter() == 10);
+}
+
+TEST_CASE("dup_filter_test3", "[dup_filter_sink]")
+{
+    dup_filter_sink_st dup_sink{std::chrono::seconds{1}};
+    auto test_sink = std::make_shared<test_sink_mt>();
+    dup_sink.add_sink(test_sink);
+
+    for (int i = 0; i < 10; i++)
+    {
+        dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+        dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message2"});
+    }
+
+    REQUIRE(test_sink->msg_counter() == 20);
+}
+
+TEST_CASE("dup_filter_test4", "[dup_filter_sink]")
+{
+    dup_filter_sink_mt dup_sink{std::chrono::milliseconds{10}};
+    auto test_sink = std::make_shared<test_sink_mt>();
+    dup_sink.add_sink(test_sink);
+
+    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message"});
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message"});
+    REQUIRE(test_sink->msg_counter() == 2);
+}
+
+TEST_CASE("dup_filter_test5", "[dup_filter_sink]")
+{
+    dup_filter_sink_mt dup_sink{std::chrono::seconds{5}};
+    auto test_sink = std::make_shared<test_sink_mt>();
+    dup_sink.add_sink(test_sink);
+
+    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message2"});
+
+    REQUIRE(test_sink->msg_counter() == 3); // skip 2 messages but log the "skipped.." message before message2
+}

tests/test_pattern_formatter.cpp

@@ -183,16 +183,14 @@ TEST_CASE("left_padded_huge", "[pattern_formatter]")
 {
     REQUIRE(
         log_to_str("Some message", "[%-300n] %v", spdlog::pattern_time_type::local, "\n") ==
-        "[pattern_tester                                                                                                                  ]"
-        " Some message\n");
+            "[pattern_tester                                                  ] Some message\n");
 }
 
 TEST_CASE("left_padded_max", "[pattern_formatter]")
 {
     REQUIRE(
-        log_to_str("Some message", "[%-128n] %v", spdlog::pattern_time_type::local, "\n") ==
-        "[pattern_tester                                                                                                                  ]"
-        " Some message\n");
+        log_to_str("Some message", "[%-64n] %v", spdlog::pattern_time_type::local, "\n") ==
+            "[pattern_tester                                                  ] Some message\n");
 }
 
 TEST_CASE("clone-default-formatter", "[pattern_formatter]")