diff --git a/CMakeLists.txt b/CMakeLists.txt index c5bc7b88..f0df2be3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -152,7 +152,7 @@ message(STATUS "Build type: " ${CMAKE_BUILD_TYPE}) # --------------------------------------------------------------------------------------- # Static/Shared library # --------------------------------------------------------------------------------------- -set(SPDLOG_SRCS src/spdlog.cpp src/stdout_sinks.cpp src/color_sinks.cpp src/file_sinks.cpp src/async.cpp src/cfg.cpp) +set(SPDLOG_SRCS src/spdlog.cpp src/stdout_sinks.cpp src/color_sinks.cpp src/file_sinks.cpp src/async.cpp) if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO) list(APPEND SPDLOG_SRCS src/bundled_fmtlib_format.cpp) diff --git a/changes b/changes new file mode 100644 index 00000000..f3417e7d --- /dev/null +++ b/changes @@ -0,0 +1,11 @@ +Breaking changes: + +Removed registry api +Removed spdlog/cfg/* api +(?) Renamed set/get_default_logger() to set/get_logger() +Removed all factory functions. Use the logger constructor instead. + +TODO + +Thread pool singleton and clean async.h +flush_every removed() ? diff --git a/example/example.cpp b/example/example.cpp index 3a557ca2..cd9ede88 100644 --- a/example/example.cpp +++ b/example/example.cpp @@ -33,7 +33,7 @@ void replace_default_logger_example(); int main(int, char *[]) { // Log levels can be loaded from argv/env using "SPDLOG_LEVEL" - load_levels_example(); + //load_levels_example(); spdlog::info("Welcome to spdlog version {}.{}.{} !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH); diff --git a/include/spdlog/async.h b/include/spdlog/async.h index e96abd19..ae99c0fe 100644 --- a/include/spdlog/async.h +++ b/include/spdlog/async.h @@ -1,100 +1,87 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - +// // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. +// // Distributed under the MIT License (http://opensource.org/licenses/MIT) // -// Async logging using global thread pool -// All loggers created here share same global thread pool. -// Each log message is pushed to a queue along with a shared pointer to the -// logger. -// If a logger deleted while having pending messages in the queue, it's actual -// destruction will defer -// until all its messages are processed by the thread pool. -// This is because each message in the queue holds a shared_ptr to the -// originating logger. - -#include -#include -#include - -#include -#include -#include - -namespace spdlog { - -namespace details { -static const size_t default_async_q_size = 8192; -} - -// async logger factory - creates async loggers backed with thread pool. -// if a global thread pool doesn't already exist, create it with default queue -// size of 8192 items and single thread. -template -struct async_factory_impl { - template - static std::shared_ptr create(std::string logger_name, SinkArgs &&...args) { - auto ®istry_inst = details::registry::instance(); - - // create global thread pool if not already exists.. - - auto &mutex = registry_inst.tp_mutex(); - std::lock_guard tp_lock(mutex); - auto tp = registry_inst.get_tp(); - if (tp == nullptr) { - tp = std::make_shared(details::default_async_q_size, 1U); - registry_inst.set_tp(tp); - } - - auto sink = std::make_shared(std::forward(args)...); - auto new_logger = std::make_shared(std::move(logger_name), std::move(sink), - std::move(tp), OverflowPolicy); - registry_inst.initialize_logger(new_logger); - return new_logger; - } -}; - -using async_factory = async_factory_impl; -using async_factory_nonblock = async_factory_impl; - -template -inline std::shared_ptr create_async(std::string logger_name, - SinkArgs &&...sink_args) { - return async_factory::create(std::move(logger_name), - std::forward(sink_args)...); -} - -template -inline std::shared_ptr create_async_nb(std::string logger_name, - SinkArgs &&...sink_args) { - return async_factory_nonblock::create(std::move(logger_name), - std::forward(sink_args)...); -} - -// set global thread pool. -inline void init_thread_pool(size_t q_size, - size_t thread_count, - std::function on_thread_start, - std::function on_thread_stop) { - auto tp = std::make_shared(q_size, thread_count, on_thread_start, - on_thread_stop); - details::registry::instance().set_tp(std::move(tp)); -} - -inline void init_thread_pool(size_t q_size, - size_t thread_count, - std::function on_thread_start) { - init_thread_pool(q_size, thread_count, on_thread_start, [] {}); -} - -inline void init_thread_pool(size_t q_size, size_t thread_count) { - init_thread_pool( - q_size, thread_count, [] {}, [] {}); -} - -// get the global thread pool. -inline std::shared_ptr thread_pool() { - return details::registry::instance().get_tp(); -} -} // namespace spdlog +// #pragma once +// +// // +// // Async logging using global thread pool +// // All loggers created here share same global thread pool. +// // Each log message is pushed to a queue along with a shared pointer to the +// // logger. +// // If a logger deleted while having pending messages in the queue, it's actual +// // destruction will defer +// // until all its messages are processed by the thread pool. +// // This is because each message in the queue holds a shared_ptr to the +// // originating logger. +// +// #include +// #include +// +// #include +// #include +// #include +// +// namespace spdlog { +// +// namespace details { +// static const size_t default_async_q_size = 8192; +// } +// +// // async logger factory - creates async loggers backed with thread pool. +// // if a global thread pool doesn't already exist, create it with default queue +// // size of 8192 items and single thread. +// template +// struct async_factory_impl { +// template +// static std::shared_ptr create(std::string logger_name, SinkArgs &&...args) { +// auto tp = std::make_shared(details::default_async_q_size, 1U); +// auto sink = std::make_shared(std::forward(args)...); +// auto new_logger = std::make_shared(std::move(logger_name), std::move(sink), +// std::move(tp), OverflowPolicy); +// return new_logger; +// } +// }; +// +// using async_factory = async_factory_impl; +// using async_factory_nonblock = async_factory_impl; +// +// template +// inline std::shared_ptr create_async(std::string logger_name, +// SinkArgs &&...sink_args) { +// return async_factory::create(std::move(logger_name), +// std::forward(sink_args)...); +// } +// +// template +// inline std::shared_ptr create_async_nb(std::string logger_name, +// SinkArgs &&...sink_args) { +// return async_factory_nonblock::create(std::move(logger_name), +// std::forward(sink_args)...); +// } +// +// // // set global thread pool. +// // inline void init_thread_pool(size_t q_size, +// // size_t thread_count, +// // std::function on_thread_start, +// // std::function on_thread_stop) { +// // auto tp = std::make_shared(q_size, thread_count, on_thread_start, +// // on_thread_stop); +// // details::registry::instance().set_tp(std::move(tp)); +// // } +// // +// // inline void init_thread_pool(size_t q_size, +// // size_t thread_count, +// // std::function on_thread_start) { +// // init_thread_pool(q_size, thread_count, on_thread_start, [] {}); +// // } +// // +// // inline void init_thread_pool(size_t q_size, size_t thread_count) { +// // init_thread_pool( +// // q_size, thread_count, [] {}, [] {}); +// // } +// +// // get the global thread pool. +// // inline std::shared_ptr thread_pool() { +// // return details::registry::instance().get_tp(); +// // } +// } // namespace spdlog diff --git a/include/spdlog/cfg/argv.h b/include/spdlog/cfg/argv.h deleted file mode 100644 index 7de2f83e..00000000 --- a/include/spdlog/cfg/argv.h +++ /dev/null @@ -1,40 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once -#include -#include - -// -// Init log levels using each argv entry that starts with "SPDLOG_LEVEL=" -// -// set all loggers to debug level: -// example.exe "SPDLOG_LEVEL=debug" - -// set logger1 to trace level -// example.exe "SPDLOG_LEVEL=logger1=trace" - -// turn off all logging except for logger1 and logger2: -// example.exe "SPDLOG_LEVEL=off,logger1=debug,logger2=info" - -namespace spdlog { -namespace cfg { - -// search for SPDLOG_LEVEL= in the args and use it to init the levels -inline void load_argv_levels(int argc, const char **argv) { - const std::string spdlog_level_prefix = "SPDLOG_LEVEL="; - for (int i = 1; i < argc; i++) { - std::string arg = argv[i]; - if (arg.find(spdlog_level_prefix) == 0) { - auto levels_string = arg.substr(spdlog_level_prefix.size()); - helpers::load_levels(levels_string); - } - } -} - -inline void load_argv_levels(int argc, char **argv) { - load_argv_levels(argc, const_cast(argv)); -} - -} // namespace cfg -} // namespace spdlog diff --git a/include/spdlog/cfg/env.h b/include/spdlog/cfg/env.h deleted file mode 100644 index 6e554145..00000000 --- a/include/spdlog/cfg/env.h +++ /dev/null @@ -1,36 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once -#include -#include -#include - -// -// Init levels and patterns from env variables SPDLOG_LEVEL -// Inspired from Rust's "env_logger" crate (https://crates.io/crates/env_logger). -// Note - fallback to "info" level on unrecognized levels -// -// Examples: -// -// set global level to debug: -// export SPDLOG_LEVEL=debug -// -// turn off all logging except for logger1: -// export SPDLOG_LEVEL="*=off,logger1=debug" -// - -// turn off all logging except for logger1 and logger2: -// export SPDLOG_LEVEL="off,logger1=debug,logger2=info" - -namespace spdlog { -namespace cfg { -inline void load_env_levels() { - auto env_val = details::os::getenv("SPDLOG_LEVEL"); - if (!env_val.empty()) { - helpers::load_levels(env_val); - } -} - -} // namespace cfg -} // namespace spdlog diff --git a/include/spdlog/cfg/helpers-inl.h b/include/spdlog/cfg/helpers-inl.h deleted file mode 100644 index 93650a2e..00000000 --- a/include/spdlog/cfg/helpers-inl.h +++ /dev/null @@ -1,107 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include -#endif - -#include -#include -#include - -#include -#include -#include -#include - -namespace spdlog { -namespace cfg { -namespace helpers { - -// inplace convert to lowercase -inline std::string &to_lower_(std::string &str) { - std::transform(str.begin(), str.end(), str.begin(), [](char ch) { - return static_cast((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch); - }); - return str; -} - -// inplace trim spaces -inline std::string &trim_(std::string &str) { - const char *spaces = " \n\r\t"; - str.erase(str.find_last_not_of(spaces) + 1); - str.erase(0, str.find_first_not_of(spaces)); - return str; -} - -// return (name,value) trimmed pair from given "name=value" string. -// return empty string on missing parts -// "key=val" => ("key", "val") -// " key = val " => ("key", "val") -// "key=" => ("key", "") -// "val" => ("", "val") - -inline std::pair extract_kv_(char sep, const std::string &str) { - auto n = str.find(sep); - std::string k, v; - if (n == std::string::npos) { - v = str; - } else { - k = str.substr(0, n); - v = str.substr(n + 1); - } - return std::make_pair(trim_(k), trim_(v)); -} - -// return vector of key/value pairs from sequence of "K1=V1,K2=V2,.." -// "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...} -inline std::unordered_map extract_key_vals_(const std::string &str) { - std::string token; - std::istringstream token_stream(str); - std::unordered_map rv{}; - while (std::getline(token_stream, token, ',')) { - if (token.empty()) { - continue; - } - auto kv = extract_kv_('=', token); - rv[kv.first] = kv.second; - } - return rv; -} - -SPDLOG_INLINE void load_levels(const std::string &input) { - if (input.empty() || input.size() > 512) { - return; - } - - auto key_vals = extract_key_vals_(input); - std::unordered_map levels; - level::level_enum global_level = level::info; - bool global_level_found = false; - - for (auto &name_level : key_vals) { - auto &logger_name = name_level.first; - auto level_name = to_lower_(name_level.second); - auto level = level::from_str(level_name); - // ignore unrecognized level names - if (level == level::off && level_name != "off") { - continue; - } - if (logger_name.empty()) // no logger name indicate global level - { - global_level_found = true; - global_level = level; - } else { - levels[logger_name] = level; - } - } - - details::registry::instance().set_levels(std::move(levels), - global_level_found ? &global_level : nullptr); -} - -} // namespace helpers -} // namespace cfg -} // namespace spdlog diff --git a/include/spdlog/cfg/helpers.h b/include/spdlog/cfg/helpers.h deleted file mode 100644 index c0238189..00000000 --- a/include/spdlog/cfg/helpers.h +++ /dev/null @@ -1,29 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include -#include - -namespace spdlog { -namespace cfg { -namespace helpers { -// -// Init levels from given string -// -// Examples: -// -// set global level to debug: "debug" -// turn off all logging except for logger1: "off,logger1=debug" -// turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info" -// -SPDLOG_API void load_levels(const std::string &txt); -} // namespace helpers - -} // namespace cfg -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "helpers-inl.h" -#endif // SPDLOG_HEADER_ONLY diff --git a/include/spdlog/details/registry-inl.h b/include/spdlog/details/registry-inl.h deleted file mode 100644 index 39da4700..00000000 --- a/include/spdlog/details/registry-inl.h +++ /dev/null @@ -1,278 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include -#endif - -#include -#include -#include -#include - -#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER - // support for the default stdout color logger - #ifdef _WIN32 - #include - #else - #include - #endif -#endif // SPDLOG_DISABLE_DEFAULT_LOGGER - -#include -#include -#include -#include -#include -#include - - -namespace spdlog { -namespace details { - - -SPDLOG_INLINE static std::shared_ptr s_instance = std::make_shared(); - -SPDLOG_INLINE registry ®istry::instance() { - return *s_instance; -} - -SPDLOG_INLINE std::shared_ptr registry::shared_instance() { - return s_instance; -} - -SPDLOG_INLINE void registry::set_instance(std::shared_ptr instance) { - s_instance = instance; -} - -SPDLOG_INLINE registry::registry() - : formatter_(new pattern_formatter()) { -#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER - // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows). - #ifdef _WIN32 - auto color_sink = std::make_shared(); - #else - auto color_sink = std::make_shared(); - #endif - - const char *default_logger_name = ""; - default_logger_ = std::make_shared(default_logger_name, std::move(color_sink)); - loggers_[default_logger_name] = default_logger_; - -#endif // SPDLOG_DISABLE_DEFAULT_LOGGER -} - -SPDLOG_INLINE registry::~registry() = default; - -SPDLOG_INLINE void registry::register_logger(std::shared_ptr new_logger) { - std::lock_guard lock(logger_map_mutex_); - register_logger_(std::move(new_logger)); -} - -SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr new_logger) { - std::lock_guard lock(logger_map_mutex_); - new_logger->set_formatter(formatter_->clone()); - - if (err_handler_) { - new_logger->set_error_handler(err_handler_); - } - - // set new level according to previously configured level or default level - auto it = log_levels_.find(new_logger->name()); - auto new_level = it != log_levels_.end() ? it->second : global_log_level_; - new_logger->set_level(new_level); - - new_logger->flush_on(flush_level_); - - if (backtrace_n_messages_ > 0) { - new_logger->enable_backtrace(backtrace_n_messages_); - } - - if (automatic_registration_) { - register_logger_(std::move(new_logger)); - } -} - -SPDLOG_INLINE std::shared_ptr registry::get(const std::string &logger_name) { - std::lock_guard lock(logger_map_mutex_); - auto found = loggers_.find(logger_name); - return found == loggers_.end() ? nullptr : found->second; -} - -SPDLOG_INLINE std::shared_ptr registry::default_logger() { - std::lock_guard 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. -SPDLOG_INLINE logger *registry::get_default_raw() { return default_logger_.get(); } - -// set default logger. -// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. -SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr new_default_logger) { - std::lock_guard lock(logger_map_mutex_); - if (new_default_logger != nullptr) { - loggers_[new_default_logger->name()] = new_default_logger; - } - default_logger_ = std::move(new_default_logger); -} - -SPDLOG_INLINE void registry::set_tp(std::shared_ptr tp) { - std::lock_guard lock(tp_mutex_); - tp_ = std::move(tp); -} - -SPDLOG_INLINE std::shared_ptr registry::get_tp() { - std::lock_guard lock(tp_mutex_); - return tp_; -} - -// Set global formatter. Each sink in each logger will get a clone of this object -SPDLOG_INLINE void registry::set_formatter(std::unique_ptr formatter) { - std::lock_guard lock(logger_map_mutex_); - formatter_ = std::move(formatter); - for (auto &l : loggers_) { - l.second->set_formatter(formatter_->clone()); - } -} - -SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) { - std::lock_guard lock(logger_map_mutex_); - backtrace_n_messages_ = n_messages; - - for (auto &l : loggers_) { - l.second->enable_backtrace(n_messages); - } -} - -SPDLOG_INLINE void registry::disable_backtrace() { - std::lock_guard lock(logger_map_mutex_); - backtrace_n_messages_ = 0; - for (auto &l : loggers_) { - l.second->disable_backtrace(); - } -} - -SPDLOG_INLINE void registry::set_level(level::level_enum log_level) { - std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) { - l.second->set_level(log_level); - } - global_log_level_ = log_level; -} - -SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) { - std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) { - l.second->flush_on(log_level); - } - flush_level_ = log_level; -} - -SPDLOG_INLINE void registry::set_error_handler(err_handler handler) { - std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) { - l.second->set_error_handler(handler); - } - err_handler_ = std::move(handler); -} - -SPDLOG_INLINE void registry::apply_all( - const std::function)> &fun) { - std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) { - fun(l.second); - } -} - -SPDLOG_INLINE void registry::flush_all() { - std::lock_guard lock(logger_map_mutex_); - for (auto &l : loggers_) { - l.second->flush(); - } -} - -SPDLOG_INLINE void registry::drop(const std::string &logger_name) { - std::lock_guard lock(logger_map_mutex_); - auto is_default_logger = default_logger_ && default_logger_->name() == logger_name; - loggers_.erase(logger_name); - if (is_default_logger) { - default_logger_.reset(); - } -} - -SPDLOG_INLINE void registry::drop_all() { - std::lock_guard lock(logger_map_mutex_); - loggers_.clear(); - default_logger_.reset(); -} - -// clean all resources and threads started by the registry -SPDLOG_INLINE void registry::shutdown() { - { - std::lock_guard lock(flusher_mutex_); - periodic_flusher_.reset(); - } - - drop_all(); - - { - std::lock_guard lock(tp_mutex_); - tp_.reset(); - } -} - -SPDLOG_INLINE std::recursive_mutex ®istry::tp_mutex() { return tp_mutex_; } - -SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) { - std::lock_guard lock(logger_map_mutex_); - automatic_registration_ = automatic_registration; -} - -SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level) { - std::lock_guard lock(logger_map_mutex_); - log_levels_ = std::move(levels); - auto global_level_requested = global_level != nullptr; - global_log_level_ = global_level_requested ? *global_level : global_log_level_; - - for (auto &logger : loggers_) { - auto logger_entry = log_levels_.find(logger.first); - if (logger_entry != log_levels_.end()) { - logger.second->set_level(logger_entry->second); - } else if (global_level_requested) { - logger.second->set_level(*global_level); - } - } -} - - -SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr new_logger) { - std::lock_guard lock(logger_map_mutex_); - auto it = log_levels_.find(new_logger->name()); - auto new_level = it != log_levels_.end() ? it->second : global_log_level_; - new_logger->set_level(new_level); -} - -SPDLOG_INLINE std::mutex ®istry::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"); - } -} - -SPDLOG_INLINE void registry::register_logger_(std::shared_ptr new_logger) { - auto logger_name = new_logger->name(); - throw_if_exists_(logger_name); - loggers_[logger_name] = std::move(new_logger); -} - -} // namespace details -} // namespace spdlog diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h deleted file mode 100644 index 5fd7506c..00000000 --- a/include/spdlog/details/registry.h +++ /dev/null @@ -1,134 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -// Loggers registry of unique name->logger pointer -// An attempt to create a logger with an already existing name will result with spdlog_ex exception. -// If user requests a non existing logger, nullptr will be returned -// This class is thread safe - -#include -#include - -#include -#include -#include -#include -#include -#include - -namespace spdlog { -class logger; - -namespace details { -class thread_pool; - -class SPDLOG_API registry { -public: - registry(); - ~registry(); - - using log_levels = std::unordered_map; - registry(const registry &) = delete; - registry &operator=(const registry &) = delete; - - void register_logger(std::shared_ptr new_logger); - void initialize_logger(std::shared_ptr new_logger); - std::shared_ptr get(const std::string &logger_name); - std::shared_ptr 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(); - - // set default logger and add it to the registry if not registered already. - // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. - // Note: Make sure to unregister it when no longer needed or before calling again with a new - // logger. - void set_default_logger(std::shared_ptr new_default_logger); - - void set_tp(std::shared_ptr tp); - - std::shared_ptr get_tp(); - - // Set global formatter. Each sink in each logger will get a clone of this object - void set_formatter(std::unique_ptr formatter); - - void enable_backtrace(size_t n_messages); - - void disable_backtrace(); - - void set_level(level::level_enum log_level); - - void flush_on(level::level_enum log_level); - - template - void flush_every(std::chrono::duration interval) { - std::lock_guard lock(flusher_mutex_); - auto clbk = [this]() { this->flush_all(); }; - periodic_flusher_ = details::make_unique(clbk, interval); - } - - std::unique_ptr &get_flusher() { - std::lock_guard lock(flusher_mutex_); - return periodic_flusher_; - } - - void set_error_handler(err_handler handler); - - void apply_all(const std::function)> &fun); - - void flush_all(); - - void drop(const std::string &logger_name); - - void drop_all(); - - // clean all resources and threads started by the registry - void shutdown(); - - std::recursive_mutex &tp_mutex(); - - void set_automatic_registration(bool automatic_registration); - - // set levels for all existing/future loggers. global_level can be null if should not set. - void set_levels(log_levels levels, level::level_enum *global_level); - - static void set_instance(std::shared_ptr instance); - static registry &instance(); - static std::shared_ptr shared_instance(); - - void apply_logger_env_levels(std::shared_ptr new_logger); - - std::mutex& console_mutex(); - -private: - void throw_if_exists_(const std::string &logger_name); - void register_logger_(std::shared_ptr new_logger); - bool set_level_from_cfg_(logger *logger); - std::mutex logger_map_mutex_, flusher_mutex_; - std::recursive_mutex tp_mutex_; - std::unordered_map> loggers_; - log_levels log_levels_; - std::unique_ptr formatter_; - spdlog::level::level_enum global_log_level_ = level::info; - level::level_enum flush_level_ = level::off; - err_handler err_handler_; - std::shared_ptr tp_; - std::unique_ptr periodic_flusher_; - std::shared_ptr default_logger_; - bool automatic_registration_ = true; - size_t backtrace_n_messages_ = 0; - std::mutex console_mutex_; -}; - -} // namespace details -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "registry-inl.h" -#endif diff --git a/include/spdlog/details/synchronous_factory.h b/include/spdlog/details/synchronous_factory.h deleted file mode 100644 index 4bd5a51c..00000000 --- a/include/spdlog/details/synchronous_factory.h +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include "registry.h" - -namespace spdlog { - -// Default logger factory- creates synchronous loggers -class logger; - -struct synchronous_factory { - template - static std::shared_ptr create(std::string logger_name, SinkArgs &&...args) { - auto sink = std::make_shared(std::forward(args)...); - auto new_logger = std::make_shared(std::move(logger_name), std::move(sink)); - details::registry::instance().initialize_logger(new_logger); - return new_logger; - } -}; -} // namespace spdlog diff --git a/include/spdlog/details/thread_pool.h b/include/spdlog/details/thread_pool.h index f22b0782..401c8348 100644 --- a/include/spdlog/details/thread_pool.h +++ b/include/spdlog/details/thread_pool.h @@ -7,7 +7,6 @@ #include #include -#include #include #include #include @@ -16,6 +15,7 @@ namespace spdlog { class async_logger; +enum class async_overflow_policy; namespace details { using async_logger_ptr = std::shared_ptr; diff --git a/include/spdlog/sinks/basic_file_sink.h b/include/spdlog/sinks/basic_file_sink.h index 699caa14..48f20308 100644 --- a/include/spdlog/sinks/basic_file_sink.h +++ b/include/spdlog/sinks/basic_file_sink.h @@ -5,7 +5,6 @@ #include #include -#include #include #include @@ -37,27 +36,6 @@ using basic_file_sink_st = basic_file_sink; } // namespace sinks -// -// factory functions -// -template -inline std::shared_ptr basic_logger_mt(const std::string &logger_name, - const filename_t &filename, - bool truncate = false, - const file_event_handlers &event_handlers = {}) { - return Factory::template create(logger_name, filename, truncate, - event_handlers); -} - -template -inline std::shared_ptr basic_logger_st(const std::string &logger_name, - const filename_t &filename, - bool truncate = false, - const file_event_handlers &event_handlers = {}) { - return Factory::template create(logger_name, filename, truncate, - event_handlers); -} - } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY diff --git a/include/spdlog/sinks/callback_sink.h b/include/spdlog/sinks/callback_sink.h index 5f8b6bc4..c4faa4ca 100644 --- a/include/spdlog/sinks/callback_sink.h +++ b/include/spdlog/sinks/callback_sink.h @@ -4,7 +4,6 @@ #pragma once #include -#include #include #include @@ -35,22 +34,5 @@ private: using callback_sink_mt = callback_sink; using callback_sink_st = callback_sink; - } // namespace sinks - -// -// factory functions -// -template -inline std::shared_ptr callback_logger_mt(const std::string &logger_name, - const custom_log_callback &callback) { - return Factory::template create(logger_name, callback); -} - -template -inline std::shared_ptr callback_logger_st(const std::string &logger_name, - const custom_log_callback &callback) { - return Factory::template create(logger_name, callback); -} - } // namespace spdlog diff --git a/include/spdlog/sinks/daily_file_sink.h b/include/spdlog/sinks/daily_file_sink.h index 615c9f7b..fb226daa 100644 --- a/include/spdlog/sinks/daily_file_sink.h +++ b/include/spdlog/sinks/daily_file_sink.h @@ -8,7 +8,6 @@ #include #include #include -#include #include #include #include @@ -196,59 +195,5 @@ using daily_file_sink_st = daily_file_sink; using daily_file_format_sink_mt = daily_file_sink; using daily_file_format_sink_st = daily_file_sink; - } // namespace sinks - -// -// factory functions -// -template -inline std::shared_ptr daily_logger_mt(const std::string &logger_name, - const filename_t &filename, - int hour = 0, - int minute = 0, - bool truncate = false, - uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) { - return Factory::template create(logger_name, filename, hour, minute, - truncate, max_files, event_handlers); -} - -template -inline std::shared_ptr daily_logger_format_mt( - const std::string &logger_name, - const filename_t &filename, - int hour = 0, - int minute = 0, - bool truncate = false, - uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) { - return Factory::template create( - logger_name, filename, hour, minute, truncate, max_files, event_handlers); -} - -template -inline std::shared_ptr daily_logger_st(const std::string &logger_name, - const filename_t &filename, - int hour = 0, - int minute = 0, - bool truncate = false, - uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) { - return Factory::template create(logger_name, filename, hour, minute, - truncate, max_files, event_handlers); -} - -template -inline std::shared_ptr daily_logger_format_st( - const std::string &logger_name, - const filename_t &filename, - int hour = 0, - int minute = 0, - bool truncate = false, - uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) { - return Factory::template create( - logger_name, filename, hour, minute, truncate, max_files, event_handlers); -} } // namespace spdlog diff --git a/include/spdlog/sinks/null_sink.h b/include/spdlog/sinks/null_sink.h index c51247fe..c9afb57e 100644 --- a/include/spdlog/sinks/null_sink.h +++ b/include/spdlog/sinks/null_sink.h @@ -4,7 +4,6 @@ #pragma once #include -#include #include #include @@ -21,21 +20,5 @@ protected: using null_sink_mt = null_sink; using null_sink_st = null_sink; - } // namespace sinks - -template -inline std::shared_ptr null_logger_mt(const std::string &logger_name) { - auto null_logger = Factory::template create(logger_name); - null_logger->set_level(level::off); - return null_logger; -} - -template -inline std::shared_ptr null_logger_st(const std::string &logger_name) { - auto null_logger = Factory::template create(logger_name); - null_logger->set_level(level::off); - return null_logger; -} - } // namespace spdlog diff --git a/include/spdlog/sinks/rotating_file_sink.h b/include/spdlog/sinks/rotating_file_sink.h index cd43d349..76d49173 100644 --- a/include/spdlog/sinks/rotating_file_sink.h +++ b/include/spdlog/sinks/rotating_file_sink.h @@ -5,7 +5,6 @@ #include #include -#include #include #include @@ -56,32 +55,6 @@ using rotating_file_sink_mt = rotating_file_sink; using rotating_file_sink_st = rotating_file_sink; } // namespace sinks - -// -// factory functions -// - -template -inline std::shared_ptr rotating_logger_mt(const std::string &logger_name, - const filename_t &filename, - size_t max_file_size, - size_t max_files, - bool rotate_on_open = false, - const file_event_handlers &event_handlers = {}) { - return Factory::template create( - logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); -} - -template -inline std::shared_ptr rotating_logger_st(const std::string &logger_name, - const filename_t &filename, - size_t max_file_size, - size_t max_files, - bool rotate_on_open = false, - const file_event_handlers &event_handlers = {}) { - return Factory::template create( - logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers); -} } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY diff --git a/include/spdlog/sinks/stdout_color_sinks.h b/include/spdlog/sinks/stdout_color_sinks.h index 72991fe0..e0e4c070 100644 --- a/include/spdlog/sinks/stdout_color_sinks.h +++ b/include/spdlog/sinks/stdout_color_sinks.h @@ -9,39 +9,21 @@ #include #endif -#include namespace spdlog { namespace sinks { #ifdef _WIN32 -using stdout_color_sink_mt = wincolor_stdout_sink_mt; -using stdout_color_sink_st = wincolor_stdout_sink_st; -using stderr_color_sink_mt = wincolor_stderr_sink_mt; -using stderr_color_sink_st = wincolor_stderr_sink_st; + using stdout_color_sink_mt = wincolor_stdout_sink_mt; + using stdout_color_sink_st = wincolor_stdout_sink_st; + using stderr_color_sink_mt = wincolor_stderr_sink_mt; + using stderr_color_sink_st = wincolor_stderr_sink_st; #else -using stdout_color_sink_mt = ansicolor_stdout_sink_mt; -using stdout_color_sink_st = ansicolor_stdout_sink_st; -using stderr_color_sink_mt = ansicolor_stderr_sink_mt; -using stderr_color_sink_st = ansicolor_stderr_sink_st; + using stdout_color_sink_mt = ansicolor_stdout_sink_mt; + using stdout_color_sink_st = ansicolor_stdout_sink_st; + using stderr_color_sink_mt = ansicolor_stderr_sink_mt; + using stderr_color_sink_st = ansicolor_stderr_sink_st; #endif } // namespace sinks - -template -std::shared_ptr stdout_color_mt(const std::string &logger_name, - color_mode mode = color_mode::automatic); - -template -std::shared_ptr stdout_color_st(const std::string &logger_name, - color_mode mode = color_mode::automatic); - -template -std::shared_ptr stderr_color_mt(const std::string &logger_name, - color_mode mode = color_mode::automatic); - -template -std::shared_ptr stderr_color_st(const std::string &logger_name, - color_mode mode = color_mode::automatic); - } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY diff --git a/include/spdlog/sinks/stdout_sinks-inl.h b/include/spdlog/sinks/stdout_sinks-inl.h index 2ed41b92..58ac897a 100644 --- a/include/spdlog/sinks/stdout_sinks-inl.h +++ b/include/spdlog/sinks/stdout_sinks-inl.h @@ -83,25 +83,4 @@ SPDLOG_INLINE stderr_sink::stderr_sink() : stdout_sink_base(stderr) {} } // namespace sinks - -// factory methods -template -SPDLOG_INLINE std::shared_ptr stdout_logger_mt(const std::string &logger_name) { - return Factory::template create(logger_name); -} - -template -SPDLOG_INLINE std::shared_ptr stdout_logger_st(const std::string &logger_name) { - return Factory::template create(logger_name); -} - -template -SPDLOG_INLINE std::shared_ptr stderr_logger_mt(const std::string &logger_name) { - return Factory::template create(logger_name); -} - -template -SPDLOG_INLINE std::shared_ptr stderr_logger_st(const std::string &logger_name) { - return Factory::template create(logger_name); -} } // namespace spdlog diff --git a/include/spdlog/sinks/stdout_sinks.h b/include/spdlog/sinks/stdout_sinks.h index 0f6188eb..d99601a2 100644 --- a/include/spdlog/sinks/stdout_sinks.h +++ b/include/spdlog/sinks/stdout_sinks.h @@ -4,7 +4,6 @@ #pragma once #include -#include #include #ifdef _WIN32 @@ -54,20 +53,6 @@ using stderr_sink_mt = stderr_sink; using stderr_sink_st = stderr_sink; } // namespace sinks - -// factory methods -template -std::shared_ptr stdout_logger_mt(const std::string &logger_name); - -template -std::shared_ptr stdout_logger_st(const std::string &logger_name); - -template -std::shared_ptr stderr_logger_mt(const std::string &logger_name); - -template -std::shared_ptr stderr_logger_st(const std::string &logger_name); - } // namespace spdlog #ifdef SPDLOG_HEADER_ONLY diff --git a/include/spdlog/spdlog-inl.h b/include/spdlog/spdlog-inl.h index 97c36222..bd11dc3c 100644 --- a/include/spdlog/spdlog-inl.h +++ b/include/spdlog/spdlog-inl.h @@ -9,19 +9,20 @@ #include #include +#include namespace spdlog { -SPDLOG_INLINE void initialize_logger(std::shared_ptr logger) { - details::registry::instance().initialize_logger(std::move(logger)); -} +#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER +using default_sink_t = sinks::stdout_color_sink_mt; +#else +using default_sink_t = sinks::null_sink_mt; +#endif -SPDLOG_INLINE std::shared_ptr get(const std::string &name) { - return details::registry::instance().get(name); -} +SPDLOG_INLINE static auto s_logger = std::make_shared("", std::make_shared()); SPDLOG_INLINE void set_formatter(std::unique_ptr formatter) { - details::registry::instance().set_formatter(std::move(formatter)); + s_logger->set_formatter(std::move(formatter)); } SPDLOG_INLINE void set_pattern(std::string pattern, pattern_time_type time_type) { @@ -30,63 +31,41 @@ SPDLOG_INLINE void set_pattern(std::string pattern, pattern_time_type time_type) } SPDLOG_INLINE void enable_backtrace(size_t n_messages) { - details::registry::instance().enable_backtrace(n_messages); + s_logger->enable_backtrace(n_messages); } -SPDLOG_INLINE void disable_backtrace() { details::registry::instance().disable_backtrace(); } +SPDLOG_INLINE void disable_backtrace() { s_logger->disable_backtrace(); } -SPDLOG_INLINE void dump_backtrace() { default_logger_raw()->dump_backtrace(); } +SPDLOG_INLINE void dump_backtrace() { s_logger->dump_backtrace(); } -SPDLOG_INLINE level::level_enum get_level() { return default_logger_raw()->level(); } +SPDLOG_INLINE level::level_enum get_level() { return s_logger->level(); } SPDLOG_INLINE bool should_log(level::level_enum log_level) { - return default_logger_raw()->should_log(log_level); + return default_logger()->should_log(log_level); } SPDLOG_INLINE void set_level(level::level_enum log_level) { - details::registry::instance().set_level(log_level); + s_logger->set_level(log_level); } SPDLOG_INLINE void flush_on(level::level_enum log_level) { - details::registry::instance().flush_on(log_level); + s_logger->flush_on(log_level); } SPDLOG_INLINE void set_error_handler(void (*handler)(const std::string &msg)) { - details::registry::instance().set_error_handler(handler); + s_logger->set_error_handler(handler); } -SPDLOG_INLINE void register_logger(std::shared_ptr logger) { - details::registry::instance().register_logger(std::move(logger)); -} -SPDLOG_INLINE void apply_all(const std::function)> &fun) { - details::registry::instance().apply_all(fun); -} - -SPDLOG_INLINE void drop(const std::string &name) { details::registry::instance().drop(name); } - -SPDLOG_INLINE void drop_all() { details::registry::instance().drop_all(); } - -SPDLOG_INLINE void shutdown() { details::registry::instance().shutdown(); } - -SPDLOG_INLINE void set_automatic_registration(bool automatic_registration) { - details::registry::instance().set_automatic_registration(automatic_registration); -} +SPDLOG_INLINE void shutdown() { s_logger.reset(); } SPDLOG_INLINE std::shared_ptr default_logger() { - return details::registry::instance().default_logger(); + return s_logger; } -SPDLOG_INLINE spdlog::logger *default_logger_raw() { - return details::registry::instance().get_default_raw(); -} SPDLOG_INLINE void set_default_logger(std::shared_ptr default_logger) { - details::registry::instance().set_default_logger(std::move(default_logger)); -} - -SPDLOG_INLINE void apply_logger_env_levels(std::shared_ptr logger) { - details::registry::instance().apply_logger_env_levels(std::move(logger)); + s_logger = std::move(default_logger); } } // namespace spdlog diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h index a8afbcec..37133660 100644 --- a/include/spdlog/spdlog.h +++ b/include/spdlog/spdlog.h @@ -10,8 +10,6 @@ #pragma once #include -#include -#include #include #include @@ -22,35 +20,6 @@ namespace spdlog { -using default_factory = synchronous_factory; - -// Create and register 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("logger_name", "dailylog_filename", 11, 59); -template -inline std::shared_ptr create(std::string logger_name, SinkArgs &&...sink_args) { - return default_factory::create(std::move(logger_name), - std::forward(sink_args)...); -} - -// Initialize and register a logger, -// formatter and flush level will be set according the global settings. -// -// Useful for initializing manually created loggers with the global settings. -// -// Example: -// auto mylogger = std::make_shared("mylogger", ...); -// spdlog::initialize_logger(mylogger); -SPDLOG_API void initialize_logger(std::shared_ptr logger); - -// Return an existing logger or nullptr if a logger with such name doesn't -// exist. -// example: spdlog::get("my_logger")->info("hello {}", "world"); -SPDLOG_API std::shared_ptr get(const std::string &name); - // Set global formatter. Each sink in each logger will get a clone of this object SPDLOG_API void set_formatter(std::unique_ptr formatter); @@ -80,36 +49,14 @@ SPDLOG_API bool should_log(level::level_enum lvl); // Set global flush level SPDLOG_API void flush_on(level::level_enum log_level); -// Start/Restart a periodic flusher thread -// Warning: Use only if all your loggers are thread safe! -template -inline void flush_every(std::chrono::duration interval) { - details::registry::instance().flush_every(interval); -} // Set global error handler SPDLOG_API void set_error_handler(void (*handler)(const std::string &msg)); -// Register the given logger with the given name -SPDLOG_API void register_logger(std::shared_ptr logger); - -// Apply a user defined function on all registered loggers -// Example: -// spdlog::apply_all([&](std::shared_ptr l) {l->flush();}); -SPDLOG_API void apply_all(const std::function)> &fun); - -// Drop the reference to the given logger -SPDLOG_API void drop(const std::string &name); - -// Drop all references from the registry -SPDLOG_API void drop_all(); // stop any running threads started by spdlog and clean registry loggers SPDLOG_API void shutdown(); -// Automatic registration of loggers when using spdlog::create() or spdlog::create_async -SPDLOG_API void set_automatic_registration(bool automatic_registration); - // API for using default logger (stdout_color_mt), // e.g: spdlog::info("Message {}", 1); // @@ -127,70 +74,60 @@ SPDLOG_API void set_automatic_registration(bool automatic_registration); SPDLOG_API std::shared_ptr default_logger(); -SPDLOG_API spdlog::logger *default_logger_raw(); - SPDLOG_API void set_default_logger(std::shared_ptr default_logger); -// Initialize logger level based on environment configs. -// -// Useful for applying SPDLOG_LEVEL to manually created loggers. -// -// Example: -// auto mylogger = std::make_shared("mylogger", ...); -// spdlog::apply_logger_env_levels(mylogger); -SPDLOG_API void apply_logger_env_levels(std::shared_ptr logger); template inline void log(source_loc source, level::level_enum lvl, format_string_t fmt, Args &&...args) { - default_logger_raw()->log(source, lvl, fmt, std::forward(args)...); + default_logger()->log(source, lvl, fmt, std::forward(args)...); } template inline void log(level::level_enum lvl, format_string_t fmt, Args &&...args) { - default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward(args)...); + default_logger()->log(source_loc{}, lvl, fmt, std::forward(args)...); } template inline void trace(format_string_t fmt, Args &&...args) { - default_logger_raw()->trace(fmt, std::forward(args)...); + default_logger()->trace(fmt, std::forward(args)...); } template inline void debug(format_string_t fmt, Args &&...args) { - default_logger_raw()->debug(fmt, std::forward(args)...); + default_logger()->debug(fmt, std::forward(args)...); } template inline void info(format_string_t fmt, Args &&...args) { - default_logger_raw()->info(fmt, std::forward(args)...); + default_logger()->info(fmt, std::forward(args)...); } template inline void warn(format_string_t fmt, Args &&...args) { - default_logger_raw()->warn(fmt, std::forward(args)...); + default_logger()->warn(fmt, std::forward(args)...); } template inline void error(format_string_t fmt, Args &&...args) { - default_logger_raw()->error(fmt, std::forward(args)...); + default_logger()->error(fmt, std::forward(args)...); } template inline void critical(format_string_t fmt, Args &&...args) { - default_logger_raw()->critical(fmt, std::forward(args)...); + default_logger()->critical(fmt, std::forward(args)...); } template inline void log(source_loc source, level::level_enum lvl, const T &msg) { - default_logger_raw()->log(source, lvl, msg); + default_logger()->log(source, lvl, msg); } template inline void log(level::level_enum lvl, const T &msg) { - default_logger_raw()->log(lvl, msg); + default_logger()->log(lvl, msg); } #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT @@ -240,32 +177,32 @@ inline void critical(wformat_string_t fmt, Args &&...args) { template inline void trace(const T &msg) { - default_logger_raw()->trace(msg); + default_logger()->trace(msg); } template inline void debug(const T &msg) { - default_logger_raw()->debug(msg); + default_logger()->debug(msg); } template inline void info(const T &msg) { - default_logger_raw()->info(msg); + default_logger()->info(msg); } template inline void warn(const T &msg) { - default_logger_raw()->warn(msg); + default_logger()->warn(msg); } template inline void error(const T &msg) { - default_logger_raw()->error(msg); + default_logger()->error(msg); } template inline void critical(const T &msg) { - default_logger_raw()->critical(msg); + default_logger()->critical(msg); } } // namespace spdlog @@ -303,7 +240,7 @@ inline void critical(const T &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::default_logger(), __VA_ARGS__) #else #define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0 #define SPDLOG_DEBUG(...) (void)0 @@ -312,7 +249,7 @@ inline void critical(const T &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::default_logger(), __VA_ARGS__) #else #define SPDLOG_LOGGER_INFO(logger, ...) (void)0 #define SPDLOG_INFO(...) (void)0 @@ -321,7 +258,7 @@ inline void critical(const T &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::default_logger(), __VA_ARGS__) #else #define SPDLOG_LOGGER_WARN(logger, ...) (void)0 #define SPDLOG_WARN(...) (void)0 @@ -330,7 +267,7 @@ inline void critical(const T &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::default_logger(), __VA_ARGS__) #else #define SPDLOG_LOGGER_ERROR(logger, ...) (void)0 #define SPDLOG_ERROR(...) (void)0 @@ -339,7 +276,7 @@ inline void critical(const T &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::default_logger(), __VA_ARGS__) #else #define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0 #define SPDLOG_CRITICAL(...) (void)0 diff --git a/src/cfg.cpp b/src/cfg.cpp deleted file mode 100644 index ebdea166..00000000 --- a/src/cfg.cpp +++ /dev/null @@ -1,8 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#ifndef SPDLOG_COMPILED_LIB - #error Please define SPDLOG_COMPILED_LIB to compile this file. -#endif - -#include diff --git a/src/color_sinks.cpp b/src/color_sinks.cpp index 3c1a7354..2225a80b 100644 --- a/src/color_sinks.cpp +++ b/src/color_sinks.cpp @@ -14,42 +14,18 @@ // #ifdef _WIN32 #include -template class SPDLOG_API spdlog::sinks::wincolor_sink; -template class SPDLOG_API spdlog::sinks::wincolor_sink; -template class SPDLOG_API spdlog::sinks::wincolor_stdout_sink; -template class SPDLOG_API spdlog::sinks::wincolor_stdout_sink; -template class SPDLOG_API spdlog::sinks::wincolor_stderr_sink; -template class SPDLOG_API spdlog::sinks::wincolor_stderr_sink; + template class SPDLOG_API spdlog::sinks::wincolor_sink; + template class SPDLOG_API spdlog::sinks::wincolor_sink; + template class SPDLOG_API spdlog::sinks::wincolor_stdout_sink; + template class SPDLOG_API spdlog::sinks::wincolor_stdout_sink; + template class SPDLOG_API spdlog::sinks::wincolor_stderr_sink; + template class SPDLOG_API spdlog::sinks::wincolor_stderr_sink; #else #include "spdlog/sinks/ansicolor_sink-inl.h" -template class SPDLOG_API spdlog::sinks::ansicolor_sink; -template class SPDLOG_API spdlog::sinks::ansicolor_sink; -template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink; -template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink; -template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink; -template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink; + template class SPDLOG_API spdlog::sinks::ansicolor_sink; + template class SPDLOG_API spdlog::sinks::ansicolor_sink; + template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink; + template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink; + template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink; + template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink; #endif - -// factory methods for color loggers -#include "spdlog/sinks/stdout_color_sinks-inl.h" -template SPDLOG_API std::shared_ptr -spdlog::stdout_color_mt(const std::string &logger_name, - color_mode mode); -template SPDLOG_API std::shared_ptr -spdlog::stdout_color_st(const std::string &logger_name, - color_mode mode); -template SPDLOG_API std::shared_ptr -spdlog::stderr_color_mt(const std::string &logger_name, - color_mode mode); -template SPDLOG_API std::shared_ptr -spdlog::stderr_color_st(const std::string &logger_name, - color_mode mode); - -template SPDLOG_API std::shared_ptr spdlog::stdout_color_mt( - const std::string &logger_name, color_mode mode); -template SPDLOG_API std::shared_ptr spdlog::stdout_color_st( - const std::string &logger_name, color_mode mode); -template SPDLOG_API std::shared_ptr spdlog::stderr_color_mt( - const std::string &logger_name, color_mode mode); -template SPDLOG_API std::shared_ptr spdlog::stderr_color_st( - const std::string &logger_name, color_mode mode); diff --git a/src/spdlog.cpp b/src/spdlog.cpp index 9f8390bc..a0d00cc7 100644 --- a/src/spdlog.cpp +++ b/src/spdlog.cpp @@ -11,7 +11,6 @@ #include #include #include -#include #include #include #include diff --git a/src/stdout_sinks.cpp b/src/stdout_sinks.cpp index 5d6a8aef..0020beb8 100644 --- a/src/stdout_sinks.cpp +++ b/src/stdout_sinks.cpp @@ -17,21 +17,3 @@ template class SPDLOG_API spdlog::sinks::stdout_sink; template class SPDLOG_API spdlog::sinks::stdout_sink; template class SPDLOG_API spdlog::sinks::stderr_sink; template class SPDLOG_API spdlog::sinks::stderr_sink; - -template SPDLOG_API std::shared_ptr -spdlog::stdout_logger_mt(const std::string &logger_name); -template SPDLOG_API std::shared_ptr -spdlog::stdout_logger_st(const std::string &logger_name); -template SPDLOG_API std::shared_ptr -spdlog::stderr_logger_mt(const std::string &logger_name); -template SPDLOG_API std::shared_ptr -spdlog::stderr_logger_st(const std::string &logger_name); - -template SPDLOG_API std::shared_ptr spdlog::stdout_logger_mt( - const std::string &logger_name); -template SPDLOG_API std::shared_ptr spdlog::stdout_logger_st( - const std::string &logger_name); -template SPDLOG_API std::shared_ptr spdlog::stderr_logger_mt( - const std::string &logger_name); -template SPDLOG_API std::shared_ptr spdlog::stderr_logger_st( - const std::string &logger_name); diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 0a3d77eb..63dbfb51 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -34,7 +34,6 @@ set(SPDLOG_UTESTS_SOURCES test_eventlog.cpp test_pattern_formatter.cpp test_async.cpp - test_registry.cpp test_macros.cpp utils.cpp main.cpp @@ -45,8 +44,7 @@ set(SPDLOG_UTESTS_SOURCES test_backtrace.cpp test_create_dir.cpp test_custom_callbacks.cpp - test_cfg.cpp - test_time_point.cpp + test_time_point.cpp test_stopwatch.cpp test_circular_q.cpp) diff --git a/tests/includes.h b/tests/includes.h index 635e8208..0e980a54 100644 --- a/tests/includes.h +++ b/tests/includes.h @@ -35,3 +35,4 @@ #include "spdlog/sinks/stdout_color_sinks.h" #include "spdlog/sinks/msvc_sink.h" #include "spdlog/pattern_formatter.h" +#include "spdlog/details/thread_pool.h" diff --git a/tests/test_async.cpp b/tests/test_async.cpp index 76fdd7c6..a97aeb3b 100644 --- a/tests/test_async.cpp +++ b/tests/test_async.cpp @@ -1,200 +1,187 @@ -#include "includes.h" -#include "spdlog/async.h" -#include "spdlog/sinks/basic_file_sink.h" -#include "test_sink.h" - -#define TEST_FILENAME "test_logs/async_test.log" - -TEST_CASE("basic async test ", "[async]") { - auto test_sink = std::make_shared(); - size_t overrun_counter = 0; - size_t queue_size = 128; - size_t messages = 256; - { - auto tp = std::make_shared(queue_size, 1); - auto logger = std::make_shared("as", test_sink, tp, - spdlog::async_overflow_policy::block); - for (size_t i = 0; i < messages; i++) { - logger->info("Hello message #{}", i); - } - logger->flush(); - overrun_counter = tp->overrun_counter(); - } - REQUIRE(test_sink->msg_counter() == messages); - REQUIRE(test_sink->flush_counter() == 1); - REQUIRE(overrun_counter == 0); -} - -TEST_CASE("discard policy ", "[async]") { - auto test_sink = std::make_shared(); - test_sink->set_delay(std::chrono::milliseconds(1)); - size_t queue_size = 4; - size_t messages = 1024; - - auto tp = std::make_shared(queue_size, 1); - auto logger = std::make_shared( - "as", test_sink, tp, spdlog::async_overflow_policy::overrun_oldest); - for (size_t i = 0; i < messages; i++) { - logger->info("Hello message"); - } - REQUIRE(test_sink->msg_counter() < messages); - REQUIRE(tp->overrun_counter() > 0); -} - -TEST_CASE("discard policy discard_new ", "[async]") { - auto test_sink = std::make_shared(); - test_sink->set_delay(std::chrono::milliseconds(1)); - size_t queue_size = 4; - size_t messages = 1024; - - auto tp = std::make_shared(queue_size, 1); - auto logger = std::make_shared( - "as", test_sink, tp, spdlog::async_overflow_policy::discard_new); - for (size_t i = 0; i < messages; i++) { - logger->info("Hello message"); - } - REQUIRE(test_sink->msg_counter() < messages); - REQUIRE(tp->discard_counter() > 0); -} - -TEST_CASE("discard policy using factory ", "[async]") { - size_t queue_size = 4; - size_t messages = 1024; - spdlog::init_thread_pool(queue_size, 1); - - auto logger = spdlog::create_async_nb("as2"); - auto test_sink = std::static_pointer_cast(logger->sinks()[0]); - test_sink->set_delay(std::chrono::milliseconds(3)); - - for (size_t i = 0; i < messages; i++) { - logger->info("Hello message"); - } - - REQUIRE(test_sink->msg_counter() < messages); - spdlog::drop_all(); -} - -TEST_CASE("flush", "[async]") { - auto test_sink = std::make_shared(); - size_t queue_size = 256; - size_t messages = 256; - { - auto tp = std::make_shared(queue_size, 1); - auto logger = std::make_shared("as", test_sink, tp, - spdlog::async_overflow_policy::block); - for (size_t i = 0; i < messages; i++) { - logger->info("Hello message #{}", i); - } - - logger->flush(); - } - // std::this_thread::sleep_for(std::chrono::milliseconds(250)); - REQUIRE(test_sink->msg_counter() == messages); - REQUIRE(test_sink->flush_counter() == 1); -} - -TEST_CASE("async periodic flush", "[async]") { - auto logger = spdlog::create_async("as"); - auto test_sink = std::static_pointer_cast(logger->sinks()[0]); - - spdlog::flush_every(std::chrono::seconds(1)); - std::this_thread::sleep_for(std::chrono::milliseconds(1700)); - REQUIRE(test_sink->flush_counter() == 1); - spdlog::flush_every(std::chrono::seconds(0)); - spdlog::drop_all(); -} - -TEST_CASE("tp->wait_empty() ", "[async]") { - auto test_sink = std::make_shared(); - test_sink->set_delay(std::chrono::milliseconds(5)); - size_t messages = 100; - - auto tp = std::make_shared(messages, 2); - auto logger = std::make_shared("as", test_sink, tp, - spdlog::async_overflow_policy::block); - for (size_t i = 0; i < messages; i++) { - logger->info("Hello message #{}", i); - } - logger->flush(); - tp.reset(); - - REQUIRE(test_sink->msg_counter() == messages); - REQUIRE(test_sink->flush_counter() == 1); -} - -TEST_CASE("multi threads", "[async]") { - auto test_sink = std::make_shared(); - size_t queue_size = 128; - size_t messages = 256; - size_t n_threads = 10; - { - auto tp = std::make_shared(queue_size, 1); - auto logger = std::make_shared("as", test_sink, tp, - spdlog::async_overflow_policy::block); - - std::vector threads; - for (size_t i = 0; i < n_threads; i++) { - threads.emplace_back([logger, messages] { - for (size_t j = 0; j < messages; j++) { - logger->info("Hello message #{}", j); - } - }); - logger->flush(); - } - - for (auto &t : threads) { - t.join(); - } - } - - REQUIRE(test_sink->msg_counter() == messages * n_threads); - REQUIRE(test_sink->flush_counter() == n_threads); -} - -TEST_CASE("to_file", "[async]") { - prepare_logdir(); - size_t messages = 1024; - size_t tp_threads = 1; - spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME); - { - auto file_sink = std::make_shared(filename, true); - auto tp = std::make_shared(messages, tp_threads); - auto logger = - std::make_shared("as", std::move(file_sink), std::move(tp)); - - for (size_t j = 0; j < messages; j++) { - logger->info("Hello message #{}", j); - } - } - - require_message_count(TEST_FILENAME, messages); - auto contents = file_contents(TEST_FILENAME); - using spdlog::details::os::default_eol; - REQUIRE(ends_with(contents, spdlog::fmt_lib::format("Hello message #1023{}", default_eol))); -} - -TEST_CASE("to_file multi-workers", "[async]") { - prepare_logdir(); - size_t messages = 1024 * 10; - size_t tp_threads = 10; - spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME); - { - auto file_sink = std::make_shared(filename, true); - auto tp = std::make_shared(messages, tp_threads); - auto logger = - std::make_shared("as", std::move(file_sink), std::move(tp)); - - for (size_t j = 0; j < messages; j++) { - logger->info("Hello message #{}", j); - } - } - require_message_count(TEST_FILENAME, messages); -} - -TEST_CASE("bad_tp", "[async]") { - auto test_sink = std::make_shared(); - std::shared_ptr const empty_tp; - auto logger = std::make_shared("as", test_sink, empty_tp); - logger->info("Please throw an exception"); - REQUIRE(test_sink->msg_counter() == 0); -} +// #include "includes.h" +// #include "spdlog/async.h" +// #include "spdlog/sinks/basic_file_sink.h" +// #include "test_sink.h" +// +// #define TEST_FILENAME "test_logs/async_test.log" +// +// TEST_CASE("basic async test ", "[async]") { +// auto test_sink = std::make_shared(); +// size_t overrun_counter = 0; +// size_t queue_size = 128; +// size_t messages = 256; +// { +// auto tp = std::make_shared(queue_size, 1); +// auto logger = std::make_shared("as", test_sink, tp, +// spdlog::async_overflow_policy::block); +// for (size_t i = 0; i < messages; i++) { +// logger->info("Hello message #{}", i); +// } +// logger->flush(); +// overrun_counter = tp->overrun_counter(); +// } +// REQUIRE(test_sink->msg_counter() == messages); +// REQUIRE(test_sink->flush_counter() == 1); +// REQUIRE(overrun_counter == 0); +// } +// +// TEST_CASE("discard policy ", "[async]") { +// auto test_sink = std::make_shared(); +// test_sink->set_delay(std::chrono::milliseconds(1)); +// size_t queue_size = 4; +// size_t messages = 1024; +// +// auto tp = std::make_shared(queue_size, 1); +// auto logger = std::make_shared( +// "as", test_sink, tp, spdlog::async_overflow_policy::overrun_oldest); +// for (size_t i = 0; i < messages; i++) { +// logger->info("Hello message"); +// } +// REQUIRE(test_sink->msg_counter() < messages); +// REQUIRE(tp->overrun_counter() > 0); +// } +// +// TEST_CASE("discard policy discard_new ", "[async]") { +// auto test_sink = std::make_shared(); +// test_sink->set_delay(std::chrono::milliseconds(1)); +// size_t queue_size = 4; +// size_t messages = 1024; +// +// auto tp = std::make_shared(queue_size, 1); +// auto logger = std::make_shared( +// "as", test_sink, tp, spdlog::async_overflow_policy::discard_new); +// for (size_t i = 0; i < messages; i++) { +// logger->info("Hello message"); +// } +// REQUIRE(test_sink->msg_counter() < messages); +// REQUIRE(tp->discard_counter() > 0); +// } +// +// TEST_CASE("discard policy using factory ", "[async]") { +// size_t queue_size = 4; +// size_t messages = 1024; +// auto logger = spdlog::create_async_nb("as2"); +// auto test_sink = std::static_pointer_cast(logger->sinks()[0]); +// test_sink->set_delay(std::chrono::milliseconds(3)); +// +// for (size_t i = 0; i < messages; i++) { +// logger->info("Hello message"); +// } +// +// REQUIRE(test_sink->msg_counter() < messages); +// } +// +// TEST_CASE("flush", "[async]") { +// auto test_sink = std::make_shared(); +// size_t queue_size = 256; +// size_t messages = 256; +// { +// auto tp = std::make_shared(queue_size, 1); +// auto logger = std::make_shared("as", test_sink, tp, +// spdlog::async_overflow_policy::block); +// for (size_t i = 0; i < messages; i++) { +// logger->info("Hello message #{}", i); +// } +// +// logger->flush(); +// } +// // std::this_thread::sleep_for(std::chrono::milliseconds(250)); +// REQUIRE(test_sink->msg_counter() == messages); +// REQUIRE(test_sink->flush_counter() == 1); +// } +// +// +// TEST_CASE("tp->wait_empty() ", "[async]") { +// auto test_sink = std::make_shared(); +// test_sink->set_delay(std::chrono::milliseconds(5)); +// size_t messages = 100; +// +// auto tp = std::make_shared(messages, 2); +// auto logger = std::make_shared("as", test_sink, tp, +// spdlog::async_overflow_policy::block); +// for (size_t i = 0; i < messages; i++) { +// logger->info("Hello message #{}", i); +// } +// logger->flush(); +// tp.reset(); +// +// REQUIRE(test_sink->msg_counter() == messages); +// REQUIRE(test_sink->flush_counter() == 1); +// } +// +// TEST_CASE("multi threads", "[async]") { +// auto test_sink = std::make_shared(); +// size_t queue_size = 128; +// size_t messages = 256; +// size_t n_threads = 10; +// { +// auto tp = std::make_shared(queue_size, 1); +// auto logger = std::make_shared("as", test_sink, tp, +// spdlog::async_overflow_policy::block); +// +// std::vector threads; +// for (size_t i = 0; i < n_threads; i++) { +// threads.emplace_back([logger, messages] { +// for (size_t j = 0; j < messages; j++) { +// logger->info("Hello message #{}", j); +// } +// }); +// logger->flush(); +// } +// +// for (auto &t : threads) { +// t.join(); +// } +// } +// +// REQUIRE(test_sink->msg_counter() == messages * n_threads); +// REQUIRE(test_sink->flush_counter() == n_threads); +// } +// +// TEST_CASE("to_file", "[async]") { +// prepare_logdir(); +// size_t messages = 1024; +// size_t tp_threads = 1; +// spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME); +// { +// auto file_sink = std::make_shared(filename, true); +// auto tp = std::make_shared(messages, tp_threads); +// auto logger = +// std::make_shared("as", std::move(file_sink), std::move(tp)); +// +// for (size_t j = 0; j < messages; j++) { +// logger->info("Hello message #{}", j); +// } +// } +// +// require_message_count(TEST_FILENAME, messages); +// auto contents = file_contents(TEST_FILENAME); +// using spdlog::details::os::default_eol; +// REQUIRE(ends_with(contents, spdlog::fmt_lib::format("Hello message #1023{}", default_eol))); +// } +// +// TEST_CASE("to_file multi-workers", "[async]") { +// prepare_logdir(); +// size_t messages = 1024 * 10; +// size_t tp_threads = 10; +// spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME); +// { +// auto file_sink = std::make_shared(filename, true); +// auto tp = std::make_shared(messages, tp_threads); +// auto logger = +// std::make_shared("as", std::move(file_sink), std::move(tp)); +// +// for (size_t j = 0; j < messages; j++) { +// logger->info("Hello message #{}", j); +// } +// } +// require_message_count(TEST_FILENAME, messages); +// } +// +// TEST_CASE("bad_tp", "[async]") { +// auto test_sink = std::make_shared(); +// std::shared_ptr const empty_tp; +// auto logger = std::make_shared("as", test_sink, empty_tp); +// logger->info("Please throw an exception"); +// REQUIRE(test_sink->msg_counter() == 0); +// } diff --git a/tests/test_backtrace.cpp b/tests/test_backtrace.cpp index 4d78c0c2..393ddafd 100644 --- a/tests/test_backtrace.cpp +++ b/tests/test_backtrace.cpp @@ -1,6 +1,7 @@ #include "includes.h" #include "test_sink.h" #include "spdlog/async.h" +#include "spdlog/async_logger.h" TEST_CASE("bactrace1", "[bactrace]") { using spdlog::sinks::test_sink_st; @@ -47,9 +48,8 @@ TEST_CASE("bactrace-async", "[bactrace]") { size_t backtrace_size = 5; - spdlog::init_thread_pool(120, 1); - auto logger = std::make_shared("test-bactrace-async", test_sink, - spdlog::thread_pool()); + auto tp = std::make_shared(8192, 1U); + auto logger = std::make_shared("test-bactrace-async", test_sink, tp); logger->set_pattern("%v"); logger->enable_backtrace(backtrace_size); diff --git a/tests/test_cfg.cpp b/tests/test_cfg.cpp deleted file mode 100644 index 684d870c..00000000 --- a/tests/test_cfg.cpp +++ /dev/null @@ -1,169 +0,0 @@ - -#include "includes.h" -#include "test_sink.h" - -#include -#include - -using spdlog::cfg::load_argv_levels; -using spdlog::cfg::load_env_levels; -using spdlog::sinks::test_sink_st; - -TEST_CASE("env", "[cfg]") { - spdlog::drop("l1"); - auto l1 = spdlog::create("l1"); -#ifdef CATCH_PLATFORM_WINDOWS - _putenv_s("SPDLOG_LEVEL", "l1=warn"); -#else - setenv("SPDLOG_LEVEL", "l1=warn", 1); -#endif - load_env_levels(); - REQUIRE(l1->level() == spdlog::level::warn); - spdlog::set_default_logger(spdlog::create("cfg-default")); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); -} - -TEST_CASE("argv1", "[cfg]") { - spdlog::drop("l1"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=warn"}; - load_argv_levels(2, argv); - auto l1 = spdlog::create("l1"); - REQUIRE(l1->level() == spdlog::level::warn); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); -} - -TEST_CASE("argv2", "[cfg]") { - spdlog::drop("l1"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=warn,trace"}; - load_argv_levels(2, argv); - auto l1 = spdlog::create("l1"); - REQUIRE(l1->level() == spdlog::level::warn); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace); -} - -TEST_CASE("argv3", "[cfg]") { - spdlog::set_level(spdlog::level::trace); - - spdlog::drop("l1"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=junk_name=warn"}; - load_argv_levels(2, argv); - auto l1 = spdlog::create("l1"); - REQUIRE(l1->level() == spdlog::level::trace); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace); -} - -TEST_CASE("argv4", "[cfg]") { - spdlog::set_level(spdlog::level::info); - spdlog::drop("l1"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=junk"}; - load_argv_levels(2, argv); - auto l1 = spdlog::create("l1"); - REQUIRE(l1->level() == spdlog::level::info); -} - -TEST_CASE("argv5", "[cfg]") { - spdlog::set_level(spdlog::level::info); - spdlog::drop("l1"); - const char *argv[] = {"ignore", "ignore", "SPDLOG_LEVEL=l1=warn,trace"}; - load_argv_levels(3, argv); - auto l1 = spdlog::create("l1"); - REQUIRE(l1->level() == spdlog::level::warn); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace); - spdlog::set_level(spdlog::level::info); -} - -TEST_CASE("argv6", "[cfg]") { - spdlog::set_level(spdlog::level::err); - const char *argv[] = {""}; - load_argv_levels(1, argv); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::err); - spdlog::set_level(spdlog::level::info); -} - -TEST_CASE("argv7", "[cfg]") { - spdlog::set_level(spdlog::level::err); - const char *argv[] = {""}; - load_argv_levels(0, argv); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::err); - spdlog::set_level(spdlog::level::info); -} - -TEST_CASE("level-not-set-test1", "[cfg]") { - spdlog::drop("l1"); - const char *argv[] = {"ignore", ""}; - load_argv_levels(2, argv); - auto l1 = spdlog::create("l1"); - l1->set_level(spdlog::level::trace); - REQUIRE(l1->level() == spdlog::level::trace); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); -} - -TEST_CASE("level-not-set-test2", "[cfg]") { - spdlog::drop("l1"); - spdlog::drop("l2"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace"}; - - auto l1 = spdlog::create("l1"); - l1->set_level(spdlog::level::warn); - auto l2 = spdlog::create("l2"); - l2->set_level(spdlog::level::warn); - - load_argv_levels(2, argv); - - REQUIRE(l1->level() == spdlog::level::trace); - REQUIRE(l2->level() == spdlog::level::warn); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); -} - -TEST_CASE("level-not-set-test3", "[cfg]") { - spdlog::drop("l1"); - spdlog::drop("l2"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace"}; - - load_argv_levels(2, argv); - - auto l1 = spdlog::create("l1"); - auto l2 = spdlog::create("l2"); - - REQUIRE(l1->level() == spdlog::level::trace); - REQUIRE(l2->level() == spdlog::level::info); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); -} - -TEST_CASE("level-not-set-test4", "[cfg]") { - spdlog::drop("l1"); - spdlog::drop("l2"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace,warn"}; - - load_argv_levels(2, argv); - - auto l1 = spdlog::create("l1"); - auto l2 = spdlog::create("l2"); - - REQUIRE(l1->level() == spdlog::level::trace); - REQUIRE(l2->level() == spdlog::level::warn); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::warn); -} - -TEST_CASE("level-not-set-test5", "[cfg]") { - spdlog::drop("l1"); - spdlog::drop("l2"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=junk,warn"}; - - load_argv_levels(2, argv); - - auto l1 = spdlog::create("l1"); - auto l2 = spdlog::create("l2"); - - REQUIRE(l1->level() == spdlog::level::warn); - REQUIRE(l2->level() == spdlog::level::warn); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::warn); -} - -TEST_CASE("restore-to-default", "[cfg]") { - spdlog::drop("l1"); - spdlog::drop("l2"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=info"}; - load_argv_levels(2, argv); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); -} diff --git a/tests/test_custom_callbacks.cpp b/tests/test_custom_callbacks.cpp index 4b048572..8d275de6 100644 --- a/tests/test_custom_callbacks.cpp +++ b/tests/test_custom_callbacks.cpp @@ -31,5 +31,4 @@ TEST_CASE("custom_callback_logger", "[custom_callback_logger]") { REQUIRE(lines[0] == ref_lines[0]); REQUIRE(lines[1] == ref_lines[1]); REQUIRE(lines[2] == ref_lines[2]); - spdlog::drop_all(); } diff --git a/tests/test_daily_logger.cpp b/tests/test_daily_logger.cpp index fe4783cb..75d43b22 100644 --- a/tests/test_daily_logger.cpp +++ b/tests/test_daily_logger.cpp @@ -35,7 +35,8 @@ TEST_CASE("daily_logger with dateonly calculator", "[daily_logger]") { spdlog::fmt_lib::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("logger", basename, 0, 0); + auto sink = std::make_shared(basename, 0, 0); + auto logger = std::make_shared("logger", std::move(sink)); for (int i = 0; i < 10; ++i) { logger->info("Test message {}", i); } @@ -67,13 +68,12 @@ TEST_CASE("daily_logger with custom calculator", "[daily_logger]") { spdlog::fmt_lib::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("logger", basename, 0, 0); + auto sink = std::make_shared(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(); require_message_count(filename_buf_to_utf8string(w), 10); } diff --git a/tests/test_errors.cpp b/tests/test_errors.cpp index 1c24cabc..06a73ebb 100644 --- a/tests/test_errors.cpp +++ b/tests/test_errors.cpp @@ -3,6 +3,7 @@ * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE */ #include "includes.h" +#include "spdlog/async_logger.h" #include @@ -24,7 +25,8 @@ TEST_CASE("default_error_handler", "[errors]") { prepare_logdir(); spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); - auto logger = spdlog::create("test-error", filename, true); + auto sink = std::make_shared(filename, true); + auto logger = std::make_unique("test-error", std::move(sink)); logger->set_pattern("%v"); logger->info(SPDLOG_FMT_RUNTIME("Test message {} {}"), 1); logger->info("Test message {}", 2); @@ -37,29 +39,28 @@ TEST_CASE("default_error_handler", "[errors]") { TEST_CASE("custom_error_handler", "[errors]") { prepare_logdir(); spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); - auto logger = spdlog::create("logger", filename, true); - logger->flush_on(spdlog::level::info); - logger->set_error_handler([=](const std::string &) { throw custom_ex(); }); - logger->info("Good message #1"); + auto sink = std::make_shared(filename, true); + spdlog::logger 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"); - REQUIRE_THROWS_AS(logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx"), custom_ex); - logger->info("Good message #2"); + REQUIRE_THROWS_AS(logger.info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx"), custom_ex); + logger.info("Good message #2"); require_message_count(SIMPLE_LOG, 2); } #endif TEST_CASE("default_error_handler2", "[errors]") { - spdlog::drop_all(); - auto logger = spdlog::create("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()); + 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]") { - spdlog::drop_all(); - auto logger = spdlog::create("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()); + logger.set_error_handler([=](const std::string &) { throw custom_ex(); }); + REQUIRE_THROWS_AS(logger.flush(), custom_ex); } #if !defined(SPDLOG_USE_STD_FORMAT) @@ -69,9 +70,9 @@ TEST_CASE("async_error_handler", "[errors]") { spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_ASYNC_LOG); { - spdlog::init_thread_pool(128, 1); - auto logger = - spdlog::create_async("logger", filename, true); + auto sink = std::make_shared(filename, true); + auto tp = std::make_shared(128, 1); + auto logger = std::make_shared("logger", std::move(sink), std::move(tp)); logger->set_error_handler([=](const std::string &) { std::ofstream ofs("test_logs/custom_err.txt"); if (!ofs) { @@ -82,9 +83,7 @@ TEST_CASE("async_error_handler", "[errors]") { logger->info("Good message #1"); logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx"); logger->info("Good message #2"); - spdlog::drop("logger"); // force logger to drain the queue and shutdown } - spdlog::init_thread_pool(128, 1); require_message_count(SIMPLE_ASYNC_LOG, 2); REQUIRE(file_contents("test_logs/custom_err.txt") == err_msg); } @@ -96,17 +95,14 @@ TEST_CASE("async_error_handler2", "[errors]") { std::string err_msg("This is async handler error message"); { spdlog::details::os::create_dir(SPDLOG_FILENAME_T("test_logs")); - spdlog::init_thread_pool(128, 1); - auto logger = spdlog::create_async("failed_logger"); - logger->set_error_handler([=](const std::string &) { + auto tp = std::make_shared(128, 1); + spdlog::async_logger logger("failed_logger", std::make_shared(), tp); + logger.set_error_handler([=](const std::string &) { std::ofstream ofs("test_logs/custom_err2.txt"); if (!ofs) throw std::runtime_error("Failed open test_logs/custom_err2.txt"); ofs << err_msg; }); - logger->info("Hello failure"); - spdlog::drop("failed_logger"); // force logger to drain the queue and shutdown + logger.info("Hello failure"); } - - spdlog::init_thread_pool(128, 1); REQUIRE(file_contents("test_logs/custom_err2.txt") == err_msg); } diff --git a/tests/test_file_logging.cpp b/tests/test_file_logging.cpp index ac378b5c..6e81c9ae 100644 --- a/tests/test_file_logging.cpp +++ b/tests/test_file_logging.cpp @@ -11,7 +11,8 @@ TEST_CASE("simple_file_logger", "[simple_logger]") { prepare_logdir(); spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); - auto logger = spdlog::create("logger", filename); + auto sink = std::make_shared(filename); + auto logger = std::make_unique("logger", std::move(sink)); logger->set_pattern("%v"); logger->info("Test message {}", 1); @@ -28,7 +29,8 @@ TEST_CASE("flush_on", "[flush_on]") { prepare_logdir(); spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); - auto logger = spdlog::create("logger", filename); + auto sink = std::make_shared(filename); + auto logger = std::make_shared("logger", sink); logger->set_pattern("%v"); logger->set_level(spdlog::level::trace); logger->flush_on(spdlog::level::info); @@ -49,13 +51,13 @@ TEST_CASE("rotating_file_logger1", "[rotating_logger]") { prepare_logdir(); size_t max_size = 1024 * 10; spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG); - auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 0); + auto sink = std::make_shared(basename, max_size, 0); + spdlog::logger logger("logger", std::move(sink)); for (int i = 0; i < 10; ++i) { - logger->info("Test message {}", i); + logger.info("Test message {}", i); } - - logger->flush(); + logger.flush(); require_message_count(ROTATING_LOG, 10); } @@ -66,16 +68,15 @@ TEST_CASE("rotating_file_logger2", "[rotating_logger]") { { // make an initial logger to create the first output file - auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 2, true); + auto sink = + std::make_shared(basename, max_size, 2, true); + auto logger = std::make_shared("logger", sink); for (int i = 0; i < 10; ++i) { logger->info("Test message {}", i); } - // drop causes the logger destructor to be called, which is required so the - // next logger can rename the first output file. - spdlog::drop(logger->name()); } - - auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 2, true); + auto sink = std::make_shared(basename, max_size, 2, true); + auto logger = std::make_shared("logger", sink); for (int i = 0; i < 10; ++i) { logger->info("Test message {}", i); } @@ -98,6 +99,7 @@ TEST_CASE("rotating_file_logger3", "[rotating_logger]") { prepare_logdir(); size_t max_size = 0; spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG); - REQUIRE_THROWS_AS(spdlog::rotating_logger_mt("logger", basename, max_size, 0), - spdlog::spdlog_ex); + REQUIRE_THROWS_AS( + std::make_shared(basename, max_size, 2, true), + spdlog::spdlog_ex); } diff --git a/tests/test_macros.cpp b/tests/test_macros.cpp index 132706f1..bb414631 100644 --- a/tests/test_macros.cpp +++ b/tests/test_macros.cpp @@ -15,7 +15,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("logger", filename); + auto sink = std::make_shared(filename); + auto logger = std::make_shared("logger", sink); logger->set_pattern("%v"); logger->set_level(spdlog::level::trace); @@ -46,7 +47,8 @@ TEST_CASE("disable param evaluation", "[macros]") { } TEST_CASE("pass logger pointer", "[macros]") { - auto logger = spdlog::create("refmacro"); + auto null_sink = std::make_shared(); + auto logger = std::make_unique("refmacro", std::move(null_sink)); auto &ref = *logger; SPDLOG_LOGGER_TRACE(&ref, "Test message 1"); SPDLOG_LOGGER_DEBUG(&ref, "Test message 2"); diff --git a/tests/test_misc.cpp b/tests/test_misc.cpp index 5ae3c045..390e5ab1 100644 --- a/tests/test_misc.cpp +++ b/tests/test_misc.cpp @@ -1,5 +1,6 @@ #include "includes.h" #include "test_sink.h" +#include "spdlog/async_logger.h" template std::string log_info(const T &what, spdlog::level::level_enum logger_level = spdlog::level::info) { @@ -71,18 +72,6 @@ TEST_CASE("to_level_enum", "[convert_to_level_enum]") { REQUIRE(spdlog::level::from_str("null") == spdlog::level::off); } -TEST_CASE("periodic flush", "[periodic_flush]") { - using spdlog::sinks::test_sink_mt; - auto logger = spdlog::create("periodic_flush"); - auto test_sink = std::static_pointer_cast(logger->sinks()[0]); - - spdlog::flush_every(std::chrono::seconds(1)); - std::this_thread::sleep_for(std::chrono::milliseconds(1250)); - REQUIRE(test_sink->flush_counter() == 1); - spdlog::flush_every(std::chrono::seconds(0)); - spdlog::drop_all(); -} - TEST_CASE("clone-logger", "[clone]") { using spdlog::sinks::test_sink_mt; auto test_sink = std::make_shared(); @@ -101,14 +90,13 @@ TEST_CASE("clone-logger", "[clone]") { REQUIRE(test_sink->lines()[0] == "Some message 1"); REQUIRE(test_sink->lines()[1] == "Some message 2"); - spdlog::drop_all(); } TEST_CASE("clone async", "[clone]") { using spdlog::sinks::test_sink_mt; - spdlog::init_thread_pool(4, 1); + auto tp = std::make_shared(4, 1); auto test_sink = std::make_shared(); - auto logger = std::make_shared("orig", test_sink, spdlog::thread_pool()); + auto logger = std::make_shared("orig", test_sink, tp); logger->set_pattern("%v"); auto cloned = logger->clone("clone"); @@ -125,8 +113,6 @@ TEST_CASE("clone async", "[clone]") { REQUIRE(test_sink->lines().size() == 2); REQUIRE(test_sink->lines()[0] == "Some message 1"); REQUIRE(test_sink->lines()[1] == "Some message 2"); - - spdlog::drop_all(); } TEST_CASE("default logger API", "[default logger]") { @@ -164,7 +150,6 @@ TEST_CASE("default logger API", "[default logger]") { spdlog::set_level(spdlog::level::info); spdlog::debug("should not be logged"); REQUIRE(oss.str().empty()); - spdlog::drop_all(); spdlog::set_pattern("%v"); } diff --git a/tests/test_mpmc_q.cpp b/tests/test_mpmc_q.cpp index bc7a37d9..c4f0f05b 100644 --- a/tests/test_mpmc_q.cpp +++ b/tests/test_mpmc_q.cpp @@ -1,4 +1,5 @@ #include "includes.h" +#include using std::chrono::milliseconds; using test_clock = std::chrono::high_resolution_clock; @@ -6,6 +7,7 @@ using test_clock = std::chrono::high_resolution_clock; static milliseconds millis_from(const test_clock::time_point &tp0) { return std::chrono::duration_cast(test_clock::now() - tp0); } + TEST_CASE("dequeue-empty-nowait", "[mpmc_blocking_q]") { size_t q_size = 100; milliseconds tolerance_wait(20); diff --git a/tests/test_registry.cpp b/tests/test_registry.cpp deleted file mode 100644 index 69ec8f53..00000000 --- a/tests/test_registry.cpp +++ /dev/null @@ -1,112 +0,0 @@ -#include "includes.h" - -static const char *const tested_logger_name = "null_logger"; -static const char *const tested_logger_name2 = "null_logger2"; - -#ifndef SPDLOG_NO_EXCEPTIONS -TEST_CASE("register_drop", "[registry]") { - spdlog::drop_all(); - spdlog::create(tested_logger_name); - REQUIRE(spdlog::get(tested_logger_name) != nullptr); - // Throw if registering existing name - REQUIRE_THROWS_AS(spdlog::create(tested_logger_name), - spdlog::spdlog_ex); -} - -TEST_CASE("explicit register", "[registry]") { - spdlog::drop_all(); - auto logger = std::make_shared(tested_logger_name, - std::make_shared()); - spdlog::register_logger(logger); - REQUIRE(spdlog::get(tested_logger_name) != nullptr); - // Throw if registering existing name - REQUIRE_THROWS_AS(spdlog::create(tested_logger_name), - spdlog::spdlog_ex); -} -#endif - -TEST_CASE("apply_all", "[registry]") { - spdlog::drop_all(); - auto logger = std::make_shared(tested_logger_name, - std::make_shared()); - spdlog::register_logger(logger); - auto logger2 = std::make_shared( - tested_logger_name2, std::make_shared()); - spdlog::register_logger(logger2); - - int counter = 0; - spdlog::apply_all([&counter](std::shared_ptr) { counter++; }); - REQUIRE(counter == 2); - - counter = 0; - spdlog::drop(tested_logger_name2); - spdlog::apply_all([&counter](std::shared_ptr l) { - REQUIRE(l->name() == tested_logger_name); - counter++; - }); - REQUIRE(counter == 1); -} - -TEST_CASE("drop", "[registry]") { - spdlog::drop_all(); - spdlog::create(tested_logger_name); - spdlog::drop(tested_logger_name); - REQUIRE_FALSE(spdlog::get(tested_logger_name)); -} - -TEST_CASE("drop-default", "[registry]") { - spdlog::set_default_logger(spdlog::null_logger_st(tested_logger_name)); - spdlog::drop(tested_logger_name); - REQUIRE_FALSE(spdlog::default_logger()); - REQUIRE_FALSE(spdlog::get(tested_logger_name)); -} - -TEST_CASE("drop_all", "[registry]") { - spdlog::drop_all(); - spdlog::create(tested_logger_name); - spdlog::create(tested_logger_name2); - spdlog::drop_all(); - REQUIRE_FALSE(spdlog::get(tested_logger_name)); - REQUIRE_FALSE(spdlog::get(tested_logger_name2)); - REQUIRE_FALSE(spdlog::default_logger()); -} - -TEST_CASE("drop non existing", "[registry]") { - spdlog::drop_all(); - spdlog::create(tested_logger_name); - spdlog::drop("some_name"); - REQUIRE_FALSE(spdlog::get("some_name")); - REQUIRE(spdlog::get(tested_logger_name)); - spdlog::drop_all(); -} - -TEST_CASE("default logger", "[registry]") { - spdlog::drop_all(); - spdlog::set_default_logger(spdlog::null_logger_st(tested_logger_name)); - REQUIRE(spdlog::get(tested_logger_name) == spdlog::default_logger()); - spdlog::drop_all(); -} - -TEST_CASE("set_default_logger(nullptr)", "[registry]") { - spdlog::set_default_logger(nullptr); - REQUIRE_FALSE(spdlog::default_logger()); -} - -TEST_CASE("disable automatic registration", "[registry]") { - // set some global parameters - spdlog::level::level_enum log_level = spdlog::level::level_enum::warn; - spdlog::set_level(log_level); - // but disable automatic registration - spdlog::set_automatic_registration(false); - auto logger1 = spdlog::create( - tested_logger_name, SPDLOG_FILENAME_T("filename"), 11, 59); - auto logger2 = spdlog::create_async(tested_logger_name2); - // loggers should not be part of the registry - REQUIRE_FALSE(spdlog::get(tested_logger_name)); - REQUIRE_FALSE(spdlog::get(tested_logger_name2)); - // but make sure they are still initialized according to global defaults - REQUIRE(logger1->level() == log_level); - REQUIRE(logger2->level() == log_level); - spdlog::set_level(spdlog::level::info); - spdlog::set_automatic_registration(true); -} diff --git a/tests/test_stdout_api.cpp b/tests/test_stdout_api.cpp index 67659b84..54b99370 100644 --- a/tests/test_stdout_api.cpp +++ b/tests/test_stdout_api.cpp @@ -5,71 +5,72 @@ #include "includes.h" #include "spdlog/sinks/stdout_sinks.h" #include "spdlog/sinks/stdout_color_sinks.h" + TEST_CASE("stdout_st", "[stdout]") { - auto l = spdlog::stdout_logger_st("test"); + auto sink = std::make_shared(); + auto l = std::make_unique("test", std::move(sink)); l->set_pattern("%+"); l->set_level(spdlog::level::trace); l->trace("Test stdout_st"); - spdlog::drop_all(); } TEST_CASE("stdout_mt", "[stdout]") { - auto l = spdlog::stdout_logger_mt("test"); + auto sink = std::make_shared(); + auto l = std::make_unique("test", std::move(sink)); l->set_pattern("%+"); l->set_level(spdlog::level::debug); l->debug("Test stdout_mt"); - spdlog::drop_all(); } TEST_CASE("stderr_st", "[stderr]") { - auto l = spdlog::stderr_logger_st("test"); + auto sink = std::make_shared(); + auto l = std::make_unique("test", std::move(sink)); l->set_pattern("%+"); l->info("Test stderr_st"); - spdlog::drop_all(); } TEST_CASE("stderr_mt", "[stderr]") { - auto l = spdlog::stderr_logger_mt("test"); + auto sink = std::make_shared(); + auto l = std::make_unique("test", std::move(sink)); l->set_pattern("%+"); l->info("Test stderr_mt"); l->warn("Test stderr_mt"); l->error("Test stderr_mt"); l->critical("Test stderr_mt"); - spdlog::drop_all(); } // color loggers TEST_CASE("stdout_color_st", "[stdout]") { - auto l = spdlog::stdout_color_st("test"); + auto sink = std::make_shared(); + auto l = std::make_unique("test", std::move(sink)); l->set_pattern("%+"); l->info("Test stdout_color_st"); - spdlog::drop_all(); } TEST_CASE("stdout_color_mt", "[stdout]") { - auto l = spdlog::stdout_color_mt("test"); + auto sink = std::make_shared(); + auto l = std::make_unique("test", std::move(sink)); l->set_pattern("%+"); l->set_level(spdlog::level::trace); l->trace("Test stdout_color_mt"); - spdlog::drop_all(); } TEST_CASE("stderr_color_st", "[stderr]") { - auto l = spdlog::stderr_color_st("test"); + auto sink = std::make_shared(); + auto l = std::make_unique("test", std::move(sink)); l->set_pattern("%+"); l->set_level(spdlog::level::debug); l->debug("Test stderr_color_st"); - spdlog::drop_all(); } TEST_CASE("stderr_color_mt", "[stderr]") { - auto l = spdlog::stderr_color_mt("test"); + auto sink = std::make_shared(); + auto l = std::make_unique("test", std::move(sink)); l->set_pattern("%+"); l->info("Test stderr_color_mt"); l->warn("Test stderr_color_mt"); l->error("Test stderr_color_mt"); l->critical("Test stderr_color_mt"); - spdlog::drop_all(); } #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT diff --git a/tests/test_time_point.cpp b/tests/test_time_point.cpp index b7b1b232..813d771a 100644 --- a/tests/test_time_point.cpp +++ b/tests/test_time_point.cpp @@ -31,5 +31,4 @@ TEST_CASE("time_point1", "[time_point log_msg]") { REQUIRE(lines[4] == lines[5]); REQUIRE(lines[6] == lines[7]); REQUIRE(lines[8] != lines[9]); - spdlog::drop_all(); } diff --git a/tests/utils.cpp b/tests/utils.cpp index 1fa26175..ad4577a1 100644 --- a/tests/utils.cpp +++ b/tests/utils.cpp @@ -8,7 +8,6 @@ #endif void prepare_logdir() { - spdlog::drop_all(); #ifdef _WIN32 system("rmdir /S /Q test_logs"); #else