[feature] Support dynamic tag setting in android.

[change] Modify the Android example, and other examples fail to run error.

example/example.cpp

@@ -261,8 +261,8 @@ void syslog_example()
 void android_example()
 {
     std::string tag = "spdlog-android";
-    auto android_logger = spdlog::android_logger_mt("android", tag);
+    auto android_logger = spdlog::android_logger_mt("android");
-    android_logger->critical("Use \"adb shell logcat\" to view this message.");
+    android_logger->critical("cus_critical_tag", "Use \"adb shell logcat\" to view this message.");
 }
 #endif
 

include/spdlog/async_logger-inl.h

@@ -24,7 +24,7 @@ SPDLOG_INLINE spdlog::async_logger::async_logger(
 {}
 
 // send the log message to the thread pool
-SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg)
+SPDLOG_INLINE void spdlog::async_logger::sink_it_(const char*tag, const details::log_msg &msg)
 {
     if (auto pool_ptr = thread_pool_.lock())
     {
@@ -52,7 +52,7 @@ SPDLOG_INLINE void spdlog::async_logger::flush_()
 //
 // backend functions - called from the thread pool to do the actual job
 //
-SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg)
+SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const char*tag, const details::log_msg &msg)
 {
     for (auto &sink : sinks_)
     {
@@ -60,7 +60,7 @@ SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg
         {
             SPDLOG_TRY
             {
-                sink->log(msg);
+                sink->log(tag, msg);
             }
             SPDLOG_LOGGER_CATCH()
         }

include/spdlog/async_logger.h

@@ -52,9 +52,9 @@ public:
     std::shared_ptr<logger> clone(std::string new_name) override;
 
 protected:
-    void sink_it_(const details::log_msg &msg) override;
+    void sink_it_(const char*tag, const details::log_msg &msg) override;
     void flush_() override;
-    void backend_sink_it_(const details::log_msg &incoming_log_msg);
+    void backend_sink_it_(const char*tag, const details::log_msg &incoming_log_msg);
     void backend_flush_();
 
 private:

include/spdlog/common.h

@@ -96,7 +96,7 @@ class formatter;
 namespace sinks {
 class sink;
 }
-
+static const char* spdlog_default_tag = "SPD_Log_TAG";
 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
 using filename_t = std::wstring;
 // allow macro expansion to occur in SPDLOG_FILENAME_T

include/spdlog/details/thread_pool-inl.h

@@ -105,7 +105,7 @@ bool SPDLOG_INLINE thread_pool::process_next_msg_()
     switch (incoming_async_msg.msg_type)
     {
     case async_msg_type::log: {
-        incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);
+        incoming_async_msg.worker_ptr->backend_sink_it_("", incoming_async_msg);
         return true;
     }
     case async_msg_type::flush: {

include/spdlog/logger-inl.h

@@ -163,11 +163,11 @@ SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name)
 }
 
 // protected methods
-SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool log_enabled, bool traceback_enabled)
+SPDLOG_INLINE void logger::log_it_(const char*tag, const spdlog::details::log_msg &log_msg, bool log_enabled, bool traceback_enabled)
 {
     if (log_enabled)
     {
-        sink_it_(log_msg);
+        sink_it_(tag, log_msg);
     }
     if (traceback_enabled)
     {
@@ -175,7 +175,7 @@ SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool
     }
 }
 
-SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg)
+SPDLOG_INLINE void logger::sink_it_(const char*tag, const details::log_msg &msg)
 {
     for (auto &sink : sinks_)
     {
@@ -183,7 +183,7 @@ SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg)
         {
             SPDLOG_TRY
             {
-                sink->log(msg);
+                sink->log(tag, msg);
             }
             SPDLOG_LOGGER_CATCH()
         }
@@ -212,9 +212,9 @@ SPDLOG_INLINE void logger::dump_backtrace_()
     using details::log_msg;
     if (tracer_.enabled())
     {
-        sink_it_(log_msg{name(), level::info, "****************** Backtrace Start ******************"});
+        sink_it_("", log_msg{name(), level::info, "****************** Backtrace Start ******************"});
-        tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); });
+        tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_("", msg); });
-        sink_it_(log_msg{name(), level::info, "****************** Backtrace End ********************"});
+        sink_it_("", log_msg{name(), level::info, "****************** Backtrace End ********************"});
     }
 }
 

include/spdlog/logger.h

