Renamed default logger to global logger

CMakeLists.txt

@@ -85,7 +85,7 @@ endif()
 
 option(SPDLOG_PREVENT_CHILD_FD "Prevent from child processes to inherit log file descriptors" OFF)
 option(SPDLOG_NO_THREAD_ID "prevent spdlog from querying the thread id on each log call if thread id is not needed" OFF)
-option(SPDLOG_DISABLE_DEFAULT_LOGGER "Disable default logger creation" OFF)
+option(SPDLOG_DISABLE_GLOBAL_LOGGER "Disable global logger creation" OFF)
 option(SPDLOG_NO_TLS "Disable thread local storage" OFF)
 
 # clang-tidy
@@ -309,7 +309,7 @@ foreach(SPDLOG_OPTION
     SPDLOG_CLOCK_COARSE
     SPDLOG_PREVENT_CHILD_FD
     SPDLOG_NO_THREAD_ID
-    SPDLOG_DISABLE_DEFAULT_LOGGER
+    SPDLOG_DISABLE_GLOBAL_LOGGER
     SPDLOG_NO_TLS
     SPDLOG_FWRITE_UNLOCKED)
     if(${SPDLOG_OPTION})

README.md

@@ -410,10 +410,10 @@ void file_events_example()
 ---
 #### Replace the Default Logger
 ```c++
-void replace_default_logger_example()
+void replace_global_logger_example()
 {
-    auto new_logger = spdlog::basic_logger_mt("new_default_logger", "logs/new-default-log.txt", true);
-    spdlog::set_default_logger(new_logger);
+    auto new_logger = spdlog::basic_logger_mt("new_global_logger", "logs/new-default-log.txt", true);
+    spdlog::set_global_logger(new_logger);
     spdlog::info("new logger log message");
 }
 ```

bench/bench.cpp

@@ -78,7 +78,7 @@ void bench_single_threaded(int iters) {
 
 int main(int argc, char *argv[]) {
     spdlog::set_automatic_registration(false);
-    spdlog::default_logger()->set_pattern("[%^%l%$] %v");
+    spdlog::global_logger()->set_pattern("[%^%l%$] %v");
     int iters = 250000;
     size_t threads = 4;
     try {
@@ -155,8 +155,8 @@ void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log)
     using std::chrono::duration;
     using std::chrono::duration_cast;
 
-    auto orig_default = spdlog::default_logger();
-    spdlog::set_default_logger(log);
+    auto orig_default = spdlog::global_logger();
+    spdlog::set_global_logger(log);
     auto start = high_resolution_clock::now();
     for (auto i = 0; i < howmany; ++i)
     {
@@ -166,7 +166,7 @@ void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log)
     auto delta = high_resolution_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();
     spdlog::drop(log->name());
-    spdlog::set_default_logger(std::move(orig_default));
+    spdlog::set_global_logger(std::move(orig_default));
     spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany /
 delta_d));
 }
@@ -184,8 +184,8 @@ non dapibus eros. Donec fringilla dui sed " "augue pretium, nec scelerisque est
 convallis, sem nec blandit maximus, nisi turpis ornare " "nisl, sit amet volutpat neque massa eu
 odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
 
-    auto orig_default = spdlog::default_logger();
-    spdlog::set_default_logger(log);
+    auto orig_default = spdlog::global_logger();
+    spdlog::set_global_logger(log);
     auto start = high_resolution_clock::now();
     for (auto i = 0; i < howmany; ++i)
     {
@@ -195,7 +195,7 @@ odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
     auto delta = high_resolution_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();
     spdlog::drop(log->name());
-    spdlog::set_default_logger(std::move(orig_default));
+    spdlog::set_global_logger(std::move(orig_default));
     spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany /
 delta_d));
 }

bench/latency.cpp

