[fix] CI error

include/spdlog/logger.h

@@ -132,7 +132,7 @@ public:
     }
 
     template<typename T>
-    void log(const char*tag, level::level_enum lvl, const T &msg)
+    void log(const char* tag, level::level_enum lvl, const T &msg)
     {
         log(tag, source_loc{}, lvl, msg);
     }
@@ -145,7 +145,7 @@ public:
         log(tag, loc, lvl, string_view_t{msg});
     }
 
-    void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, string_view_t msg)
+    void log(log_clock::time_point log_time, const char* tag, source_loc loc, level::level_enum lvl, string_view_t msg)
     {
         bool log_enabled = should_log(lvl);
         bool traceback_enabled = tracer_.enabled();
@@ -155,7 +155,7 @@ public:
         }
 
         details::log_msg log_msg(log_time, loc, name_, lvl, msg);
-        log_it_("", log_msg, log_enabled, traceback_enabled);
+        log_it_(tag, log_msg, log_enabled, traceback_enabled);
     }
 
     void log(const char* tag, source_loc loc, level::level_enum lvl, string_view_t msg)
@@ -180,9 +180,9 @@ public:
     template<class T, typename std::enable_if<!std::is_convertible<const T &, spdlog::string_view_t>::value &&
                                                   !is_convertible_to_wstring_view<const T &>::value,
                           int>::type = 0>
-    void log(source_loc loc, level::level_enum lvl, const T &msg)
+    void log(const char* tag, source_loc loc, level::level_enum lvl, const T &msg)
     {
-        log(loc, lvl, "{}", msg);
+        log(tag, loc, lvl, "{}", msg);
     }
 
     template<typename T>
@@ -394,7 +394,6 @@ protected:
     // handle errors during logging.
     // default handler prints the error to stderr at max rate of 1 message/sec.
     void err_handler_(const std::string &msg);
-    const char* default_tag() { return spdlog_default_tag; }
 };
 
 void swap(logger &a, logger &b);

include/spdlog/sinks/dist_sink.h

@@ -61,7 +61,7 @@ protected:
         {
             if (sink->should_log(msg.level))
             {
-                sink->log(msg);
+                sink->log(tag, msg);
             }
         }
     }

include/spdlog/sinks/dup_filter_sink.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "dist_sink.h"
+#include <spdlog/common.h>
 #include <spdlog/details/null_mutex.h>
 #include <spdlog/details/log_msg.h>
 
@@ -68,12 +69,12 @@ protected:
             if (msg_size > 0 && static_cast<size_t>(msg_size) < sizeof(buf))
             {
                 details::log_msg skipped_msg{msg.logger_name, level::info, string_view_t{buf, static_cast<size_t>(msg_size)}};
-                dist_sink<Mutex>::sink_it_(skipped_msg);
+                dist_sink<Mutex>::sink_it_(tag, skipped_msg);
             }
         }
 
         // log current message
-        dist_sink<Mutex>::sink_it_(msg);
+        dist_sink<Mutex>::sink_it_(spdlog_default_tag, msg);
         last_msg_time_ = msg.time;
         skip_counter_ = 0;
         last_msg_payload_.assign(msg.payload.data(), msg.payload.data() + msg.payload.size());

include/spdlog/sinks/null_sink.h

@@ -16,7 +16,7 @@ template<typename Mutex>
 class null_sink : public base_sink<Mutex>
 {
 protected:
-    void sink_it_(const details::log_msg &) override {}
+    void sink_it_(const char* tag, const details::log_msg &) override {}
     void flush_() override {}
 };
 

include/spdlog/sinks/ostream_sink.h

@@ -23,7 +23,7 @@ public:
     ostream_sink &operator=(const ostream_sink &) = delete;
 
 protected:
-    void sink_it_(const details::log_msg &msg) override
+    void sink_it_(const char* tag, const details::log_msg &msg) override
     {
         memory_buf_t formatted;
         base_sink<Mutex>::formatter_->format(msg, formatted);

include/spdlog/sinks/win_eventlog_sink.h

@@ -214,7 +214,7 @@ private:
     }
 
 protected:
