From 7f3b5fb84dc1fae3b03fd3ae2d1b06835752823a Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Thu, 27 Jun 2019 17:17:25 +0300
Subject: [PATCH] Fix dup filter

---
 include/spdlog/sinks/dup_filter_sink.h | 75 +++++++++++++-------------
 1 file changed, 39 insertions(+), 36 deletions(-)

diff --git a/include/spdlog/sinks/dup_filter_sink.h b/include/spdlog/sinks/dup_filter_sink.h
index 309c639e..67a171ef 100644
--- a/include/spdlog/sinks/dup_filter_sink.h
+++ b/include/spdlog/sinks/dup_filter_sink.h
@@ -7,24 +7,30 @@
 #include "spdlog/details/null_mutex.h"
 #include "spdlog/details/log_msg.h"
 
+#include <mutex>
 #include <string>
 #include <chrono>
 
-// Duplicate remove sink.
-// Filter the message if previous one is identical and less than max max_skip_duration have passed
+// Duplicate message removal sink.
+// Skip the message if previous one is identical and less than "max_skip_duration" have passed
 //
 // Example:
-//     auto d = std::make_shared<dup_filter_sink_st>(std::chrono::seconds(5));
-//     d->add_sink(std::make_shared<stdout_color_sink_mt>());
-//     spdlog::logger l("logger", d);
-//     l.info("Hello");
-//     l.info("Hello");
-//     l.info("Hello");
-//     l.info("Different Hello");
+//
+//     #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] 3 duplicate messages..
+//       [2019-06-25 17:50:56.512] [logger] [info] Skipped 3 duplicate messages..
 //       [2019-06-25 17:50:56.512] [logger] [info] Different Hello
 
 
@@ -36,54 +42,51 @@ class dup_filter_sink : public dist_sink<Mutex>
 {
 public:
     template<class Rep, class Period>
-    explicit dup_filter_sink(std::chrono::duration<Rep, Period> max_ignore_duration)
-        : max_skip_duration_{max_ignore_duration}
-        , last_msg_time_{log_clock::now()}
-        , skip_counter_{0}
+    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_;
-    size_t skip_counter_;
     std::string last_msg_payload_;
+    size_t skip_counter_ = 0;
 
     void sink_it_(const details::log_msg &msg) override
     {
-        auto msg_time = msg.time;
-        auto delta_time = msg_time - last_msg_time_;
-        last_msg_time_ = msg_time;
-
-        if (delta_time < max_skip_duration_ && last_msg_payload_ == msg.payload)
+        bool filtered = filter_(msg);
+        if(!filtered)
         {
-            skip_counter_++;
+            skip_counter_ += 1;
             return;
         }
 
-        // got different message from the previous
-        if (skip_counter_ > 0)
+        // log the "skipped.." message
+        if(skip_counter_ > 0)
         {
-            fmt::basic_memory_buffer<char, 80> buf;
-            fmt::format_to(buf, "{} duplicate messages..", skip_counter_);
+            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()}};
-
-            // log the skip notification
-            for (auto &sink : dist_sink<Mutex>::sinks_)
-            {
-                if (sink->should_log(msg.level))
-                {
-                    sink->log(skipped_msg);
-                }
-            }
-            skip_counter_ = 0;
+            dist_sink<Mutex>::sink_it_(skipped_msg);
         }
 
-        last_msg_payload_.assign(msg.payload.data(), msg.payload.data() + msg.payload.size());
+        // 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