@@ -40,7 +40,7 @@ void bench_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logge
 }
 
 void bench_global_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) {
-    spdlog::set_default_logger(std::move(logger));
+    spdlog::set_global_logger(std::move(logger));
     int i = 0;
     for (auto _ : state) {
         spdlog::info("Hello logger: msg number {}...............", ++i);
@@ -57,7 +57,7 @@ void bench_disabled_macro(benchmark::State &state, std::shared_ptr<spdlog::logge
 }
 
 void bench_disabled_macro_global_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) {
-    spdlog::set_default_logger(std::move(logger));
+    spdlog::set_global_logger(std::move(logger));
     int i = 0;
     benchmark::DoNotOptimize(i);       // prevent unused warnings
     benchmark::DoNotOptimize(logger);  // prevent unused warnings

example/example.cpp

@@ -24,7 +24,7 @@ void syslog_example();
 void udp_example();
 void custom_flags_example();
 void file_events_example();
-void replace_default_logger_example();
+void replace_global_logger_example();
 
 #include "spdlog/spdlog.h"
 #include "spdlog/version.h"
@@ -66,7 +66,7 @@ int main(int, char *[]) {
         udp_example();
         custom_flags_example();
         file_events_example();
-        replace_default_logger_example();
+        replace_global_logger_example();
 
         // Release all spdlog resources
         // This is optional (only mandatory if using windows + async log).
@@ -165,9 +165,9 @@ void vector_example() {
 // Compile time log levels.
 // define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE)
 void trace_example() {
-    // trace from default logger
+    // trace from global logger
     SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23);
-    // debug from default logger
+    // debug from global logger
     SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23);
 }
 
@@ -287,15 +287,15 @@ void file_events_example() {
     my_logger.info("Some log line");
 }
 
-void replace_default_logger_example() {
+void replace_global_logger_example() {
     // store the old logger so we don't break other examples.
-    auto old_logger = spdlog::default_logger();
+    auto old_logger = spdlog::global_logger();
 
-    auto new_logger = spdlog::basic_logger_mt("new_default_logger", "logs/new-default-log.txt", true);
-    spdlog::set_default_logger(new_logger);
+    auto new_logger = spdlog::basic_logger_mt("new_global_logger", "logs/new-default-log.txt", true);
+    spdlog::set_global_logger(new_logger);
     spdlog::set_level(spdlog::level::info);
     spdlog::debug("This message should not be displayed!");
     spdlog::set_level(spdlog::level::trace);
     spdlog::debug("This message should be displayed..");
-    spdlog::set_default_logger(old_logger);
+    spdlog::set_global_logger(old_logger);
 }

include/spdlog/details/context.h

@@ -30,18 +30,17 @@ public:
     context(const context &) = delete;
     context &operator=(const context &) = delete;
 
-    std::shared_ptr<logger> default_logger();
+    std::shared_ptr<logger> global_logger();
 
-    // Return raw ptr to the default logger.
-    // To be used directly by the spdlog default api (e.g. spdlog::info)
-    // This make the default API faster, but cannot be used concurrently with set_default_logger().
-    // e.g do not call set_default_logger() from one thread while calling spdlog::info() from
+    // Return raw ptr to the global logger.
+    // To be used directly by the spdlog global api (e.g. spdlog::info)
+    // This make the global API faster, but cannot be used concurrently with set_global_logger().
+    // e.g do not call set_global_logger() from one thread while calling spdlog::info() from
     // another.
-    logger *get_default_raw() const noexcept;
+    logger *global_logger_raw() const noexcept;
 
-    // set default logger.
-    // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
-    void set_default_logger(std::shared_ptr<logger> new_default_logger);
+    // set logger instance.
+    void set_logger(std::shared_ptr<logger> new_logger);
 
     void set_tp(std::shared_ptr<thread_pool> tp);
 
@@ -58,7 +57,7 @@ private:
 
     std::recursive_mutex tp_mutex_;
     std::shared_ptr<thread_pool> tp_;
-    std::shared_ptr<logger> default_logger_;
+    std::shared_ptr<logger> global_logger_;
 };
 
 }  // namespace details

include/spdlog/spdlog.h

@@ -31,67 +31,65 @@ std::shared_ptr<logger> create(std::string logger_name, SinkArgs &&...sink_args)
     return default_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
 }
 