-    void sink_it_(const details::log_msg &msg) override
+    void sink_it_(const char* tag, const details::log_msg &msg) override
     {
         using namespace internal;
 

include/spdlog/spdlog-inl.h

@@ -16,7 +16,8 @@ SPDLOG_INLINE void initialize_logger(std::shared_ptr<logger> logger)
 {
     details::registry::instance().initialize_logger(std::move(logger));
 }
-SPDLOG_API const char* default_tag() {
+SPDLOG_INLINE const char *default_tag()
+{
     return spdlog_default_tag;
 }
 SPDLOG_INLINE std::shared_ptr<logger> get(const std::string &name)

tests/test_daily_logger.cpp

@@ -139,7 +139,7 @@ static void test_rotate(int days_to_run, uint16_t max_days, uint16_t expected_n_
     for (int i = 0; i < days_to_run; i++)
     {
         auto offset = std::chrono::seconds{24 * 3600 * i};
-        sink.log(create_msg(offset));
+        sink.log(spdlog::default_tag(), create_msg(offset));
     }
 
     REQUIRE(count_files("test_logs") == static_cast<size_t>(expected_n_files));

tests/test_dup_filter.cpp

@@ -13,7 +13,7 @@ TEST_CASE("dup_filter_test1", "[dup_filter_sink]")
 
     for (int i = 0; i < 10; i++)
     {
-        dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+        dup_sink.log(spdlog::default_tag(), spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
     }
 
     REQUIRE(test_sink->msg_counter() == 1);
@@ -30,7 +30,7 @@ TEST_CASE("dup_filter_test2", "[dup_filter_sink]")
 
     for (int i = 0; i < 10; i++)
     {
-        dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+        dup_sink.log(spdlog::default_tag(), spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
         std::this_thread::sleep_for(std::chrono::milliseconds(5));
     }
 
@@ -48,8 +48,8 @@ TEST_CASE("dup_filter_test3", "[dup_filter_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"});
+        dup_sink.log(spdlog::default_tag(), spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+        dup_sink.log(spdlog::default_tag(), spdlog::details::log_msg{"test", spdlog::level::info, "message2"});
     }
 
     REQUIRE(test_sink->msg_counter() == 20);
@@ -64,9 +64,9 @@ TEST_CASE("dup_filter_test4", "[dup_filter_sink]")
     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"});
+    dup_sink.log(spdlog::default_tag(), 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"});
+    dup_sink.log(spdlog::default_tag(), spdlog::details::log_msg{"test", spdlog::level::info, "message"});
     REQUIRE(test_sink->msg_counter() == 2);
 }
 
@@ -80,10 +80,10 @@ TEST_CASE("dup_filter_test5", "[dup_filter_sink]")
     test_sink->set_pattern("%v");
     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"});
+    dup_sink.log(spdlog::default_tag(), spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+    dup_sink.log(spdlog::default_tag(), spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+    dup_sink.log(spdlog::default_tag(), spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
+    dup_sink.log(spdlog::default_tag(), 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
     REQUIRE(test_sink->lines()[1] == "Skipped 2 duplicate messages..");

tests/test_errors.cpp

@@ -11,7 +11,7 @@
 class failing_sink : public spdlog::sinks::base_sink<std::mutex>
 {
 protected:
-    void sink_it_(const spdlog::details::log_msg &) final
+    void sink_it_(const char* tag, const spdlog::details::log_msg &) final
     {
         throw std::runtime_error("some error happened during log");
     }

tests/test_macros.cpp

@@ -20,8 +20,8 @@ TEST_CASE("debug and trace w/o format string", "[macros]]")
     logger->set_pattern("%v");
     logger->set_level(spdlog::level::trace);
 
-    SPDLOG_LOGGER_TRACE(logger, "Test message 1");
-    SPDLOG_LOGGER_DEBUG(logger, "Test message 2");
+    SPDLOG_LOGGER_TRACE(logger, spdlog::default_tag(), "Test message 1");
+    SPDLOG_LOGGER_DEBUG(logger, spdlog::default_tag(), "Test message 2");
     logger->flush();
 
     using spdlog::details::os::default_eol;
@@ -47,8 +47,8 @@ TEST_CASE("pass logger pointer", "[macros]")
 {
     auto logger = spdlog::create<spdlog::sinks::null_sink_mt>("refmacro");
     auto &ref = *logger;
-    SPDLOG_LOGGER_TRACE(&ref, "Test message 1");
-    SPDLOG_LOGGER_DEBUG(&ref, "Test message 2");
+    SPDLOG_LOGGER_TRACE(&ref, spdlog::default_tag(), "Test message 1");
+    SPDLOG_LOGGER_DEBUG(&ref, spdlog::default_tag(), "Test message 2");
 }
 
 // ensure that even if right macro level is on- don't evaluate if the logger's level is not high enough

tests/test_pattern_formatter.cpp

@@ -236,11 +236,11 @@ TEST_CASE("padding_truncate_funcname", "[pattern_formatter]")
     test_sink.set_formatter(std::move(formatter));
 
     spdlog::details::log_msg msg1{spdlog::source_loc{"ignored", 1, "func"}, "test_logger", spdlog::level::info, "message"};
-    test_sink.log(msg1);
+    test_sink.log(spdlog::default_tag(), msg1);
     REQUIRE(test_sink.lines()[0] == "message [ func]");
 
     spdlog::details::log_msg msg2{spdlog::source_loc{"ignored", 1, "function"}, "test_logger", spdlog::level::info, "message"};
-    test_sink.log(msg2);
+    test_sink.log(spdlog::default_tag(), msg2);
     REQUIRE(test_sink.lines()[1] == "message [funct]");
 }
 
@@ -253,11 +253,11 @@ TEST_CASE("padding_funcname", "[pattern_formatter]")
     test_sink.set_formatter(std::move(formatter));
 
     spdlog::details::log_msg msg1{spdlog::source_loc{"ignored", 1, "func"}, "test_logger", spdlog::level::info, "message"};
-    test_sink.log(msg1);
+    test_sink.log(spdlog::default_tag(), msg1);
     REQUIRE(test_sink.lines()[0] == "message [      func]");
 
     spdlog::details::log_msg msg2{spdlog::source_loc{"ignored", 1, "func567890123"}, "test_logger", spdlog::level::info, "message"};
-    test_sink.log(msg2);
+    test_sink.log(spdlog::default_tag(), msg2);
     REQUIRE(test_sink.lines()[1] == "message [func567890123]");
 }
 

tests/test_sink.h

@@ -47,7 +47,7 @@ public:
     }
 
 protected:
-    void sink_it_(const details::log_msg &msg) override
+    void sink_it_(const char* tag, const details::log_msg &msg) override
     {
         memory_buf_t formatted;
         base_sink<Mutex>::formatter_->format(msg, formatted);

tests/test_time_point.cpp

@@ -16,14 +16,14 @@ TEST_CASE("time_point1", "[time_point log_msg]")
     for (int i = 0; i < 5; i++)
     {
         spdlog::details::log_msg msg{tp, source, "test_logger", spdlog::level::info, "message"};
-        test_sink->log(msg);
+        test_sink->log(spdlog::default_tag(), msg);
     }
 
-    logger.log(tp, source, spdlog::level::info, "formatted message");
-    logger.log(tp, source, spdlog::level::info, "formatted message");
-    logger.log(tp, source, spdlog::level::info, "formatted message");
-    logger.log(tp, source, spdlog::level::info, "formatted message");
-    logger.log(source, spdlog::level::info, "formatted message"); // last line has different time_point
+    logger.log(tp, spdlog::default_tag(), source, spdlog::level::info, "formatted message");
+    logger.log(tp, spdlog::default_tag(), source, spdlog::level::info, "formatted message");
+    logger.log(tp, spdlog::default_tag(), source, spdlog::level::info, "formatted message");
+    logger.log(tp, spdlog::default_tag(), source, spdlog::level::info, "formatted message");
+    logger.log(spdlog::default_tag(), source, spdlog::level::info, "formatted message"); // last line has different time_point
 
     // now the real test... that the times are the same.
     std::vector<std::string> lines = test_sink->lines();