Use regular mutex in stdout sinks

include/spdlog/details/console_globals.h

@@ -1,28 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-#include <mutex>
-#include <spdlog/details/null_mutex.h>
-
-namespace spdlog {
-namespace details {
-
-struct console_mutex {
-    using mutex_t = std::mutex;
-    static mutex_t &mutex() {
-        static mutex_t s_mutex;
-        return s_mutex;
-    }
-};
-
-struct console_nullmutex {
-    using mutex_t = null_mutex;
-    static mutex_t &mutex() {
-        static mutex_t s_mutex;
-        return s_mutex;
-    }
-};
-}  // namespace details
-}  // namespace spdlog

include/spdlog/details/registry-inl.h

@@ -245,6 +245,10 @@ SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr<logger> new
     new_logger->set_level(new_level);
 }
 
+SPDLOG_INLINE std::mutex &registry::console_mutex() {
+    return console_mutex_;
+}
+
 SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) {
     if (loggers_.find(logger_name) != loggers_.end()) {
         throw_spdlog_ex("logger with name '" + logger_name + "' already exists");

include/spdlog/details/registry.h

@@ -99,6 +99,8 @@ public:
 
     void apply_logger_env_levels(std::shared_ptr<logger> new_logger);
 
+    std::mutex& console_mutex();
+
 private:
     registry();
     ~registry();
@@ -119,6 +121,7 @@ private:
     std::shared_ptr<logger> default_logger_;
     bool automatic_registration_ = true;
     size_t backtrace_n_messages_ = 0;
+    std::mutex console_mutex_;
 };
 
 }  // namespace details

include/spdlog/sinks/ansicolor_sink-inl.h

@@ -13,12 +13,9 @@
 namespace spdlog {
 namespace sinks {
 
-template <typename ConsoleMutex>
-SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, color_mode mode)
-    : target_file_(target_file),
-      mutex_(ConsoleMutex::mutex()),
-      formatter_(details::make_unique<spdlog::pattern_formatter>())
-
+template <typename Mutex>
+SPDLOG_INLINE ansicolor_sink<Mutex>::ansicolor_sink(FILE *target_file, color_mode mode)
+    : target_file_(target_file)
 {
     set_color_mode(mode);
     colors_.at(level::trace) = to_string_(white);
@@ -30,22 +27,21 @@ SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, co
     colors_.at(level::off) = to_string_(reset);
 }
 
-template <typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum color_level,
+template <typename Mutex>
+SPDLOG_INLINE void ansicolor_sink<Mutex>::set_color(level::level_enum color_level,
                                                            string_view_t color) {
-    std::lock_guard<mutex_t> lock(mutex_);
+    std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
     colors_.at(static_cast<size_t>(color_level)) = to_string_(color);
 }
 
-template <typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg) {
+template <typename Mutex>
+SPDLOG_INLINE void ansicolor_sink<Mutex>::sink_it_(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.
-    std::lock_guard<mutex_t> lock(mutex_);
     msg.color_range_start = 0;
     msg.color_range_end = 0;
     memory_buf_t formatted;
-    formatter_->format(msg, formatted);
+    base_sink<Mutex>::formatter_->format(msg, formatted);
     if (should_do_colors_ && msg.color_range_end > msg.color_range_start) {
         // before color range
         print_range_(formatted, 0, msg.color_range_start);
@@ -62,74 +58,66 @@ SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg
     fflush(target_file_);
 }
 
-template <typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::flush() {
-    std::lock_guard<mutex_t> lock(mutex_);
+template <typename Mutex>
+SPDLOG_INLINE void ansicolor_sink<Mutex>::flush_() {
     fflush(target_file_);
 }
 
-template <typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern) {
-    std::lock_guard<mutex_t> lock(mutex_);
-    formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
-}
-
-template <typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(
-    std::unique_ptr<spdlog::formatter> sink_formatter) {
-    std::lock_guard<mutex_t> lock(mutex_);
-    formatter_ = std::move(sink_formatter);
-}
-
-template <typename ConsoleMutex>
-SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color() {
+template <typename Mutex>
+SPDLOG_INLINE bool ansicolor_sink<Mutex>::should_color() {
     return should_do_colors_;
 }
 
-template <typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) {
+template <typename Mutex>
+SPDLOG_INLINE void ansicolor_sink<Mutex>::set_color_mode(color_mode mode) {
+    std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+    set_color_mode_(mode);
+}
+
+template <typename Mutex>
+SPDLOG_INLINE void ansicolor_sink<Mutex>::set_color_mode_(color_mode mode) {
     switch (mode) {
         case color_mode::always:
             should_do_colors_ = true;
-            return;
+        return;
         case color_mode::automatic:
             should_do_colors_ =
                 details::os::in_terminal(target_file_) && details::os::is_color_terminal();
-            return;
+        return;
         case color_mode::never:
             should_do_colors_ = false;
-            return;
+        return;
         default:
             should_do_colors_ = false;
     }
 }
 
-template <typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code) {
+template <typename Mutex>
+SPDLOG_INLINE void ansicolor_sink<Mutex>::print_ccode_(const string_view_t &color_code) {
     fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_);
 }
 
-template <typename ConsoleMutex>
-SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted,
+template <typename Mutex>
+SPDLOG_INLINE void ansicolor_sink<Mutex>::print_range_(const memory_buf_t &formatted,
                                                               size_t start,
                                                               size_t end) {
     fwrite(formatted.data() + start, sizeof(char), end - start, target_file_);
 }
 
-template <typename ConsoleMutex>
-SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv) {
+template <typename Mutex>
+SPDLOG_INLINE std::string ansicolor_sink<Mutex>::to_string_(const string_view_t &sv) {
     return std::string(sv.data(), sv.size());
 }
 
 // ansicolor_stdout_sink
-template <typename ConsoleMutex>
-SPDLOG_INLINE ansicolor_stdout_sink<ConsoleMutex>::ansicolor_stdout_sink(color_mode mode)
-    : ansicolor_sink<ConsoleMutex>(stdout, mode) {}
+template <typename Mutex>
+SPDLOG_INLINE ansicolor_stdout_sink<Mutex>::ansicolor_stdout_sink(color_mode mode)
+    : ansicolor_sink<Mutex>(stdout, mode) {}
 
 // ansicolor_stderr_sink
-template <typename ConsoleMutex>
-SPDLOG_INLINE ansicolor_stderr_sink<ConsoleMutex>::ansicolor_stderr_sink(color_mode mode)
-    : ansicolor_sink<ConsoleMutex>(stderr, mode) {}
+template <typename Mutex>
+SPDLOG_INLINE ansicolor_stderr_sink<Mutex>::ansicolor_stderr_sink(color_mode mode)
+    : ansicolor_sink<Mutex>(stderr, mode) {}
 
 }  // namespace sinks
 }  // namespace spdlog