@@ -84,15 +84,15 @@ public:
 
     // FormatString is NOT a type derived from fmt::compile_string but is a string_view_t or can be implicitly converted to one
     template<typename... Args>
-    void log(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args)
+    void log(const char* tag, source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args)
     {
-        log_(loc, lvl, fmt, std::forward<Args>(args)...);
+        log_(tag, loc, lvl, fmt, std::forward<Args>(args)...);
     }
 
     template<typename FormatString, typename... Args>
     void log(level::level_enum lvl, const FormatString &fmt, Args &&...args)
     {
-        log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
+        log(default_tag(), source_loc{}, lvl, fmt, std::forward<Args>(args)...);
     }
 
     template<typename FormatString, typename... Args>
@@ -132,17 +132,17 @@ public:
     }
 
     template<typename T>
-    void log(level::level_enum lvl, const T &msg)
+    void log(const char*tag, level::level_enum lvl, const T &msg)
     {
-        log(source_loc{}, lvl, msg);
+        log(tag, source_loc{}, lvl, msg);
     }
 
     // T can be statically converted to string_view and isn't a fmt::compile_string
     template<class T, typename std::enable_if<
                           std::is_convertible<const T &, spdlog::string_view_t>::value && !fmt::is_compile_string<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, string_view_t{msg});
+        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)
@@ -155,10 +155,10 @@ public:
         }
 
         details::log_msg log_msg(log_time, loc, name_, lvl, msg);
-        log_it_(log_msg, log_enabled, traceback_enabled);
+        log_it_("", log_msg, log_enabled, traceback_enabled);
     }
 
-    void log(source_loc loc, level::level_enum lvl, string_view_t msg)
+    void log(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();
@@ -168,12 +168,12 @@ public:
         }
 
         details::log_msg log_msg(loc, name_, lvl, msg);
-        log_it_(log_msg, log_enabled, traceback_enabled);
+        log_it_(tag, log_msg, log_enabled, traceback_enabled);
     }
 
-    void log(level::level_enum lvl, string_view_t msg)
+    void log(const char* tag, level::level_enum lvl, string_view_t msg)
     {
-        log(source_loc{}, lvl, msg);
+        log(tag, source_loc{}, lvl, msg);
     }
 
     // T cannot be statically converted to string_view or wstring_view
@@ -185,42 +185,79 @@ public:
         log(loc, lvl, "{}", msg);
     }
 
+    template<typename T>
+    void trace(const char* tag, const T &msg)
+    {
+        log(tag, level::trace, msg);
+    }
+
     template<typename T>
     void trace(const T &msg)
     {
-        log(level::trace, msg);
+        trace(default_tag(), msg);
+    }
+
+    template<typename T>
+    void debug(const char* tag, const T &msg)
+    {
+        log(tag, level::debug, msg);
     }
 
     template<typename T>
     void debug(const T &msg)
     {
-        log(level::debug, msg);
+        debug(default_tag(), msg);
+    }
+
+    template<typename T>
+    void info(const char* tag, const T &msg)
+    {
+        log(tag, level::info, msg);
     }
 
     template<typename T>
     void info(const T &msg)
     {
-        log(level::info, msg);
+        info(default_tag(), msg);
+    }
+
+    template<typename T>
+    void warn(const char* tag, const T &msg)
+    {
+        log(tag, level::warn, msg);
     }
 
     template<typename T>
     void warn(const T &msg)
     {
-        log(level::warn, msg);
+        warn(default_tag(), msg);
+    }
+
+    template<typename T>
+    void error(const char* tag, const T &msg)
+    {
+        log(tag, level::err, msg);
     }
 
     template<typename T>
     void error(const T &msg)
     {
-        log(level::err, msg);
+        error(default_tag(), msg);
+    }
+
+    template<typename T>
+    void critical(const char* tag, const T &msg)
+    {
+        log(tag, level::critical, msg);
     }
 
     template<typename T>
     void critical(const T &msg)
     {
-        log(level::critical, msg);
+        critical(default_tag(), msg);
     }
 
+
 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
 #    ifndef _WIN32
 #        error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
@@ -327,7 +364,7 @@ protected:
 
     // common implementation for after templated public api has been resolved
     template<typename FormatString, typename... Args>