-// Set formatter of the default logger. Each sink in each logger will get a clone of this object
+// Set formatter of the global logger. Each sink in each logger will get a clone of this object
 SPDLOG_API void set_formatter(std::unique_ptr<formatter> formatter);
 
-// Set format string of the default logger.
+// Set format string of the global logger.
 // example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v");
 SPDLOG_API void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local);
 
-// Get logging level of the default logger
+// Get logging level of the global logger
 SPDLOG_API level get_level();
 
-// Set logging level of the default logger
+// Set logging level of the global logger
 SPDLOG_API void set_level(level level);
 
-// Determine whether the default logger should log messages with a certain level
+// Determine whether the global logger should log messages with a certain level
 SPDLOG_API bool should_log(level level);
 
-// Set flush level of the default logger.
+// Set flush level of the global logger.
 SPDLOG_API void flush_on(level level);
 
 
-// Set error handler for the default logger
+// Set error handler for the global logger
 SPDLOG_API void set_error_handler(void (*handler)(const std::string &msg));
 
 // calls context::shutdown() to perform final cleanups
 SPDLOG_API void shutdown();
 
 
-// API for using default logger (stdout_color_mt),
+// API for using global logger (stdout_color_mt),
 // e.g: spdlog::info("Message {}", 1);
 //
-// The default logger object can be accessed using the spdlog::default_logger():
+// The global logger object can be accessed using the spdlog::global_logger():
 // For example, to add another sink to it:
-// spdlog::default_logger()->sinks().push_back(some_sink);
+// spdlog::global_logger()->sinks().push_back(some_sink);
 //
-// The default logger can be replaced using spdlog::set_default_logger(new_logger).
+// The global logger can be replaced using spdlog::set_global_logger(new_logger).
 // For example, to replace it with a file logger.
 //
 // IMPORTANT:
-// The default API is thread safe (for _mt loggers), but:
-// set_default_logger() *should not* be used concurrently with the default API.
-// e.g. do not call set_default_logger() from one thread while calling spdlog::info() from another.
+// Do not call set_global_logger() from one thread while calling spdlog::info() from another.
 
-SPDLOG_API std::shared_ptr<logger> default_logger();
+SPDLOG_API std::shared_ptr<logger> global_logger();
 
-SPDLOG_API logger *default_logger_raw();
+SPDLOG_API logger *global_logger_raw();
 
-SPDLOG_API void set_default_logger(std::shared_ptr<logger> default_logger);
+SPDLOG_API void set_global_logger(std::shared_ptr<logger> global_logger);
 
 template <typename... Args>
 void log(source_loc source, level lvl, format_string_t<Args...> fmt, Args &&...args) {
-    default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...);
+    global_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...);
 }
 
 template <typename... Args>
 void log(level lvl, format_string_t<Args...> fmt, Args &&...args) {
-    default_logger_raw()->log(lvl, fmt, std::forward<Args>(args)...);
+    global_logger_raw()->log(lvl, fmt, std::forward<Args>(args)...);
 }
 
-inline void log(level lvl, std::string_view msg) { default_logger_raw()->log(lvl, msg); }
+inline void log(level lvl, std::string_view msg) { global_logger_raw()->log(lvl, msg); }
 