include/spdlog/sinks/ansicolor_sink.h

@@ -3,12 +3,10 @@
 
 #pragma once
 
+#include "base_sink.h"
+
 #include <array>
 #include <memory>
-#include <mutex>
-#include <spdlog/details/console_globals.h>
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/sinks/sink.h>
 #include <string>
 
 namespace spdlog {
@@ -21,10 +19,9 @@ namespace sinks {
  * If no color terminal detected, omit the escape codes.
  */
 
-template <typename ConsoleMutex>
-class ansicolor_sink : public sink {
+template <typename Mutex>
+class ansicolor_sink : public base_sink<Mutex> {
 public:
-    using mutex_t = typename ConsoleMutex::mutex_t;
     ansicolor_sink(FILE *target_file, color_mode mode);
     ~ansicolor_sink() override = default;
 
@@ -37,12 +34,6 @@ public:
     void set_color(level::level_enum color_level, string_view_t color);
     void set_color_mode(color_mode mode);
     bool should_color();
-
-    void log(const details::log_msg &msg) override;
-    void flush() override;
-    void set_pattern(const std::string &pattern) final override;
-    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;
-
     // Formatting codes
     const string_view_t reset = "\033[m";
     const string_view_t bold = "\033[1m";
@@ -78,34 +69,36 @@ public:
     const string_view_t red_bold = "\033[31m\033[1m";
     const string_view_t bold_on_red = "\033[1m\033[41m";
 
-private:
+protected:
     FILE *target_file_;
-    mutex_t &mutex_;
     bool should_do_colors_;
-    std::unique_ptr<spdlog::formatter> formatter_;
     std::array<std::string, level::n_levels> colors_;
+
+    void sink_it_(const details::log_msg &msg) override;
+    void flush_() override;
+    void set_color_mode_(color_mode mode);
     void print_ccode_(const string_view_t &color_code);
     void print_range_(const memory_buf_t &formatted, size_t start, size_t end);
     static std::string to_string_(const string_view_t &sv);
 };
 
-template <typename ConsoleMutex>
-class ansicolor_stdout_sink : public ansicolor_sink<ConsoleMutex> {
+template <typename Mutex>
+class ansicolor_stdout_sink : public ansicolor_sink<Mutex> {
 public:
     explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic);
 };
 
-template <typename ConsoleMutex>
-class ansicolor_stderr_sink : public ansicolor_sink<ConsoleMutex> {
+template <typename Mutex>
+class ansicolor_stderr_sink : public ansicolor_sink<Mutex> {
 public:
     explicit ansicolor_stderr_sink(color_mode mode = color_mode::automatic);
 };
 
-using ansicolor_stdout_sink_mt = ansicolor_stdout_sink<details::console_mutex>;
-using ansicolor_stdout_sink_st = ansicolor_stdout_sink<details::console_nullmutex>;
+using ansicolor_stdout_sink_mt = ansicolor_stdout_sink<std::mutex>;
+using ansicolor_stdout_sink_st = ansicolor_stdout_sink<details::null_mutex>;
 
-using ansicolor_stderr_sink_mt = ansicolor_stderr_sink<details::console_mutex>;
-using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::console_nullmutex>;
+using ansicolor_stderr_sink_mt = ansicolor_stderr_sink<std::mutex>;
+using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::null_mutex>;
 
 }  // namespace sinks
 }  // namespace spdlog

include/spdlog/sinks/stdout_sinks-inl.h

@@ -8,7 +8,6 @@
 #endif
 
 #include <memory>
-#include <spdlog/details/console_globals.h>
 #include <spdlog/pattern_formatter.h>
 
 #ifdef _WIN32
@@ -22,17 +21,15 @@
 
     #include <io.h>     // _get_osfhandle(..)
     #include <stdio.h>  // _fileno(..)
-#endif                  // WIN32
+#endif                  // _WIN32
 
 namespace spdlog {
 
 namespace sinks {
 
-template <typename ConsoleMutex>
-SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
-    : mutex_(ConsoleMutex::mutex()),
-      file_(file),
-      formatter_(details::make_unique<spdlog::pattern_formatter>()) {
+template <typename Mutex>
+SPDLOG_INLINE stdout_sink_base<Mutex>::stdout_sink_base(FILE *file)
+    :file_(file) {
 #ifdef _WIN32
     // get windows handle from the FILE* object
 
@@ -47,15 +44,14 @@ SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
 #endif  // WIN32
 }
 
-template <typename ConsoleMutex>
-SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &msg) {
+template <typename Mutex>
+SPDLOG_INLINE void stdout_sink_base<Mutex>::sink_it_(const details::log_msg &msg) {
 #ifdef _WIN32
     if (handle_ == INVALID_HANDLE_VALUE) {
         return;
     }
-    std::lock_guard<mutex_t> lock(mutex_);
     memory_buf_t formatted;
-    formatter_->format(msg, formatted);
+    base_sink<Mutex>::formatter_->format(msg, formatted);
     auto size = static_cast<DWORD>(formatted.size());
     DWORD bytes_written = 0;
     bool ok = ::WriteFile(handle_, formatted.data(), size, &bytes_written, nullptr) != 0;
@@ -64,42 +60,27 @@ SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &m
                         std::to_string(::GetLastError()));
     }
 #else
-    std::lock_guard<mutex_t> lock(mutex_);
     memory_buf_t formatted;
-    formatter_->format(msg, formatted);
+    base_sink<Mutex>::formatter_->format(msg, formatted);
     ::fwrite(formatted.data(), sizeof(char), formatted.size(), file_);
 #endif                // WIN32
     ::fflush(file_);  // flush every line to terminal
 }
 
-template <typename ConsoleMutex>
-SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::flush() {
-    std::lock_guard<mutex_t> lock(mutex_);
+template <typename Mutex>
+SPDLOG_INLINE void stdout_sink_base<Mutex>::flush_() {
     fflush(file_);
 }
 
-template <typename ConsoleMutex>
-SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_pattern(const std::string &pattern) {
-    std::lock_guard<mutex_t> lock(mutex_);
-    formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
-}
-
-template <typename ConsoleMutex>
-SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_formatter(
-    std::unique_ptr<spdlog::formatter> sink_formatter) {
-    std::lock_guard<mutex_t> lock(mutex_);
-    formatter_ = std::move(sink_formatter);
-}
-
 // stdout sink
-template <typename ConsoleMutex>
-SPDLOG_INLINE stdout_sink<ConsoleMutex>::stdout_sink()
-    : stdout_sink_base<ConsoleMutex>(stdout) {}
+template <typename Mutex>
+SPDLOG_INLINE stdout_sink<Mutex>::stdout_sink()
+    : stdout_sink_base<Mutex>(stdout) {}
 
 // stderr sink
-template <typename ConsoleMutex>
-SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink()
-    : stdout_sink_base<ConsoleMutex>(stderr) {}
+template <typename Mutex>
+SPDLOG_INLINE stderr_sink<Mutex>::stderr_sink()
+    : stdout_sink_base<Mutex>(stderr) {}
 
 }  // namespace sinks
 

include/spdlog/sinks/stdout_sinks.h

@@ -4,9 +4,8 @@
 #pragma once
 
 #include <cstdio>
-#include <spdlog/details/console_globals.h>
 #include <spdlog/details/synchronous_factory.h>
-#include <spdlog/sinks/sink.h>
+#include <spdlog/sinks/base_sink.h>
 
 #ifdef _WIN32
     #include <spdlog/details/windows_include.h>
@@ -16,10 +15,9 @@ namespace spdlog {
 
 namespace sinks {
 
-template <typename ConsoleMutex>
-class stdout_sink_base : public sink {
+template <typename Mutex>
+class stdout_sink_base : public base_sink<Mutex> {
 public:
-    using mutex_t = typename ConsoleMutex::mutex_t;
     explicit stdout_sink_base(FILE *file);
     ~stdout_sink_base() override = default;
 
@@ -28,39 +26,32 @@ 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 flush() override;
-    void set_pattern(const std::string &pattern) override;
-
-    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;
-
 protected:
-    mutex_t &mutex_;
+    void sink_it_(const details::log_msg &msg) override;
+    void flush_() override;
     FILE *file_;
-    std::unique_ptr<spdlog::formatter> formatter_;
 #ifdef _WIN32
     HANDLE handle_;
 #endif  // WIN32
 };
 
-template <typename ConsoleMutex>
-class stdout_sink : public stdout_sink_base<ConsoleMutex> {
+template <typename Mutex>
+class stdout_sink : public stdout_sink_base<Mutex> {
 public:
     stdout_sink();
 };
 
-template <typename ConsoleMutex>
-class stderr_sink : public stdout_sink_base<ConsoleMutex> {
+template <typename Mutex>
+class stderr_sink : public stdout_sink_base<Mutex> {
 public:
     stderr_sink();
 };
 
-using stdout_sink_mt = stdout_sink<details::console_mutex>;
-using stdout_sink_st = stdout_sink<details::console_nullmutex>;
+using stdout_sink_mt = stdout_sink<std::mutex>;
+using stdout_sink_st = stdout_sink<details::null_mutex>;
 
-using stderr_sink_mt = stderr_sink<details::console_mutex>;
-using stderr_sink_st = stderr_sink<details::console_nullmutex>;
+using stderr_sink_mt = stderr_sink<std::mutex>;
+using stderr_sink_st = stderr_sink<details::null_mutex>;
 
 }  // namespace sinks
 

src/color_sinks.cpp

@@ -22,12 +22,12 @@ template class SPDLOG_API spdlog::sinks::wincolor_stderr_sink<spdlog::details::c
 template class SPDLOG_API spdlog::sinks::wincolor_stderr_sink<spdlog::details::console_nullmutex>;
 #else
     #include "spdlog/sinks/ansicolor_sink-inl.h"
-template class SPDLOG_API spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>;
-template class SPDLOG_API spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>;
-template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink<spdlog::details::console_mutex>;
-template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink<spdlog::details::console_nullmutex>;
-template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink<spdlog::details::console_mutex>;
-template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink<spdlog::details::console_nullmutex>;
+template class SPDLOG_API spdlog::sinks::ansicolor_sink<std::mutex>;
+template class SPDLOG_API spdlog::sinks::ansicolor_sink<spdlog::details::null_mutex>;
+template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink<std::mutex>;
+template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink<spdlog::details::null_mutex>;
+template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink<std::mutex>;
+template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink<spdlog::details::null_mutex>;
 #endif
 
 // factory methods for color loggers

src/stdout_sinks.cpp

@@ -11,12 +11,12 @@
 #include <spdlog/details/null_mutex.h>
 #include <spdlog/sinks/stdout_sinks-inl.h>
 
-template class SPDLOG_API spdlog::sinks::stdout_sink_base<spdlog::details::console_mutex>;
-template class SPDLOG_API spdlog::sinks::stdout_sink_base<spdlog::details::console_nullmutex>;
-template class SPDLOG_API spdlog::sinks::stdout_sink<spdlog::details::console_mutex>;
-template class SPDLOG_API spdlog::sinks::stdout_sink<spdlog::details::console_nullmutex>;
-template class SPDLOG_API spdlog::sinks::stderr_sink<spdlog::details::console_mutex>;
-template class SPDLOG_API spdlog::sinks::stderr_sink<spdlog::details::console_nullmutex>;
+template class SPDLOG_API spdlog::sinks::stdout_sink_base<std::mutex>;
+template class SPDLOG_API spdlog::sinks::stdout_sink_base<spdlog::details::null_mutex>;
+template class SPDLOG_API spdlog::sinks::stdout_sink<std::mutex>;
+template class SPDLOG_API spdlog::sinks::stdout_sink<spdlog::details::null_mutex>;
+template class SPDLOG_API spdlog::sinks::stderr_sink<std::mutex>;
+template class SPDLOG_API spdlog::sinks::stderr_sink<spdlog::details::null_mutex>;
 
 template SPDLOG_API std::shared_ptr<spdlog::logger>
 spdlog::stdout_logger_mt<spdlog::synchronous_factory>(const std::string &logger_name);