-    void log_(source_loc loc, level::level_enum lvl, const FormatString &fmt, Args &&...args)
+    void log_(const char* tag, source_loc loc, level::level_enum lvl, const FormatString &fmt, Args &&...args)
     {
         bool log_enabled = should_log(lvl);
         bool traceback_enabled = tracer_.enabled();
@@ -341,15 +378,15 @@ protected:
             // faster than fmt::format_to(std::back_inserter(buf), fmt, std::forward<Args>(args)...);
             fmt::detail::vformat_to(buf, fmt::string_view(fmt), fmt::make_format_args(args...), {});
             details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()));
-            log_it_(log_msg, log_enabled, traceback_enabled);
+            log_it_(tag, log_msg, log_enabled, traceback_enabled);
         }
         SPDLOG_LOGGER_CATCH()
     }
 
     // log the given message (if the given log level is high enough),
     // and save backtrace (if backtrace is enabled).
-    void log_it_(const details::log_msg &log_msg, bool log_enabled, bool traceback_enabled);
+    void log_it_(const char*tag, const details::log_msg &log_msg, bool log_enabled, bool traceback_enabled);
-    virtual void sink_it_(const details::log_msg &msg);
+    virtual void sink_it_(const char*tag, const details::log_msg &msg);
     virtual void flush_();
     void dump_backtrace_();
     bool should_flush_(const details::log_msg &msg);
@@ -357,6 +394,7 @@ 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/android_sink.h

@@ -31,13 +31,12 @@ template<typename Mutex>
 class android_sink final : public base_sink<Mutex>
 {
 public:
-    explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false)
+    explicit android_sink(bool use_raw_msg = false)
-        : tag_(std::move(tag))
+        :use_raw_msg_(use_raw_msg)
-        , use_raw_msg_(use_raw_msg)
     {}
 
 protected:
-    void sink_it_(const details::log_msg &msg) override
+    void sink_it_(const char* tag, const details::log_msg &msg) override
     {
         const android_LogPriority priority = convert_to_android_(msg.level);
         memory_buf_t formatted;
@@ -53,12 +52,12 @@ protected:
         const char *msg_output = formatted.data();
 
         // See system/core/liblog/logger_write.c for explanation of return value
-        int ret = __android_log_write(priority, tag_.c_str(), msg_output);
+        int ret = __android_log_write(priority, tag, msg_output);
         int retry_count = 0;
         while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES))
         {
             details::os::sleep_for_millis(5);
-            ret = __android_log_write(priority, tag_.c_str(), msg_output);
+            ret = __android_log_write(priority, tag, msg_output);
             retry_count++;
         }
 
@@ -91,8 +90,6 @@ private:
             return ANDROID_LOG_DEFAULT;
         }
     }
-
-    std::string tag_;
     bool use_raw_msg_;
 };
 
@@ -103,15 +100,15 @@ using android_sink_st = android_sink<details::null_mutex>;
 // Create and register android syslog logger
 
 template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> android_logger_mt(const std::string &logger_name, const std::string &tag = "spdlog")
+inline std::shared_ptr<logger> android_logger_mt(const std::string &logger_name)
 {
-    return Factory::template create<sinks::android_sink_mt>(logger_name, tag);
+    return Factory::template create<sinks::android_sink_mt>(logger_name);
 }
 
 template<typename Factory = spdlog::synchronous_factory>
-inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name, const std::string &tag = "spdlog")
+inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name)
 {
-    return Factory::template create<sinks::android_sink_st>(logger_name, tag);
+    return Factory::template create<sinks::android_sink_st>(logger_name);
 }
 
 } // namespace spdlog

include/spdlog/sinks/ansicolor_sink-inl.h

@@ -38,7 +38,7 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum col
 }
 
 template<typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg)
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const char* tag,  const details::log_msg &msg)
 {
     // Wrap the originally formatted message in color codes.
     // If color is not supported in the terminal, log as is instead.

include/spdlog/sinks/ansicolor_sink.h

@@ -39,7 +39,7 @@ public:
     void set_color_mode(color_mode mode);
     bool should_color();
 
-    void log(const details::log_msg &msg) override;
+    void log(const char* tag, const details::log_msg &msg) override;
     void flush() override;
     void set_pattern(const std::string &pattern) final;
     void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;

include/spdlog/sinks/base_sink-inl.h

@@ -23,10 +23,10 @@ SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink(std::unique_ptr<spdlog:
 {}
 
 template<typename Mutex>
-void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg)
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const char* tag, const details::log_msg &msg)
 {
     std::lock_guard<Mutex> lock(mutex_);
-    sink_it_(msg);
+    sink_it_(tag, msg);
 }
 
 template<typename Mutex>