-inline void log(source_loc loc, level lvl, std::string_view msg) { default_logger_raw()->log(loc, lvl, msg); }
+inline void log(source_loc loc, level lvl, std::string_view msg) { global_logger_raw()->log(loc, lvl, msg); }
 
 template <typename... Args>
 void trace(format_string_t<Args...> fmt, Args &&...args) {
@@ -160,7 +158,7 @@ inline void critical(std::string_view msg) { log(level::critical, msg); }
 
 #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_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::global_logger_raw(), __VA_ARGS__)
 #else
     #define SPDLOG_LOGGER_TRACE(logger, ...) (void)0
     #define SPDLOG_TRACE(...) (void)0
@@ -168,7 +166,7 @@ inline void critical(std::string_view msg) { log(level::critical, msg); }
 
 #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_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::global_logger_raw(), __VA_ARGS__)
 #else
     #define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0
     #define SPDLOG_DEBUG(...) (void)0
@@ -176,7 +174,7 @@ inline void critical(std::string_view msg) { log(level::critical, msg); }
 
 #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_INFO(...) SPDLOG_LOGGER_INFO(spdlog::global_logger_raw(), __VA_ARGS__)
 #else
     #define SPDLOG_LOGGER_INFO(logger, ...) (void)0
     #define SPDLOG_INFO(...) (void)0
@@ -184,7 +182,7 @@ inline void critical(std::string_view msg) { log(level::critical, msg); }
 
 #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_WARN(...) SPDLOG_LOGGER_WARN(spdlog::global_logger_raw(), __VA_ARGS__)
 #else
     #define SPDLOG_LOGGER_WARN(logger, ...) (void)0
     #define SPDLOG_WARN(...) (void)0
@@ -192,7 +190,7 @@ inline void critical(std::string_view msg) { log(level::critical, msg); }
 
 #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_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::global_logger_raw(), __VA_ARGS__)
 #else
     #define SPDLOG_LOGGER_ERROR(logger, ...) (void)0
     #define SPDLOG_ERROR(...) (void)0
@@ -200,7 +198,7 @@ inline void critical(std::string_view msg) { log(level::critical, msg); }
 
 #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_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::global_logger_raw(), __VA_ARGS__)
 #else
     #define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0
     #define SPDLOG_CRITICAL(...) (void)0

src/details/context.cpp

@@ -6,8 +6,8 @@
 #include "spdlog/logger.h"
 #include "spdlog/pattern_formatter.h"
 
-#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
-    // support for the default stdout color logger
+#ifndef SPDLOG_DISABLE_GLOBAL_LOGGER
+    // support for the global stdout color logger
     #ifdef _WIN32
         #include "spdlog/sinks/wincolor_sink.h"
     #else
@@ -15,7 +15,7 @@
         #include "spdlog/sinks/ansicolor_sink.h"
 
     #endif
-#endif  // SPDLOG_DISABLE_DEFAULT_LOGGER
+#endif  // SPDLOG_DISABLE_GLOBAL_LOGGER
 
 #include <memory>
 #include <string>
@@ -27,35 +27,35 @@ namespace spdlog {
 namespace details {
 
 context::context() {
-#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
-    // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
+#ifndef SPDLOG_DISABLE_GLOBAL_LOGGER
+    // create global logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
     #ifdef _WIN32
     auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
     #else
     auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
     #endif
-    const char *default_logger_name = "";
-    default_logger_ = std::make_shared<logger>(default_logger_name, std::move(color_sink));
+    const char *global_logger_name = "";
+    global_logger_ = std::make_shared<logger>(global_logger_name, std::move(color_sink));
 
-#endif  // SPDLOG_DISABLE_DEFAULT_LOGGER
+#endif  // SPDLOG_DISABLE_GLOBAL_LOGGER
 }
 
 context::~context() = default;
 
-std::shared_ptr<logger> context::default_logger() {
-    return default_logger_;
+std::shared_ptr<logger> context::global_logger() {
+    return global_logger_;
 }
 
-// Return raw ptr to the default logger.
+// Return raw ptr to the global logger.
 // To be used directly by the spdlog default api (e.g. spdlog::info)
-// This make the default API faster, but cannot be used concurrently with set_default_logger().
-// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
-logger *context::get_default_raw() const noexcept{ return default_logger_.get(); }
-
-// set default logger.
-// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
-void context::set_default_logger(std::shared_ptr<logger> new_default_logger) {
-    default_logger_ = std::move(new_default_logger);
+// This make the default API faster, but cannot be used concurrently with set_global_logger().
+// e.g do not call set_global_logger() from one thread while calling spdlog::info() from another.
+logger *context::global_logger_raw() const noexcept{ return global_logger_.get(); }
+
+// set global logger.
+// global logger is stored in global_logger_ (for faster retrieval) and in the loggers_ map.
+void context::set_logger(std::shared_ptr<logger> new_global_logger) {
+    global_logger_ = std::move(new_global_logger);
 }
 
 void context::set_tp(std::shared_ptr<thread_pool> tp) {

src/spdlog.cpp

@@ -13,34 +13,33 @@
 namespace spdlog {
 
 
+std::shared_ptr<logger> global_logger() { return details::context::instance().global_logger(); }
+
+logger *global_logger_raw() { return details::context::instance().global_logger_raw(); }
+
+void set_global_logger(std::shared_ptr<logger> global_logger) {
+    details::context::instance().set_logger(std::move(global_logger));
+}
 
 void set_formatter(std::unique_ptr<formatter> formatter) {
-    default_logger_raw()->set_formatter(std::move(formatter));
+    global_logger_raw()->set_formatter(std::move(formatter));
 }
 
 void set_pattern(std::string pattern, pattern_time_type time_type) {
     set_formatter(std::make_unique<pattern_formatter>(std::move(pattern), time_type));
 }
 
-level get_level() { return default_logger_raw()->log_level(); }
-
-bool should_log(level level) { return default_logger_raw()->should_log(level); }
+level get_level() { return global_logger_raw()->log_level(); }
 
-void set_level(level level) { default_logger_raw()->set_level(level); }
+bool should_log(level level) { return global_logger_raw()->should_log(level); }
 
-void flush_on(level level) { default_logger_raw()->flush_on(level); }
+void set_level(level level) { global_logger_raw()->set_level(level); }
 
-void set_error_handler(void (*handler)(const std::string &msg)) { default_logger_raw()->set_error_handler(handler); }
+void flush_on(level level) { global_logger_raw()->flush_on(level); }
 
+void set_error_handler(void (*handler)(const std::string &msg)) { global_logger_raw()->set_error_handler(handler); }
 
 void shutdown() { details::context::instance().shutdown(); }
 
-std::shared_ptr<logger> default_logger() { return details::context::instance().default_logger(); }
-
-logger *default_logger_raw() { return details::context::instance().get_default_raw(); }
-
-void set_default_logger(std::shared_ptr<logger> default_logger) {
-    details::context::instance().set_default_logger(std::move(default_logger));
-}
 
 }  // namespace spdlog

tests/test_macros.cpp

@@ -27,8 +27,8 @@ TEST_CASE("debug and trace w/o format string", "[macros]") {
     REQUIRE(ends_with(file_contents(TEST_FILENAME), spdlog::fmt_lib::format("Test message 2{}", default_eol)));
     REQUIRE(count_lines(TEST_FILENAME) == 1);
 
-    auto orig_default_logger = spdlog::default_logger();
-    spdlog::set_default_logger(logger);
+    auto orig_global_logger = spdlog::global_logger();
+    spdlog::set_global_logger(logger);
 
     SPDLOG_TRACE("Test message 3");
     SPDLOG_DEBUG("Test message {}", 4);
@@ -36,7 +36,7 @@ TEST_CASE("debug and trace w/o format string", "[macros]") {
 
     require_message_count(TEST_FILENAME, 2);
     REQUIRE(ends_with(file_contents(TEST_FILENAME), spdlog::fmt_lib::format("Test message 4{}", default_eol)));
-    spdlog::set_default_logger(std::move(orig_default_logger));
+    spdlog::set_global_logger(std::move(orig_global_logger));
 }
 
 TEST_CASE("disable param evaluation", "[macros]") {

tests/test_misc.cpp

@@ -115,14 +115,14 @@ TEST_CASE("clone async", "[clone]") {
     REQUIRE(test_sink->lines()[1] == "Some message 2");
 }
 
-TEST_CASE("default logger API", "[default logger]") {
+TEST_CASE("global logger API", "[global logger]") {
     std::ostringstream oss;
     auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
 
-    spdlog::set_default_logger(std::make_shared<spdlog::logger>("oss", oss_sink));
+    spdlog::set_global_logger(std::make_shared<spdlog::logger>("oss", oss_sink));
     spdlog::set_pattern("*** %v");
 
-    spdlog::default_logger()->set_level(spdlog::level::trace);
+    spdlog::global_logger()->set_level(spdlog::level::trace);
     spdlog::trace("hello trace");
     REQUIRE(oss.str() == "*** hello trace" + std::string(spdlog::details::os::default_eol));