Merge branch 'v2.x' of https://github.com/gabime/spdlog into v2.x

include/spdlog/details/os-inl.h

@@ -531,7 +531,7 @@ static SPDLOG_INLINE bool mkdir_(const filename_t &path)
 
 // create the given directory - and all directories leading to it
 // return true on success or if the directory already exists
-SPDLOG_INLINE bool create_dir(filename_t path)
+SPDLOG_INLINE bool create_dir(const filename_t &path)
 {
     if (path_exists(path))
     {
@@ -570,7 +570,7 @@ SPDLOG_INLINE bool create_dir(filename_t path)
 // "abc/" => "abc"
 // "abc" => ""
 // "abc///" => "abc//"
-SPDLOG_INLINE filename_t dir_name(filename_t path)
+SPDLOG_INLINE filename_t dir_name(const filename_t &path)
 {
     auto pos = path.find_last_of(folder_seps_filename);
     return pos != filename_t::npos ? path.substr(0, pos) : filename_t{};

include/spdlog/details/os.h

@@ -99,11 +99,11 @@ SPDLOG_API void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target);
 // "abc/" => "abc"
 // "abc" => ""
 // "abc///" => "abc//"
-SPDLOG_API filename_t dir_name(filename_t path);
+SPDLOG_API filename_t dir_name(const filename_t &path);
 
 // Create a dir from the given path.
 // Return true if succeeded or if this dir already exists.
-SPDLOG_API bool create_dir(filename_t path);
+SPDLOG_API bool create_dir(const filename_t &path);
 
 // non thread safe, cross platform getenv/getenv_s
 // return empty string if field not found

include/spdlog/pattern_formatter.h

@@ -69,7 +69,7 @@ class SPDLOG_API custom_flag_formatter : public details::flag_formatter
 public:
     virtual std::unique_ptr<custom_flag_formatter> clone() const = 0;
 
-    void set_padding_info(details::padding_info padding)
+    void set_padding_info(const details::padding_info& padding)
     {
         flag_formatter::padinfo_ = padding;
     }

include/spdlog/sinks/base_sink.h

@@ -36,7 +36,7 @@ public:
 protected:
     // sink formatter
     std::unique_ptr<spdlog::formatter> formatter_;
-    mutable Mutex mutex_;
+    Mutex mutex_;
 
     virtual void sink_it_(const details::log_msg &msg) = 0;
     virtual void flush_() = 0;

include/spdlog/spdlog.h

@@ -21,20 +21,6 @@
 
 namespace spdlog {
 
-using default_factory = synchronous_factory;
-
-// Create a logger with a templated sink type
-// The logger's level, formatter and flush level will be set according the
-// global settings.
-//
-// Example:
-//   spdlog::create<daily_file_sink_st>("logger_name", "dailylog_filename", 11, 59);
-template<typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... sink_args)
-{
-    return default_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
-}
-
 // API for using default logger (stdout_color_mt),
 // e.g: spdlog::info("Message {}", 1);
 //

tests/includes.h

@@ -12,6 +12,7 @@
 #include <string>
 #include <iomanip>
 #include <stdlib.h>
+#include <memory>
 
 #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
 

tests/test_daily_logger.cpp

@@ -18,13 +18,14 @@ TEST_CASE("daily_logger with dateonly calculator", "[daily_logger]")
     fmt::format_to(
         std::back_inserter(w), SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}"), basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
 
-    auto logger = spdlog::create<sink_type>("logger", basename, 0, 0);
+    auto sink = std::make_shared<sink_type>(basename, 0, 0);
+    spdlog::logger logger("logger", sink);
     for (int i = 0; i < 10; ++i)
     {
 
-        logger->info("Test message {}", i);
+        logger.info("Test message {}", i);
     }
-    logger->flush();
+    logger.flush();
 
 #ifdef SPDLOG_WCHAR_FILENAMES
     spdlog::memory_buf_t buf;
@@ -60,13 +61,14 @@ TEST_CASE("daily_logger with custom calculator", "[daily_logger]")
     fmt::format_to(
         std::back_inserter(w), SPDLOG_FILENAME_T("{}{:04d}{:02d}{:02d}"), basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
 
-    auto logger = spdlog::create<sink_type>("logger", basename, 0, 0);
+    auto sink = std::make_shared<sink_type>(basename, 0, 0);
+    spdlog::logger logger("logger", sink);
     for (int i = 0; i < 10; ++i)
     {
-        logger->info("Test message {}", i);
+        logger.info("Test message {}", i);
     }
 
-    logger->flush();
+    logger.flush();
 
 #ifdef SPDLOG_WCHAR_FILENAMES
     spdlog::memory_buf_t buf;
@@ -165,4 +167,4 @@ TEST_CASE("daily_logger rotate", "[daily_file_sink]")
     test_rotate(days_to_run, 10, 10);
     test_rotate(days_to_run, 11, 10);
     test_rotate(days_to_run, 20, 10);
-}
\ No newline at end of file
+}

tests/test_errors.cpp

@@ -27,11 +27,13 @@ TEST_CASE("default_error_handler", "[errors]]")
     prepare_logdir();
     spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
 
-    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("test-error", filename, true);
-    logger->set_formatter(make_unique<spdlog::pattern_formatter>("%v"));
-    logger->info(fmt::runtime("Test message {} {}"), 1);
-    logger->info("Test message {}", 2);
-    logger->flush();
+
+    auto sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
+    spdlog::logger logger("test-error", std::move(sink));
+    logger.set_formatter(make_unique<spdlog::pattern_formatter>("%v"));
+    logger.info(fmt::runtime("Test message {} {}"), 1);
+    logger.info("Test message {}", 2);
+    logger.flush();
 
     using spdlog::details::os::default_eol;
     REQUIRE(file_contents(SIMPLE_LOG) == fmt::format("Test message 2{}", default_eol));
@@ -44,7 +46,8 @@ TEST_CASE("custom_error_handler", "[errors]]")
 {
     prepare_logdir();
     spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
-    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename, true);
+    auto sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
+    auto logger = std::make_shared<spdlog::logger>("logger", std::move(sink));
     logger->flush_on(spdlog::level::info);
     logger->set_error_handler([=](const std::string &) { throw custom_ex(); });
     logger->info("Good message #1");
@@ -56,16 +59,16 @@ TEST_CASE("custom_error_handler", "[errors]]")
 
 TEST_CASE("default_error_handler2", "[errors]]")
 {
-    auto logger = spdlog::create<failing_sink>("failed_logger");
-    logger->set_error_handler([=](const std::string &) { throw custom_ex(); });
-    REQUIRE_THROWS_AS(logger->info("Some message"), custom_ex);
+    spdlog::logger logger("failed-logger", std::make_shared<failing_sink>());
+    logger.set_error_handler([=](const std::string &) { throw custom_ex(); });
+    REQUIRE_THROWS_AS(logger.info("Some message"), custom_ex);
 }
 
 TEST_CASE("flush_error_handler", "[errors]]")
 {
-    auto logger = spdlog::create<failing_sink>("failed_logger");
-    logger->set_error_handler([=](const std::string &) { throw custom_ex(); });
-    REQUIRE_THROWS_AS(logger->flush(), custom_ex);
+    spdlog::logger logger("failed-logger", std::make_shared<failing_sink>());
+    logger.set_error_handler([=](const std::string &) { throw custom_ex(); });
+    REQUIRE_THROWS_AS(logger.flush(), custom_ex);
 }
 
 TEST_CASE("async_error_handler", "[errors]]")

tests/test_file_logging.cpp

@@ -11,13 +11,15 @@ TEST_CASE("simple_file_logger", "[simple_logger]]")
     prepare_logdir();
     spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
 
-    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename);
-    logger->set_formatter(make_unique<spdlog::pattern_formatter>("%v"));
+    auto sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename);
+    spdlog::logger logger("logger", sink);
 