include/spdlog/sinks/base_sink.h

@@ -29,7 +29,7 @@ public:
     base_sink &operator=(const base_sink &) = delete;
     base_sink &operator=(base_sink &&) = delete;
 
-    void log(const details::log_msg &msg) final;
+    void log(const char* tag, const details::log_msg &msg) final;
     void flush() final;
     void set_pattern(const std::string &pattern) final;
     void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final;
@@ -39,7 +39,7 @@ protected:
     std::unique_ptr<spdlog::formatter> formatter_;
     mutable Mutex mutex_;
 
-    virtual void sink_it_(const details::log_msg &msg) = 0;
+    virtual void sink_it_(const char* tag, 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);

include/spdlog/sinks/basic_file_sink-inl.h

@@ -26,7 +26,7 @@ SPDLOG_INLINE const filename_t &basic_file_sink<Mutex>::filename() const
 }
 
 template<typename Mutex>
-SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg)
+SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const char*tag, const details::log_msg &msg)
 {
     memory_buf_t formatted;
     base_sink<Mutex>::formatter_->format(msg, formatted);

include/spdlog/sinks/basic_file_sink.h

@@ -24,7 +24,7 @@ public:
     const filename_t &filename() const;
 
 protected:
-    void sink_it_(const details::log_msg &msg) override;
+    void sink_it_(const char*tag, const details::log_msg &msg) override;
     void flush_() override;
 
 private:

include/spdlog/sinks/daily_file_sink.h

@@ -99,7 +99,7 @@ public:
     }
 
 protected:
-    void sink_it_(const details::log_msg &msg) override
+    void sink_it_(const char*tag, const details::log_msg &msg) override
     {
         auto time = msg.time;
         bool should_rotate = time >= rotation_tp_;

include/spdlog/sinks/dist_sink.h

@@ -55,7 +55,7 @@ public:
     }
 
 protected:
