Updated default API impl and tests

include/spdlog/details/registry.h

@@ -75,13 +75,23 @@ public:
         return found == loggers_.end() ? nullptr : found->second;
     }
 
-    std::shared_ptr<logger> get_default_logger() const
+    std::shared_ptr<logger> default_logger()
     {
+        std::lock_guard<std::mutex> lock(logger_map_mutex_);
         return default_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 another.
+    logger *get_default_raw()
+    {
+        return default_logger_.get();
+    }
+
     // set default logger.
-    // default logger is stored in default_logger_ (for faster retrieval) and in the map of existing loggers.
+    // 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)
     {
         std::lock_guard<std::mutex> lock(logger_map_mutex_);
@@ -90,7 +100,10 @@ public:
         {
             loggers_.erase(default_logger_->name());
         }
-        loggers_[new_default_logger->name()] = new_default_logger;
+        if (new_default_logger != nullptr)
+        {
+            loggers_[new_default_logger->name()] = new_default_logger;
+        }
         default_logger_ = std::move(new_default_logger);
     }
 
@@ -176,6 +189,10 @@ public:
     {
         std::lock_guard<std::mutex> lock(logger_map_mutex_);
         loggers_.erase(logger_name);
+        if (default_logger_ && default_logger_->name() == logger_name)
+        {
+            default_logger_.reset();
+        }
     }
 
     void drop_all()

include/spdlog/spdlog.h

@@ -25,7 +25,6 @@ namespace spdlog {
 struct synchronous_factory
 {
     template<typename Sink, typename... SinkArgs>
-
     static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... args)
     {
         auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
@@ -126,28 +125,29 @@ inline void shutdown()
     details::registry::instance().shutdown();
 }
 
-//
 // API for using default logger (stdout_color_mt),
 // e.g: spdlog::info("Message {}", 1);
 //
-// The default logger object can be accessed using the spdlog::get():
+// The default logger object can be accessed using the spdlog::default_logger():
 // For example, to add another sink to it:
-// spdlog::get()->sinks()->push_back(some_sink);
+// spdlog::default_logger()->sinks()->push_back(some_sink);
 //
 // The default logger can replaced using spdlog::set_default_logger(new_logger).
-// For example, to replace it with a file logger:
-// spdlog::set_default_logger(std::move(spdlog::basic_logger_st("mylog.txt"));
+// 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.
 
-// Return the default logger
-// inline std::shared_ptr<spdlog::logger> get()
-//{
-//    return details::registry::instance().get_default_logger();
-//}
-
-inline std::shared_ptr<spdlog::logger> get()
+inline std::shared_ptr<spdlog::logger> default_logger()
 {
-    return details::registry::instance().get_default_logger();
+    return details::registry::instance().default_logger();
+}
+
+inline spdlog::logger *default_logger_raw()
+{
+    return details::registry::instance().get_default_raw();
 }
 
 inline void set_default_logger(std::shared_ptr<spdlog::logger> default_logger)
@@ -158,128 +158,128 @@ inline void set_default_logger(std::shared_ptr<spdlog::logger> default_logger)
 template<typename... Args>
 inline void log(level::level_enum lvl, const char *fmt, const Args &... args)
 {
-    get()->log(lvl, fmt, args...);
+    default_logger_raw()->log(lvl, fmt, args...);
 }
 
 template<typename... Args>
 inline void trace(const char *fmt, const Args &... args)
 {
-    get()->trace(fmt, args...);
+    default_logger_raw()->trace(fmt, args...);
 }
 
 template<typename... Args>
 inline void debug(const char *fmt, const Args &... args)
 {
-    get()->debug(fmt, args...);
+    default_logger_raw()->debug(fmt, args...);
 }
 
 template<typename... Args>
 inline void info(const char *fmt, const Args &... args)
 {
-    get()->info(fmt, args...);
+    default_logger_raw()->info(fmt, args...);
 }
 
 template<typename... Args>
 inline void warn(const char *fmt, const Args &... args)
 {
-    get()->warn(fmt, args...);
+    default_logger_raw()->warn(fmt, args...);
 }
 
 template<typename... Args>
 inline void error(const char *fmt, const Args &... args)
 {
-    get()->error(fmt, args...);
+    default_logger_raw()->error(fmt, args...);
 }
 
 template<typename... Args>
 inline void critical(const char *fmt, const Args &... args)
 {
-    get()->critical(fmt, args...);
+    default_logger_raw()->critical(fmt, args...);
 }
 
 template<typename T>
 inline void log(level::level_enum lvl, const T &msg)
 {
-    get()->log(lvl, msg);
+    default_logger_raw()->log(lvl, msg);
 }
 
 template<typename T>
 inline void trace(const T &msg)
 {
-    get()->trace(msg);
+    default_logger_raw()->trace(msg);
 }
 
 template<typename T>
 inline void debug(const T &msg)
 {
-    get()->debug(msg);
+    default_logger_raw()->debug(msg);
 }
 
 template<typename T>
 inline void info(const T &msg)
 {
-    get()->info(msg);
+    default_logger_raw()->info(msg);
 }
 
 template<typename T>
 inline void warn(const T &msg)
 {
-    get()->warn(msg);
+    default_logger_raw()->warn(msg);
 }
 
 template<typename T>
 inline void error(const T &msg)
 {
-    get()->error(msg);
+    default_logger_raw()->error(msg);
 }
 
 template<typename T>
 inline void critical(const T &msg)
 {
-    get()->critical(msg);
+    default_logger_raw()->critical(msg);
 }
 
 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
 template<typename... Args>
 inline void log(level::level_enum lvl, const wchar_t *fmt, const Args &... args)
 {
-    get()->log(lvl, fmt, args...);
+    default_logger_raw()->log(lvl, fmt, args...);
 }
 
 template<typename... Args>
 inline void trace(const wchar_t *fmt, const Args &... args)
 {
-    get()->trace(fmt, args...);
+    default_logger_raw()->trace(fmt, args...);
 }
 
 template<typename... Args>
 inline void debug(const wchar_t *fmt, const Args &... args)
 {
-    get()->debug(fmt, args...);
+    default_logger_raw()->debug(fmt, args...);
 }
 
 template<typename... Args>
 inline void info(const wchar_t *fmt, const Args &... args)
 {
-    get()->info(fmt, args...);
+    default_logger_raw()->info(fmt, args...);
 }
 
 template<typename... Args>
 inline void warn(const wchar_t *fmt, const Args &... args)
 {
-    get()->warn(fmt, args...);
+    default_logger_raw()->warn(fmt, args...);
 }
 
 template<typename... Args>
 inline void error(const wchar_t *fmt, const Args &... args)
 {
-    get()->error(fmt, args...);
+    default_logger_raw()->error(fmt, args...);
 }
 
 template<typename... Args>
 inline void critical(const wchar_t *fmt, const Args &... args)
 {
-    get()->critical(fmt, args...);
+    default_logger_raw()->critical(fmt, args...);
 }
 
 #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT

include/spdlog/tweakme.h

@@ -122,7 +122,6 @@
 // "MY ERROR", "MY CRITICAL", "OFF" }
 ///////////////////////////////////////////////////////////////////////////////
 
-
 ///////////////////////////////////////////////////////////////////////////////
 // Uncomment to disable default logger creation.
 // This might save some (very) small initialization time if no default logger is needed.