-    logger->info("Test message {}", 1);
-    logger->info("Test message {}", 2);
+    logger.set_formatter(make_unique<spdlog::pattern_formatter>("%v"));
 
-    logger->flush();
+    logger.info("Test message {}", 1);
+    logger.info("Test message {}", 2);
+
+    logger.flush();
     require_message_count(SIMPLE_LOG, 2);
     using spdlog::details::os::default_eol;
     REQUIRE(file_contents(SIMPLE_LOG) == fmt::format("Test message 1{}Test message 2{}", default_eol, default_eol));
@@ -28,15 +30,17 @@ TEST_CASE("flush_on", "[flush_on]]")
     prepare_logdir();
     spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
 
-    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename);
-    logger->set_formatter(make_unique<spdlog::pattern_formatter>("%v"));
-    logger->set_level(spdlog::level::trace);
-    logger->flush_on(spdlog::level::info);
-    logger->trace("Should not be flushed");
+    auto sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename);
+
+    spdlog::logger logger("logger", sink);
+    logger.set_formatter(make_unique<spdlog::pattern_formatter>("%v"));
+    logger.set_level(spdlog::level::trace);
+    logger.flush_on(spdlog::level::info);
+    logger.trace("Should not be flushed");
     REQUIRE(count_lines(SIMPLE_LOG) == 0);
 
-    logger->info("Test message {}", 1);
-    logger->info("Test message {}", 2);
+    logger.info("Test message {}", 1);
+    logger.info("Test message {}", 2);
 
     require_message_count(SIMPLE_LOG, 3);
     using spdlog::details::os::default_eol;

tests/test_macros.cpp

@@ -16,7 +16,8 @@ TEST_CASE("debug and trace w/o format string", "[macros]]")
     prepare_logdir();
     spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME);
 
-    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename);
+    auto sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename);
+    auto logger = std::make_shared<spdlog::logger>("logger", sink);
     logger->set_formatter(make_unique<spdlog::pattern_formatter>("%v"));
     logger->set_level(spdlog::level::trace);
 
@@ -45,8 +46,9 @@ TEST_CASE("disable param evaluation", "[macros]")
 
 TEST_CASE("pass logger pointer", "[macros]")
 {
-    auto logger = spdlog::create<spdlog::sinks::null_sink_mt>("refmacro");
-    auto &ref = *logger;
+    auto sink = std::make_shared<spdlog::sinks::null_sink_mt>();
+    spdlog::logger logger("refmacro", sink);
+    auto &ref = logger;
     SPDLOG_LOGGER_TRACE(&ref, "Test message 1");
     SPDLOG_LOGGER_DEBUG(&ref, "Test message 2");
 }