From d2979c82d9230574cf80e69116c9c8f5138a8856 Mon Sep 17 00:00:00 2001 From: lilinxiong Date: Fri, 16 Jul 2021 20:11:13 +0800 Subject: [PATCH] [feature] Support dynamic tag setting in android. [change] Modify the Android example, and other examples fail to run error. --- example/example.cpp | 4 +- include/spdlog/async_logger-inl.h | 6 +- include/spdlog/async_logger.h | 4 +- include/spdlog/common.h | 2 +- include/spdlog/details/thread_pool-inl.h | 2 +- include/spdlog/logger-inl.h | 14 ++-- include/spdlog/logger.h | 82 ++++++++++++++----- include/spdlog/sinks/android_sink.h | 21 ++--- include/spdlog/sinks/ansicolor_sink-inl.h | 2 +- include/spdlog/sinks/ansicolor_sink.h | 2 +- include/spdlog/sinks/base_sink-inl.h | 4 +- include/spdlog/sinks/base_sink.h | 4 +- include/spdlog/sinks/basic_file_sink-inl.h | 2 +- include/spdlog/sinks/basic_file_sink.h | 2 +- include/spdlog/sinks/daily_file_sink.h | 2 +- include/spdlog/sinks/dist_sink.h | 2 +- include/spdlog/sinks/dup_filter_sink.h | 2 +- include/spdlog/sinks/ringbuffer_sink.h | 2 +- include/spdlog/sinks/rotating_file_sink-inl.h | 2 +- include/spdlog/sinks/rotating_file_sink.h | 2 +- include/spdlog/sinks/sink.h | 2 +- include/spdlog/sinks/stdout_sinks-inl.h | 2 +- include/spdlog/sinks/stdout_sinks.h | 2 +- include/spdlog/sinks/syslog_sink.h | 2 +- include/spdlog/spdlog-inl.h | 4 +- include/spdlog/spdlog.h | 35 ++++---- 26 files changed, 127 insertions(+), 83 deletions(-) diff --git a/example/example.cpp b/example/example.cpp index 0649a65e..b6bab39f 100644 --- a/example/example.cpp +++ b/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); - android_logger->critical("Use \"adb shell logcat\" to view this message."); + auto android_logger = spdlog::android_logger_mt("android"); + android_logger->critical("cus_critical_tag", "Use \"adb shell logcat\" to view this message."); } #endif diff --git a/include/spdlog/async_logger-inl.h b/include/spdlog/async_logger-inl.h index f8c9694c..b148c6ce 100644 --- a/include/spdlog/async_logger-inl.h +++ b/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() } diff --git a/include/spdlog/async_logger.h b/include/spdlog/async_logger.h index 6f299672..6657eb3f 100644 --- a/include/spdlog/async_logger.h +++ b/include/spdlog/async_logger.h @@ -52,9 +52,9 @@ public: std::shared_ptr 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: diff --git a/include/spdlog/common.h b/include/spdlog/common.h index d6434893..3c556132 100644 --- a/include/spdlog/common.h +++ b/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 diff --git a/include/spdlog/details/thread_pool-inl.h b/include/spdlog/details/thread_pool-inl.h index a0c8a222..1fc7dbe0 100644 --- a/include/spdlog/details/thread_pool-inl.h +++ b/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: { diff --git a/include/spdlog/logger-inl.h b/include/spdlog/logger-inl.h index d01c08da..0327cb57 100644 --- a/include/spdlog/logger-inl.h +++ b/include/spdlog/logger-inl.h @@ -163,11 +163,11 @@ SPDLOG_INLINE std::shared_ptr 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 ******************"}); - 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 Start ******************"}); + tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_("", msg); }); + sink_it_("", log_msg{name(), level::info, "****************** Backtrace End ********************"}); } } diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h index 81a018c0..ac0c746a 100644 --- a/include/spdlog/logger.h +++ b/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 - 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)...); + log_(tag, loc, lvl, fmt, std::forward(args)...); } template void log(level::level_enum lvl, const FormatString &fmt, Args &&...args) { - log(source_loc{}, lvl, fmt, std::forward(args)...); + log(default_tag(), source_loc{}, lvl, fmt, std::forward(args)...); } template @@ -132,17 +132,17 @@ public: } template - 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::value && !fmt::is_compile_string::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 + void trace(const char* tag, const T &msg) + { + log(tag, level::trace, msg); + } + template void trace(const T &msg) { - log(level::trace, msg); + trace(default_tag(), msg); + } + + template + void debug(const char* tag, const T &msg) + { + log(tag, level::debug, msg); } template void debug(const T &msg) { - log(level::debug, msg); + debug(default_tag(), msg); + } + + template + void info(const char* tag, const T &msg) + { + log(tag, level::info, msg); } template void info(const T &msg) { - log(level::info, msg); + info(default_tag(), msg); + } + + template + void warn(const char* tag, const T &msg) + { + log(tag, level::warn, msg); } template void warn(const T &msg) { - log(level::warn, msg); + warn(default_tag(), msg); + } + + template + void error(const char* tag, const T &msg) + { + log(tag, level::err, msg); } template void error(const T &msg) { - log(level::err, msg); + error(default_tag(), msg); + } + + template + void critical(const char* tag, const T &msg) + { + log(tag, level::critical, msg); } template 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 - 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)...); 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); - virtual void sink_it_(const details::log_msg &msg); + void log_it_(const char*tag, const details::log_msg &log_msg, bool log_enabled, bool traceback_enabled); + 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); diff --git a/include/spdlog/sinks/android_sink.h b/include/spdlog/sinks/android_sink.h index 9686adff..540eebbc 100644 --- a/include/spdlog/sinks/android_sink.h +++ b/include/spdlog/sinks/android_sink.h @@ -31,13 +31,12 @@ template class android_sink final : public base_sink { public: - explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false) - : tag_(std::move(tag)) - , use_raw_msg_(use_raw_msg) + explicit android_sink(bool use_raw_msg = false) + :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; // Create and register android syslog logger template -inline std::shared_ptr android_logger_mt(const std::string &logger_name, const std::string &tag = "spdlog") +inline std::shared_ptr android_logger_mt(const std::string &logger_name) { - return Factory::template create(logger_name, tag); + return Factory::template create(logger_name); } template -inline std::shared_ptr android_logger_st(const std::string &logger_name, const std::string &tag = "spdlog") +inline std::shared_ptr android_logger_st(const std::string &logger_name) { - return Factory::template create(logger_name, tag); + return Factory::template create(logger_name); } } // namespace spdlog diff --git a/include/spdlog/sinks/ansicolor_sink-inl.h b/include/spdlog/sinks/ansicolor_sink-inl.h index 61c0a719..08c3a800 100644 --- a/include/spdlog/sinks/ansicolor_sink-inl.h +++ b/include/spdlog/sinks/ansicolor_sink-inl.h @@ -38,7 +38,7 @@ SPDLOG_INLINE void ansicolor_sink::set_color(level::level_enum col } template -SPDLOG_INLINE void ansicolor_sink::log(const details::log_msg &msg) +SPDLOG_INLINE void ansicolor_sink::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. diff --git a/include/spdlog/sinks/ansicolor_sink.h b/include/spdlog/sinks/ansicolor_sink.h index 4438f706..36bf7dad 100644 --- a/include/spdlog/sinks/ansicolor_sink.h +++ b/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 sink_formatter) override; diff --git a/include/spdlog/sinks/base_sink-inl.h b/include/spdlog/sinks/base_sink-inl.h index b15fb0e6..89753d3d 100644 --- a/include/spdlog/sinks/base_sink-inl.h +++ b/include/spdlog/sinks/base_sink-inl.h @@ -23,10 +23,10 @@ SPDLOG_INLINE spdlog::sinks::base_sink::base_sink(std::unique_ptr -void SPDLOG_INLINE spdlog::sinks::base_sink::log(const details::log_msg &msg) +void SPDLOG_INLINE spdlog::sinks::base_sink::log(const char* tag, const details::log_msg &msg) { std::lock_guard lock(mutex_); - sink_it_(msg); + sink_it_(tag, msg); } template diff --git a/include/spdlog/sinks/base_sink.h b/include/spdlog/sinks/base_sink.h index 0647f0c4..baf55b2e 100644 --- a/include/spdlog/sinks/base_sink.h +++ b/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 sink_formatter) final; @@ -39,7 +39,7 @@ protected: std::unique_ptr 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 sink_formatter); diff --git a/include/spdlog/sinks/basic_file_sink-inl.h b/include/spdlog/sinks/basic_file_sink-inl.h index 1260d15c..c1569f0d 100644 --- a/include/spdlog/sinks/basic_file_sink-inl.h +++ b/include/spdlog/sinks/basic_file_sink-inl.h @@ -26,7 +26,7 @@ SPDLOG_INLINE const filename_t &basic_file_sink::filename() const } template -SPDLOG_INLINE void basic_file_sink::sink_it_(const details::log_msg &msg) +SPDLOG_INLINE void basic_file_sink::sink_it_(const char*tag, const details::log_msg &msg) { memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); diff --git a/include/spdlog/sinks/basic_file_sink.h b/include/spdlog/sinks/basic_file_sink.h index 62079d91..c0623682 100644 --- a/include/spdlog/sinks/basic_file_sink.h +++ b/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: diff --git a/include/spdlog/sinks/daily_file_sink.h b/include/spdlog/sinks/daily_file_sink.h index d6a09f6b..a8c250c6 100644 --- a/include/spdlog/sinks/daily_file_sink.h +++ b/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_; diff --git a/include/spdlog/sinks/dist_sink.h b/include/spdlog/sinks/dist_sink.h index 8fccb4ee..9a990835 100644 --- a/include/spdlog/sinks/dist_sink.h +++ b/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_) { diff --git a/include/spdlog/sinks/dup_filter_sink.h b/include/spdlog/sinks/dup_filter_sink.h index 282163ae..ed2f53b2 100644 --- a/include/spdlog/sinks/dup_filter_sink.h +++ b/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) diff --git a/include/spdlog/sinks/ringbuffer_sink.h b/include/spdlog/sinks/ringbuffer_sink.h index 1ee3f691..3dc7ae4e 100644 --- a/include/spdlog/sinks/ringbuffer_sink.h +++ b/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}); } diff --git a/include/spdlog/sinks/rotating_file_sink-inl.h b/include/spdlog/sinks/rotating_file_sink-inl.h index d715ebf3..6e5ddb26 100644 --- a/include/spdlog/sinks/rotating_file_sink-inl.h +++ b/include/spdlog/sinks/rotating_file_sink-inl.h @@ -61,7 +61,7 @@ SPDLOG_INLINE filename_t rotating_file_sink::filename() } template -SPDLOG_INLINE void rotating_file_sink::sink_it_(const details::log_msg &msg) +SPDLOG_INLINE void rotating_file_sink::sink_it_(const char*tag, const details::log_msg &msg) { memory_buf_t formatted; base_sink::formatter_->format(msg, formatted); diff --git a/include/spdlog/sinks/rotating_file_sink.h b/include/spdlog/sinks/rotating_file_sink.h index e1e85a7d..bb9f5f9b 100644 --- a/include/spdlog/sinks/rotating_file_sink.h +++ b/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: diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h index be99744d..7e8dbf29 100644 --- a/include/spdlog/sinks/sink.h +++ b/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 sink_formatter) = 0; diff --git a/include/spdlog/sinks/stdout_sinks-inl.h b/include/spdlog/sinks/stdout_sinks-inl.h index 9122152a..8d963f0e 100644 --- a/include/spdlog/sinks/stdout_sinks-inl.h +++ b/include/spdlog/sinks/stdout_sinks-inl.h @@ -50,7 +50,7 @@ SPDLOG_INLINE stdout_sink_base::stdout_sink_base(FILE *file) } template -SPDLOG_INLINE void stdout_sink_base::log(const details::log_msg &msg) +SPDLOG_INLINE void stdout_sink_base::log(const char* tag, const details::log_msg &msg) { #ifdef _WIN32 if (handle_ == INVALID_HANDLE_VALUE) diff --git a/include/spdlog/sinks/stdout_sinks.h b/include/spdlog/sinks/stdout_sinks.h index 40688a46..c7459c0b 100644 --- a/include/spdlog/sinks/stdout_sinks.h +++ b/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; diff --git a/include/spdlog/sinks/syslog_sink.h b/include/spdlog/sinks/syslog_sink.h index 7c38fcb5..8b1b70db 100644 --- a/include/spdlog/sinks/syslog_sink.h +++ b/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; diff --git a/include/spdlog/spdlog-inl.h b/include/spdlog/spdlog-inl.h index 96e09f59..32cb8a35 100644 --- a/include/spdlog/spdlog-inl.h +++ b/include/spdlog/spdlog-inl.h @@ -16,7 +16,9 @@ SPDLOG_INLINE void initialize_logger(std::shared_ptr logger) { details::registry::instance().initialize_logger(std::move(logger)); } - +SPDLOG_API const char* default_tag() { + return spdlog_default_tag; +} SPDLOG_INLINE std::shared_ptr get(const std::string &name) { return details::registry::instance().get(name); diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index bb130d94..030d50fa 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -46,6 +46,8 @@ inline std::shared_ptr create(std::string logger_name, SinkArgs // spdlog::initialize_logger(mylogger); SPDLOG_API void initialize_logger(std::shared_ptr 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, level, ...) (logger)->log(spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__) +#define SPDLOG_LOGGER_CALL(logger, tag, level, ...) (logger)->log(tag, 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_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__) +#define SPDLOG_LOGGER_TRACE(logger, tag ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::trace, __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_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__) +#define SPDLOG_LOGGER_DEBUG(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::debug, __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_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__) +#define SPDLOG_LOGGER_INFO(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::info, __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_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__) +#define SPDLOG_LOGGER_WARN(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::warn, __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_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__) +#define SPDLOG_LOGGER_ERROR(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::err, __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_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__) +#define SPDLOG_LOGGER_CRITICAL(logger, tag, ...) SPDLOG_LOGGER_CALL(logger, tag, spdlog::level::critical, __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