-    void sink_it_(const details::log_msg &msg) override
+    void sink_it_(const char*tag, const details::log_msg &msg) override
     {
         for (auto &sink : sinks_)
         {

include/spdlog/sinks/dup_filter_sink.h

@@ -51,7 +51,7 @@ protected:
     std::string last_msg_payload_;
     size_t skip_counter_ = 0;
 
-    void sink_it_(const details::log_msg &msg) override
+    void sink_it_(const char*tag, const details::log_msg &msg) override
     {
         bool filtered = filter_(msg);
         if (!filtered)

include/spdlog/sinks/ringbuffer_sink.h

@@ -56,7 +56,7 @@ public:
     }
 
 protected:
-    void sink_it_(const details::log_msg &msg) override
+    void sink_it_(const char*tag, const details::log_msg &msg) override
     {
         q_.push_back(details::log_msg_buffer{msg});
     }

include/spdlog/sinks/rotating_file_sink-inl.h

@@ -61,7 +61,7 @@ SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::filename()
 }
 
 template<typename Mutex>
-SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &msg)
+SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const char*tag, const details::log_msg &msg)
 {
     memory_buf_t formatted;
     base_sink<Mutex>::formatter_->format(msg, formatted);

include/spdlog/sinks/rotating_file_sink.h

@@ -27,7 +27,7 @@ public:
     filename_t filename();
 
 protected:
-    void sink_it_(const details::log_msg &msg) override;
+    void sink_it_(const char*tag, const details::log_msg &msg) override;
     void flush_() override;
 
 private:

include/spdlog/sinks/sink.h

@@ -13,7 +13,7 @@ class SPDLOG_API sink
 {
 public:
     virtual ~sink() = default;
-    virtual void log(const details::log_msg &msg) = 0;
+    virtual void log(const char* tag, 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;

include/spdlog/sinks/stdout_sinks-inl.h

@@ -50,7 +50,7 @@ SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
 }
 
 template<typename ConsoleMutex>
-SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &msg)
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const char* tag, const details::log_msg &msg)
 {
 #ifdef _WIN32
     if (handle_ == INVALID_HANDLE_VALUE)

include/spdlog/sinks/stdout_sinks.h

@@ -30,7 +30,7 @@ public:
     stdout_sink_base &operator=(const stdout_sink_base &other) = delete;
     stdout_sink_base &operator=(stdout_sink_base &&other) = delete;
 
-    void log(const details::log_msg &msg) override;
+    void log(const char* tag, const details::log_msg &msg) override;
     void flush() override;
     void set_pattern(const std::string &pattern) override;
 

include/spdlog/sinks/syslog_sink.h

@@ -45,7 +45,7 @@ public:
     syslog_sink &operator=(const syslog_sink &) = delete;
 
 protected:
-    void sink_it_(const details::log_msg &msg) override
+    void sink_it_(const char* tag, const details::log_msg &msg) override
     {
         string_view_t payload;
         memory_buf_t formatted;

include/spdlog/spdlog-inl.h

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

include/spdlog/spdlog.h

@@ -46,6 +46,8 @@ inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs
 //   spdlog::initialize_logger(mylogger);
 SPDLOG_API void initialize_logger(std::shared_ptr<logger> logger);
 
+SPDLOG_API const char* default_tag();
+
 // Return an existing logger or nullptr if a logger with such name doesn't
 // exist.
 // example: spdlog::get("my_logger")->info("hello {}", "world");
@@ -237,52 +239,57 @@ inline void critical(const T &msg)
 // SPDLOG_LEVEL_CRITICAL,
 // SPDLOG_LEVEL_OFF
 //
-
+#define SPDLOG_LOGGER_CALL(logger, tag, level, ...) (logger)->log(tag, spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__)
-#define SPDLOG_LOGGER_CALL(logger, level, ...) (logger)->log(spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__)
 
 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE
-#define SPDLOG_LOGGER_TRACE(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__)
+#define SPDLOG_LOGGER_TRACE(logger, tag ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::trace, __VA_ARGS__)
-#define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__)
+#define SPDLOG_TAG_TRACE(tag, ...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), tag, __VA_ARGS__)
+#define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), spdlog::default_tag(), __VA_ARGS__)
 #else
 #define SPDLOG_LOGGER_TRACE(logger, ...) (void)0
 #define SPDLOG_TRACE(...) (void)0
 #endif
 
 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG
-#define SPDLOG_LOGGER_DEBUG(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__)
+#define SPDLOG_LOGGER_DEBUG(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::debug, __VA_ARGS__)
-#define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__)
+#define SPDLOG_TAG_DEBUG(tag, ...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), tag, __VA_ARGS__)
+#define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), spdlog::default_tag(), __VA_ARGS__)
 #else
 #define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0
 #define SPDLOG_DEBUG(...) (void)0
 #endif
 
 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO
-#define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__)
+#define SPDLOG_LOGGER_INFO(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::info, __VA_ARGS__)
-#define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__)
+#define SPDLOG_TAG_INFO(tag, ...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), tag, __VA_ARGS__)
+#define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), spdlog::default_tag(), __VA_ARGS__)
 #else
 #define SPDLOG_LOGGER_INFO(logger, ...) (void)0
 #define SPDLOG_INFO(...) (void)0
 #endif
 
 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN
-#define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__)
+#define SPDLOG_LOGGER_WARN(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::warn, __VA_ARGS__)
-#define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__)
+#define SPDLOG_TAG_WARN(tag, ...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(),tag,  __VA_ARGS__)
+#define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), spdlog::default_tag(), __VA_ARGS__)
 #else
 #define SPDLOG_LOGGER_WARN(logger, ...) (void)0
 #define SPDLOG_WARN(...) (void)0
 #endif
 
 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR
-#define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__)
+#define SPDLOG_LOGGER_ERROR(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::err, __VA_ARGS__)
-#define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__)
+#define SPDLOG_TAG_ERROR(tag, ...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), tag, __VA_ARGS__)
+#define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), spdlog::default_tag(), __VA_ARGS__)
 #else
 #define SPDLOG_LOGGER_ERROR(logger, ...) (void)0
 #define SPDLOG_ERROR(...) (void)0
 #endif
 
 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL
-#define SPDLOG_LOGGER_CRITICAL(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__)
+#define SPDLOG_LOGGER_CRITICAL(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::critical, __VA_ARGS__)
-#define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__)
+#define SPDLOG_TAG_CRITICAL(tag, ...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), tag, __VA_ARGS__)
+#define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), spdlog::default_tag(), __VA_ARGS__)
 #else
 #define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0
 #define SPDLOG_CRITICAL(...) (void)0