danny
/
spdlog
mirror of https://github.com/gabime/spdlog.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Removed registry,factory and related functions

Browse Source
pull/3266/head
gabime 9 months ago
parent 8af91bcda0
commit 659eda9afd
42 changed files with 423 additions and 1709 deletions
Show Stats Download Patch File Download Diff File

2
CMakeLists.txt
Unescape Escape View File

@ -152,7 +152,7 @@ message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
# --------------------------------------------------------------------------------------- # ---------------------------------------------------------------------------------------
# Static/Shared library # 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) 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) list(APPEND SPDLOG_SRCS src/bundled_fmtlib_format.cpp)

11
changes
Unescape Escape View File

@ -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() ?

2
example/example.cpp
Unescape Escape View File

@ -33,7 +33,7 @@ void replace_default_logger_example();
int main(int, char *[]) { int main(int, char *[]) {
// Log levels can be loaded from argv/env using "SPDLOG_LEVEL" // 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::info("Welcome to spdlog version {}.{}.{} !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR,
SPDLOG_VER_PATCH); SPDLOG_VER_PATCH);

185
include/spdlog/async.h
Unescape Escape View File

@ -1,100 +1,87 @@
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. // // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT) // // Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
// //
// Async logging using global thread pool // #pragma once
// 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. // // Async logging using global thread pool
// If a logger deleted while having pending messages in the queue, it's actual // // All loggers created here share same global thread pool.
// destruction will defer // // Each log message is pushed to a queue along with a shared pointer to the
// until all its messages are processed by the thread pool. // // logger.
// This is because each message in the queue holds a shared_ptr to the // // If a logger deleted while having pending messages in the queue, it's actual
// originating logger. // // destruction will defer
// // until all its messages are processed by the thread pool.
#include <spdlog/async_logger.h> // // This is because each message in the queue holds a shared_ptr to the
#include <spdlog/details/registry.h> // // originating logger.
#include <spdlog/details/thread_pool.h> //
// #include <spdlog/async_logger.h>
#include <functional> // #include <spdlog/details/thread_pool.h>
#include <memory> //
#include <mutex> // #include <functional>
// #include <memory>
namespace spdlog { // #include <mutex>
//
namespace details { // namespace spdlog {
static const size_t default_async_q_size = 8192; //
} // 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. // // async logger factory - creates async loggers backed with thread pool.
template <async_overflow_policy OverflowPolicy = async_overflow_policy::block> // // if a global thread pool doesn't already exist, create it with default queue
struct async_factory_impl { // // size of 8192 items and single thread.
template <typename Sink, typename... SinkArgs> // template <async_overflow_policy OverflowPolicy = async_overflow_policy::block>
static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args) { // struct async_factory_impl {
auto &registry_inst = details::registry::instance(); // template <typename Sink, typename... SinkArgs>
// static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args) {
// create global thread pool if not already exists.. // auto tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U);
// auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto &mutex = registry_inst.tp_mutex(); // auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink),
std::lock_guard<std::recursive_mutex> tp_lock(mutex); // std::move(tp), OverflowPolicy);
auto tp = registry_inst.get_tp(); // return new_logger;
if (tp == nullptr) { // }
tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U); // };
registry_inst.set_tp(tp); //
} // using async_factory = async_factory_impl<async_overflow_policy::block>;
// using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>;
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...); //
auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), // template <typename Sink, typename... SinkArgs>
std::move(tp), OverflowPolicy); // inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name,
registry_inst.initialize_logger(new_logger); // SinkArgs &&...sink_args) {
return new_logger; // return async_factory::create<Sink>(std::move(logger_name),
} // std::forward<SinkArgs>(sink_args)...);
}; // }
//
using async_factory = async_factory_impl<async_overflow_policy::block>; // template <typename Sink, typename... SinkArgs>
using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>; // inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name,
// SinkArgs &&...sink_args) {
template <typename Sink, typename... SinkArgs> // return async_factory_nonblock::create<Sink>(std::move(logger_name),
inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, // std::forward<SinkArgs>(sink_args)...);
SinkArgs &&...sink_args) { // }
return async_factory::create<Sink>(std::move(logger_name), //
std::forward<SinkArgs>(sink_args)...); // // // set global thread pool.
} // // inline void init_thread_pool(size_t q_size,
// // size_t thread_count,
template <typename Sink, typename... SinkArgs> // // std::function<void()> on_thread_start,
inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, // // std::function<void()> on_thread_stop) {
SinkArgs &&...sink_args) { // // auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start,
return async_factory_nonblock::create<Sink>(std::move(logger_name), // // on_thread_stop);
std::forward<SinkArgs>(sink_args)...); // // details::registry::instance().set_tp(std::move(tp));
} // // }
// //
// set global thread pool. // // inline void init_thread_pool(size_t q_size,
inline void init_thread_pool(size_t q_size, // // size_t thread_count,
size_t thread_count, // // std::function<void()> on_thread_start) {
std::function<void()> on_thread_start, // // init_thread_pool(q_size, thread_count, on_thread_start, [] {});
std::function<void()> on_thread_stop) { // // }
auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start, // //
on_thread_stop); // // inline void init_thread_pool(size_t q_size, size_t thread_count) {
details::registry::instance().set_tp(std::move(tp)); // // init_thread_pool(
} // // q_size, thread_count, [] {}, [] {});
// // }
inline void init_thread_pool(size_t q_size, //
size_t thread_count, // // get the global thread pool.
std::function<void()> on_thread_start) { // // inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() {
init_thread_pool(q_size, thread_count, on_thread_start, [] {}); // // return details::registry::instance().get_tp();
} // // }
// } // namespace spdlog
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<spdlog::details::thread_pool> thread_pool() {
return details::registry::instance().get_tp();
}
} // namespace spdlog

40
include/spdlog/cfg/argv.h
Unescape Escape View File

@ -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 <spdlog/cfg/helpers.h>
#include <spdlog/details/registry.h>
//
// 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<const char **>(argv));
}
} // namespace cfg
} // namespace spdlog

36
include/spdlog/cfg/env.h
Unescape Escape View File

@ -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 <spdlog/cfg/helpers.h>
#include <spdlog/details/os.h>
#include <spdlog/details/registry.h>
//
// 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

107
include/spdlog/cfg/helpers-inl.h
Unescape Escape View File

@ -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 <spdlog/cfg/helpers.h>
#endif
#include <spdlog/details/os.h>
#include <spdlog/details/registry.h>
#include <spdlog/spdlog.h>
#include <algorithm>
#include <sstream>
#include <string>
#include <utility>
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<char>((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<std::string, std::string> 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<std::string, std::string> extract_key_vals_(const std::string &str) {
std::string token;
std::istringstream token_stream(str);
std::unordered_map<std::string, std::string> 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<std::string, level::level_enum> 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

29
include/spdlog/cfg/helpers.h
Unescape Escape View File

@ -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 <spdlog/common.h>
#include <unordered_map>
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

278
include/spdlog/details/registry-inl.h
Unescape Escape View File

@ -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 <spdlog/details/registry.h>
#endif
#include <spdlog/common.h>
#include <spdlog/details/periodic_worker.h>
#include <spdlog/logger.h>
#include <spdlog/pattern_formatter.h>
#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
// support for the default stdout color logger
#ifdef _WIN32
#include <spdlog/sinks/wincolor_sink.h>
#else
#include <spdlog/sinks/ansicolor_sink.h>
#endif
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
#include <chrono>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <mutex>
namespace spdlog {
namespace details {
SPDLOG_INLINE static std::shared_ptr<registry> s_instance = std::make_shared<registry>();
SPDLOG_INLINE registry &registry::instance() {
return *s_instance;
}
SPDLOG_INLINE std::shared_ptr<registry> registry::shared_instance() {
return s_instance;
}
SPDLOG_INLINE void registry::set_instance(std::shared_ptr<registry> 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<sinks::wincolor_stdout_sink_mt>();
#else
auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
#endif
const char *default_logger_name = "";
default_logger_ = std::make_shared<spdlog::logger>(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<logger> new_logger) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
register_logger_(std::move(new_logger));
}
SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger) {
std::lock_guard<std::mutex> 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<logger> registry::get(const std::string &logger_name) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
auto found = loggers_.find(logger_name);
return found == loggers_.end() ? nullptr : found->second;
}
SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger() {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
return default_logger_;
}
// Return raw ptr to the default logger.
// To be used directly by the spdlog default api (e.g. spdlog::info)
// This make the default API faster, but cannot be used concurrently with set_default_logger().
// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
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<logger> new_default_logger) {
std::lock_guard<std::mutex> 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<thread_pool> tp) {
std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
tp_ = std::move(tp);
}
SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp() {
std::lock_guard<std::recursive_mutex> 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> formatter) {
std::lock_guard<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<void(const std::shared_ptr<logger>)> &fun) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) {
fun(l.second);
}
}
SPDLOG_INLINE void registry::flush_all() {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) {
l.second->flush();
}
}
SPDLOG_INLINE void registry::drop(const std::string &logger_name) {
std::lock_guard<std::mutex> 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<std::mutex> 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<std::mutex> lock(flusher_mutex_);
periodic_flusher_.reset();
}
drop_all();
{
std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
tp_.reset();
}
}
SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex() { return tp_mutex_; }
SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) {
std::lock_guard<std::mutex> 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<std::mutex> 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<logger> new_logger) {
std::lock_guard<std::mutex> 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 &registry::console_mutex() {
return console_mutex_;
}
SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) {
if (loggers_.find(logger_name) != loggers_.end()) {
throw_spdlog_ex("logger with name '" + logger_name + "' already exists");
}
}
SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger) {
auto logger_name = new_logger->name();
throw_if_exists_(logger_name);
loggers_[logger_name] = std::move(new_logger);
}
} // namespace details
} // namespace spdlog

134
include/spdlog/details/registry.h
Unescape Escape View File

@ -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 <spdlog/common.h>
#include <spdlog/details/periodic_worker.h>
#include <chrono>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
namespace spdlog {
class logger;
namespace details {
class thread_pool;
class SPDLOG_API registry {
public:
registry();
~registry();
using log_levels = std::unordered_map<std::string, level::level_enum>;
registry(const registry &) = delete;
registry &operator=(const registry &) = delete;
void register_logger(std::shared_ptr<logger> new_logger);
void initialize_logger(std::shared_ptr<logger> new_logger);
std::shared_ptr<logger> get(const std::string &logger_name);
std::shared_ptr<logger> 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<logger> new_default_logger);
void set_tp(std::shared_ptr<thread_pool> tp);
std::shared_ptr<thread_pool> get_tp();
// Set global formatter. Each sink in each logger will get a clone of this object
void set_formatter(std::unique_ptr<formatter> 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 <typename Rep, typename Period>
void flush_every(std::chrono::duration<Rep, Period> interval) {
std::lock_guard<std::mutex> lock(flusher_mutex_);
auto clbk = [this]() { this->flush_all(); };
periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
}
std::unique_ptr<periodic_worker> &get_flusher() {
std::lock_guard<std::mutex> lock(flusher_mutex_);
return periodic_flusher_;
}
void set_error_handler(err_handler handler);
void apply_all(const std::function<void(const std::shared_ptr<logger>)> &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<registry> instance);
static registry &instance();
static std::shared_ptr<registry> shared_instance();
void apply_logger_env_levels(std::shared_ptr<logger> new_logger);
std::mutex& console_mutex();
private:
void throw_if_exists_(const std::string &logger_name);
void register_logger_(std::shared_ptr<logger> new_logger);
bool set_level_from_cfg_(logger *logger);
std::mutex logger_map_mutex_, flusher_mutex_;
std::recursive_mutex tp_mutex_;
std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
log_levels log_levels_;
std::unique_ptr<formatter> formatter_;
spdlog::level::level_enum global_log_level_ = level::info;
level::level_enum flush_level_ = level::off;
err_handler err_handler_;
std::shared_ptr<thread_pool> tp_;
std::unique_ptr<periodic_worker> periodic_flusher_;
std::shared_ptr<logger> 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

22
include/spdlog/details/synchronous_factory.h
Unescape Escape View File

@ -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 <typename Sink, typename... SinkArgs>
static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args) {
auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));
details::registry::instance().initialize_logger(new_logger);
return new_logger;
}
};
} // namespace spdlog

2
include/spdlog/details/thread_pool.h
Unescape Escape View File

@ -7,7 +7,6 @@
#include <spdlog/details/mpmc_blocking_q.h> #include <spdlog/details/mpmc_blocking_q.h>
#include <spdlog/details/os.h> #include <spdlog/details/os.h>
#include <chrono>
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <thread> #include <thread>
@ -16,6 +15,7 @@
namespace spdlog { namespace spdlog {
class async_logger; class async_logger;
enum class async_overflow_policy;
namespace details { namespace details {
using async_logger_ptr = std::shared_ptr<spdlog::async_logger>; using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;

22
include/spdlog/sinks/basic_file_sink.h
Unescape Escape View File

@ -5,7 +5,6 @@
#include <spdlog/details/file_helper.h> #include <spdlog/details/file_helper.h>
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/details/synchronous_factory.h>
#include <spdlog/sinks/base_sink.h> #include <spdlog/sinks/base_sink.h>
#include <mutex> #include <mutex>
@ -37,27 +36,6 @@ using basic_file_sink_st = basic_file_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
//
// factory functions
//
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> 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<sinks::basic_file_sink_mt>(logger_name, filename, truncate,
event_handlers);
}
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> 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<sinks::basic_file_sink_st>(logger_name, filename, truncate,
event_handlers);
}
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY

18
include/spdlog/sinks/callback_sink.h
Unescape Escape View File

@ -4,7 +4,6 @@
#pragma once #pragma once
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/details/synchronous_factory.h>
#include <spdlog/sinks/base_sink.h> #include <spdlog/sinks/base_sink.h>
#include <mutex> #include <mutex>
@ -35,22 +34,5 @@ private:
using callback_sink_mt = callback_sink<std::mutex>; using callback_sink_mt = callback_sink<std::mutex>;
using callback_sink_st = callback_sink<details::null_mutex>; using callback_sink_st = callback_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
//
// factory functions
//
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> callback_logger_mt(const std::string &logger_name,
const custom_log_callback &callback) {
return Factory::template create<sinks::callback_sink_mt>(logger_name, callback);
}
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> callback_logger_st(const std::string &logger_name,
const custom_log_callback &callback) {
return Factory::template create<sinks::callback_sink_st>(logger_name, callback);
}
} // namespace spdlog } // namespace spdlog

55
include/spdlog/sinks/daily_file_sink.h
Unescape Escape View File

@ -8,7 +8,6 @@
#include <spdlog/details/file_helper.h> #include <spdlog/details/file_helper.h>
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/details/os.h> #include <spdlog/details/os.h>
#include <spdlog/details/synchronous_factory.h>
#include <spdlog/fmt/chrono.h> #include <spdlog/fmt/chrono.h>
#include <spdlog/fmt/fmt.h> #include <spdlog/fmt/fmt.h>
#include <spdlog/sinks/base_sink.h> #include <spdlog/sinks/base_sink.h>
@ -196,59 +195,5 @@ using daily_file_sink_st = daily_file_sink<details::null_mutex>;
using daily_file_format_sink_mt = daily_file_sink<std::mutex, daily_filename_format_calculator>; using daily_file_format_sink_mt = daily_file_sink<std::mutex, daily_filename_format_calculator>;
using daily_file_format_sink_st = using daily_file_format_sink_st =
daily_file_sink<details::null_mutex, daily_filename_format_calculator>; daily_file_sink<details::null_mutex, daily_filename_format_calculator>;
} // namespace sinks } // namespace sinks
//
// factory functions
//
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> 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<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute,
truncate, max_files, event_handlers);
}
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> 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<sinks::daily_file_format_sink_mt>(
logger_name, filename, hour, minute, truncate, max_files, event_handlers);
}
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> 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<sinks::daily_file_sink_st>(logger_name, filename, hour, minute,
truncate, max_files, event_handlers);
}
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> 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<sinks::daily_file_format_sink_st>(
logger_name, filename, hour, minute, truncate, max_files, event_handlers);
}
} // namespace spdlog } // namespace spdlog

17
include/spdlog/sinks/null_sink.h
Unescape Escape View File

@ -4,7 +4,6 @@
#pragma once #pragma once
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/details/synchronous_factory.h>
#include <spdlog/sinks/base_sink.h> #include <spdlog/sinks/base_sink.h>
#include <mutex> #include <mutex>
@ -21,21 +20,5 @@ protected:
using null_sink_mt = null_sink<details::null_mutex>; using null_sink_mt = null_sink<details::null_mutex>;
using null_sink_st = null_sink<details::null_mutex>; using null_sink_st = null_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> null_logger_mt(const std::string &logger_name) {
auto null_logger = Factory::template create<sinks::null_sink_mt>(logger_name);
null_logger->set_level(level::off);
return null_logger;
}
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> null_logger_st(const std::string &logger_name) {
auto null_logger = Factory::template create<sinks::null_sink_st>(logger_name);
null_logger->set_level(level::off);
return null_logger;
}
} // namespace spdlog } // namespace spdlog

27
include/spdlog/sinks/rotating_file_sink.h
Unescape Escape View File

@ -5,7 +5,6 @@
#include <spdlog/details/file_helper.h> #include <spdlog/details/file_helper.h>
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/details/synchronous_factory.h>
#include <spdlog/sinks/base_sink.h> #include <spdlog/sinks/base_sink.h>
#include <chrono> #include <chrono>
@ -56,32 +55,6 @@ using rotating_file_sink_mt = rotating_file_sink<std::mutex>;
using rotating_file_sink_st = rotating_file_sink<details::null_mutex>; using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
//
// factory functions
//
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> 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<sinks::rotating_file_sink_mt>(
logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
}
template <typename Factory = spdlog::synchronous_factory>
inline std::shared_ptr<logger> 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<sinks::rotating_file_sink_st>(
logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
}
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY

18
include/spdlog/sinks/stdout_color_sinks.h
Unescape Escape View File

@ -9,7 +9,6 @@
#include <spdlog/sinks/ansicolor_sink.h> #include <spdlog/sinks/ansicolor_sink.h>
#endif #endif
#include <spdlog/details/synchronous_factory.h>
namespace spdlog { namespace spdlog {
namespace sinks { namespace sinks {
@ -25,23 +24,6 @@ using stderr_color_sink_mt = ansicolor_stderr_sink_mt;
using stderr_color_sink_st = ansicolor_stderr_sink_st; using stderr_color_sink_st = ansicolor_stderr_sink_st;
#endif #endif
} // namespace sinks } // namespace sinks
template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name,
color_mode mode = color_mode::automatic);
template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stdout_color_st(const std::string &logger_name,
color_mode mode = color_mode::automatic);
template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name,
color_mode mode = color_mode::automatic);
template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stderr_color_st(const std::string &logger_name,
color_mode mode = color_mode::automatic);
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY

21
include/spdlog/sinks/stdout_sinks-inl.h
Unescape Escape View File

@ -83,25 +83,4 @@ SPDLOG_INLINE stderr_sink<Mutex>::stderr_sink()
: stdout_sink_base<Mutex>(stderr) {} : stdout_sink_base<Mutex>(stderr) {}
} // namespace sinks } // namespace sinks
// factory methods
template <typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name) {
return Factory::template create<sinks::stdout_sink_mt>(logger_name);
}
template <typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name) {
return Factory::template create<sinks::stdout_sink_st>(logger_name);
}
template <typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name) {
return Factory::template create<sinks::stderr_sink_mt>(logger_name);
}
template <typename Factory>
SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name) {
return Factory::template create<sinks::stderr_sink_st>(logger_name);
}
} // namespace spdlog } // namespace spdlog

15
include/spdlog/sinks/stdout_sinks.h
Unescape Escape View File

@ -4,7 +4,6 @@
#pragma once #pragma once
#include <cstdio> #include <cstdio>
#include <spdlog/details/synchronous_factory.h>
#include <spdlog/sinks/base_sink.h> #include <spdlog/sinks/base_sink.h>
#ifdef _WIN32 #ifdef _WIN32
@ -54,20 +53,6 @@ using stderr_sink_mt = stderr_sink<std::mutex>;
using stderr_sink_st = stderr_sink<details::null_mutex>; using stderr_sink_st = stderr_sink<details::null_mutex>;
} // namespace sinks } // namespace sinks
// factory methods
template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name);
template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name);
template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name);
template <typename Factory = spdlog::synchronous_factory>
std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name);
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY

59
include/spdlog/spdlog-inl.h
Unescape Escape View File

@ -9,19 +9,20 @@
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/pattern_formatter.h> #include <spdlog/pattern_formatter.h>
#include <spdlog/sinks/stdout_color_sinks-inl.h>
namespace spdlog { namespace spdlog {
SPDLOG_INLINE void initialize_logger(std::shared_ptr<logger> logger) { #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
details::registry::instance().initialize_logger(std::move(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<logger> get(const std::string &name) { SPDLOG_INLINE static auto s_logger = std::make_shared<logger>("", std::make_shared<default_sink_t>());
return details::registry::instance().get(name);
}
SPDLOG_INLINE void set_formatter(std::unique_ptr<spdlog::formatter> formatter) { SPDLOG_INLINE void set_formatter(std::unique_ptr<spdlog::formatter> 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) { 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) { 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) { 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) { 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) { 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)) { 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> logger) {
details::registry::instance().register_logger(std::move(logger));
}
SPDLOG_INLINE void apply_all(const std::function<void(std::shared_ptr<logger>)> &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() { s_logger.reset(); }
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 std::shared_ptr<spdlog::logger> default_logger() { SPDLOG_INLINE std::shared_ptr<spdlog::logger> 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<spdlog::logger> default_logger) { SPDLOG_INLINE void set_default_logger(std::shared_ptr<spdlog::logger> default_logger) {
details::registry::instance().set_default_logger(std::move(default_logger)); s_logger = std::move(default_logger);
}
SPDLOG_INLINE void apply_logger_env_levels(std::shared_ptr<logger> logger) {
details::registry::instance().apply_logger_env_levels(std::move(logger));
} }
} // namespace spdlog } // namespace spdlog

105
include/spdlog/spdlog.h
Unescape Escape View File

@ -10,8 +10,6 @@
#pragma once #pragma once
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/details/registry.h>
#include <spdlog/details/synchronous_factory.h>
#include <spdlog/logger.h> #include <spdlog/logger.h>
#include <spdlog/version.h> #include <spdlog/version.h>
@ -22,35 +20,6 @@
namespace spdlog { 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<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)...);
}
// 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<spdlog::logger>("mylogger", ...);
// spdlog::initialize_logger(mylogger);
SPDLOG_API void initialize_logger(std::shared_ptr<logger> 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<logger> get(const std::string &name);
// Set global formatter. Each sink in each logger will get a clone of this object // Set global formatter. Each sink in each logger will get a clone of this object
SPDLOG_API void set_formatter(std::unique_ptr<spdlog::formatter> formatter); SPDLOG_API void set_formatter(std::unique_ptr<spdlog::formatter> formatter);
@ -80,36 +49,14 @@ SPDLOG_API bool should_log(level::level_enum lvl);
// Set global flush level // Set global flush level
SPDLOG_API void flush_on(level::level_enum log_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 <typename Rep, typename Period>
inline void flush_every(std::chrono::duration<Rep, Period> interval) {
details::registry::instance().flush_every(interval);
}
// Set global error handler // Set global error handler
SPDLOG_API void set_error_handler(void (*handler)(const std::string &msg)); 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> logger);
// Apply a user defined function on all registered loggers
// Example:
// spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) {l->flush();});
SPDLOG_API void apply_all(const std::function<void(std::shared_ptr<logger>)> &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 // stop any running threads started by spdlog and clean registry loggers
SPDLOG_API void shutdown(); 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), // API for using default logger (stdout_color_mt),
// e.g: spdlog::info("Message {}", 1); // e.g: spdlog::info("Message {}", 1);
// //
@ -127,70 +74,60 @@ SPDLOG_API void set_automatic_registration(bool automatic_registration);
SPDLOG_API std::shared_ptr<spdlog::logger> default_logger(); SPDLOG_API std::shared_ptr<spdlog::logger> default_logger();
SPDLOG_API spdlog::logger *default_logger_raw();
SPDLOG_API void set_default_logger(std::shared_ptr<spdlog::logger> default_logger); SPDLOG_API void set_default_logger(std::shared_ptr<spdlog::logger> default_logger);
// Initialize logger level based on environment configs.
//
// Useful for applying SPDLOG_LEVEL to manually created loggers.
//
// Example:
// auto mylogger = std::make_shared<spdlog::logger>("mylogger", ...);
// spdlog::apply_logger_env_levels(mylogger);
SPDLOG_API void apply_logger_env_levels(std::shared_ptr<logger> logger);
template <typename... Args> template <typename... Args>
inline void log(source_loc source, inline void log(source_loc source,
level::level_enum lvl, level::level_enum lvl,
format_string_t<Args...> fmt, format_string_t<Args...> fmt,
Args &&...args) { Args &&...args) {
default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...); default_logger()->log(source, lvl, fmt, std::forward<Args>(args)...);
} }
template <typename... Args> template <typename... Args>
inline void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args) { inline void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args) {
default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); default_logger()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
template <typename... Args> template <typename... Args>
inline void trace(format_string_t<Args...> fmt, Args &&...args) { inline void trace(format_string_t<Args...> fmt, Args &&...args) {
default_logger_raw()->trace(fmt, std::forward<Args>(args)...); default_logger()->trace(fmt, std::forward<Args>(args)...);
} }
template <typename... Args> template <typename... Args>
inline void debug(format_string_t<Args...> fmt, Args &&...args) { inline void debug(format_string_t<Args...> fmt, Args &&...args) {
default_logger_raw()->debug(fmt, std::forward<Args>(args)...); default_logger()->debug(fmt, std::forward<Args>(args)...);
} }
template <typename... Args> template <typename... Args>
inline void info(format_string_t<Args...> fmt, Args &&...args) { inline void info(format_string_t<Args...> fmt, Args &&...args) {
default_logger_raw()->info(fmt, std::forward<Args>(args)...); default_logger()->info(fmt, std::forward<Args>(args)...);
} }
template <typename... Args> template <typename... Args>
inline void warn(format_string_t<Args...> fmt, Args &&...args) { inline void warn(format_string_t<Args...> fmt, Args &&...args) {
default_logger_raw()->warn(fmt, std::forward<Args>(args)...); default_logger()->warn(fmt, std::forward<Args>(args)...);
} }
template <typename... Args> template <typename... Args>
inline void error(format_string_t<Args...> fmt, Args &&...args) { inline void error(format_string_t<Args...> fmt, Args &&...args) {
default_logger_raw()->error(fmt, std::forward<Args>(args)...); default_logger()->error(fmt, std::forward<Args>(args)...);
} }
template <typename... Args> template <typename... Args>
inline void critical(format_string_t<Args...> fmt, Args &&...args) { inline void critical(format_string_t<Args...> fmt, Args &&...args) {
default_logger_raw()->critical(fmt, std::forward<Args>(args)...); default_logger()->critical(fmt, std::forward<Args>(args)...);
} }
template <typename T> template <typename T>
inline void log(source_loc source, level::level_enum lvl, const T &msg) { 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 <typename T> template <typename T>
inline void log(level::level_enum lvl, const T &msg) { 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 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
@ -240,32 +177,32 @@ inline void critical(wformat_string_t<Args...> fmt, Args &&...args) {
template <typename T> template <typename T>
inline void trace(const T &msg) { inline void trace(const T &msg) {
default_logger_raw()->trace(msg); default_logger()->trace(msg);
} }
template <typename T> template <typename T>
inline void debug(const T &msg) { inline void debug(const T &msg) {
default_logger_raw()->debug(msg); default_logger()->debug(msg);
} }
template <typename T> template <typename T>
inline void info(const T &msg) { inline void info(const T &msg) {
default_logger_raw()->info(msg); default_logger()->info(msg);
} }
template <typename T> template <typename T>
inline void warn(const T &msg) { inline void warn(const T &msg) {
default_logger_raw()->warn(msg); default_logger()->warn(msg);
} }
template <typename T> template <typename T>
inline void error(const T &msg) { inline void error(const T &msg) {
default_logger_raw()->error(msg); default_logger()->error(msg);
} }
template <typename T> template <typename T>
inline void critical(const T &msg) { inline void critical(const T &msg) {
default_logger_raw()->critical(msg); default_logger()->critical(msg);
} }
} // namespace spdlog } // namespace spdlog
@ -303,7 +240,7 @@ inline void critical(const T &msg) {
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG
#define SPDLOG_LOGGER_DEBUG(logger, ...) \ #define SPDLOG_LOGGER_DEBUG(logger, ...) \
SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__) 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 #else
#define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0 #define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0
#define SPDLOG_DEBUG(...) (void)0 #define SPDLOG_DEBUG(...) (void)0
@ -312,7 +249,7 @@ inline void critical(const T &msg) {
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO
#define SPDLOG_LOGGER_INFO(logger, ...) \ #define SPDLOG_LOGGER_INFO(logger, ...) \
SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__) 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 #else
#define SPDLOG_LOGGER_INFO(logger, ...) (void)0 #define SPDLOG_LOGGER_INFO(logger, ...) (void)0
#define SPDLOG_INFO(...) (void)0 #define SPDLOG_INFO(...) (void)0
@ -321,7 +258,7 @@ inline void critical(const T &msg) {
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN
#define SPDLOG_LOGGER_WARN(logger, ...) \ #define SPDLOG_LOGGER_WARN(logger, ...) \
SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__) 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 #else
#define SPDLOG_LOGGER_WARN(logger, ...) (void)0 #define SPDLOG_LOGGER_WARN(logger, ...) (void)0
#define SPDLOG_WARN(...) (void)0 #define SPDLOG_WARN(...) (void)0
@ -330,7 +267,7 @@ inline void critical(const T &msg) {
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR
#define SPDLOG_LOGGER_ERROR(logger, ...) \ #define SPDLOG_LOGGER_ERROR(logger, ...) \
SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__) 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 #else
#define SPDLOG_LOGGER_ERROR(logger, ...) (void)0 #define SPDLOG_LOGGER_ERROR(logger, ...) (void)0
#define SPDLOG_ERROR(...) (void)0 #define SPDLOG_ERROR(...) (void)0
@ -339,7 +276,7 @@ inline void critical(const T &msg) {
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL
#define SPDLOG_LOGGER_CRITICAL(logger, ...) \ #define SPDLOG_LOGGER_CRITICAL(logger, ...) \
SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__) 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 #else
#define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0 #define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0
#define SPDLOG_CRITICAL(...) (void)0 #define SPDLOG_CRITICAL(...) (void)0

8
src/cfg.cpp
Unescape Escape View File

@ -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 <spdlog/cfg/helpers-inl.h>

24
src/color_sinks.cpp
Unescape Escape View File

@ -29,27 +29,3 @@ template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink<spdlog::details::
template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink<std::mutex>; template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink<std::mutex>;
template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink<spdlog::details::null_mutex>; template class SPDLOG_API spdlog::sinks::ansicolor_stderr_sink<spdlog::details::null_mutex>;
#endif #endif
// factory methods for color loggers
#include "spdlog/sinks/stdout_color_sinks-inl.h"
template SPDLOG_API std::shared_ptr<spdlog::logger>
spdlog::stdout_color_mt<spdlog::synchronous_factory>(const std::string &logger_name,
color_mode mode);
template SPDLOG_API std::shared_ptr<spdlog::logger>
spdlog::stdout_color_st<spdlog::synchronous_factory>(const std::string &logger_name,
color_mode mode);
template SPDLOG_API std::shared_ptr<spdlog::logger>
spdlog::stderr_color_mt<spdlog::synchronous_factory>(const std::string &logger_name,
color_mode mode);
template SPDLOG_API std::shared_ptr<spdlog::logger>
spdlog::stderr_color_st<spdlog::synchronous_factory>(const std::string &logger_name,
color_mode mode);
template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt<spdlog::async_factory>(
const std::string &logger_name, color_mode mode);
template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_color_st<spdlog::async_factory>(
const std::string &logger_name, color_mode mode);
template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt<spdlog::async_factory>(
const std::string &logger_name, color_mode mode);
template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_color_st<spdlog::async_factory>(
const std::string &logger_name, color_mode mode);

1
src/spdlog.cpp
Unescape Escape View File

@ -11,7 +11,6 @@
#include <spdlog/details/log_msg_buffer-inl.h> #include <spdlog/details/log_msg_buffer-inl.h>
#include <spdlog/details/null_mutex.h> #include <spdlog/details/null_mutex.h>
#include <spdlog/details/os-inl.h> #include <spdlog/details/os-inl.h>
#include <spdlog/details/registry-inl.h>
#include <spdlog/logger-inl.h> #include <spdlog/logger-inl.h>
#include <spdlog/pattern_formatter-inl.h> #include <spdlog/pattern_formatter-inl.h>
#include <spdlog/sinks/base_sink-inl.h> #include <spdlog/sinks/base_sink-inl.h>

18
src/stdout_sinks.cpp
Unescape Escape View File

@ -17,21 +17,3 @@ template class SPDLOG_API spdlog::sinks::stdout_sink<std::mutex>;
template class SPDLOG_API spdlog::sinks::stdout_sink<spdlog::details::null_mutex>; template class SPDLOG_API spdlog::sinks::stdout_sink<spdlog::details::null_mutex>;
template class SPDLOG_API spdlog::sinks::stderr_sink<std::mutex>; template class SPDLOG_API spdlog::sinks::stderr_sink<std::mutex>;
template class SPDLOG_API spdlog::sinks::stderr_sink<spdlog::details::null_mutex>; template class SPDLOG_API spdlog::sinks::stderr_sink<spdlog::details::null_mutex>;
template SPDLOG_API std::shared_ptr<spdlog::logger>
spdlog::stdout_logger_mt<spdlog::synchronous_factory>(const std::string &logger_name);
template SPDLOG_API std::shared_ptr<spdlog::logger>
spdlog::stdout_logger_st<spdlog::synchronous_factory>(const std::string &logger_name);
template SPDLOG_API std::shared_ptr<spdlog::logger>
spdlog::stderr_logger_mt<spdlog::synchronous_factory>(const std::string &logger_name);
template SPDLOG_API std::shared_ptr<spdlog::logger>
spdlog::stderr_logger_st<spdlog::synchronous_factory>(const std::string &logger_name);
template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_logger_mt<spdlog::async_factory>(
const std::string &logger_name);
template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stdout_logger_st<spdlog::async_factory>(
const std::string &logger_name);
template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_logger_mt<spdlog::async_factory>(
const std::string &logger_name);
template SPDLOG_API std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st<spdlog::async_factory>(
const std::string &logger_name);

2
tests/CMakeLists.txt
Unescape Escape View File

@ -34,7 +34,6 @@ set(SPDLOG_UTESTS_SOURCES
test_eventlog.cpp test_eventlog.cpp
test_pattern_formatter.cpp test_pattern_formatter.cpp
test_async.cpp test_async.cpp
test_registry.cpp
test_macros.cpp test_macros.cpp
utils.cpp utils.cpp
main.cpp main.cpp
@ -45,7 +44,6 @@ set(SPDLOG_UTESTS_SOURCES
test_backtrace.cpp test_backtrace.cpp
test_create_dir.cpp test_create_dir.cpp
test_custom_callbacks.cpp test_custom_callbacks.cpp
test_cfg.cpp
test_time_point.cpp test_time_point.cpp
test_stopwatch.cpp test_stopwatch.cpp
test_circular_q.cpp) test_circular_q.cpp)

1
tests/includes.h
Unescape Escape View File

@ -35,3 +35,4 @@
#include "spdlog/sinks/stdout_color_sinks.h" #include "spdlog/sinks/stdout_color_sinks.h"
#include "spdlog/sinks/msvc_sink.h" #include "spdlog/sinks/msvc_sink.h"
#include "spdlog/pattern_formatter.h" #include "spdlog/pattern_formatter.h"
#include "spdlog/details/thread_pool.h"

387
tests/test_async.cpp
Unescape Escape View File

@ -1,200 +1,187 @@
#include "includes.h" // #include "includes.h"
#include "spdlog/async.h" // #include "spdlog/async.h"
#include "spdlog/sinks/basic_file_sink.h" // #include "spdlog/sinks/basic_file_sink.h"
#include "test_sink.h" // #include "test_sink.h"
//
#define TEST_FILENAME "test_logs/async_test.log" // #define TEST_FILENAME "test_logs/async_test.log"
//
TEST_CASE("basic async test ", "[async]") { // TEST_CASE("basic async test ", "[async]") {
auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>(); // auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
size_t overrun_counter = 0; // size_t overrun_counter = 0;
size_t queue_size = 128; // size_t queue_size = 128;
size_t messages = 256; // size_t messages = 256;
{ // {
auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1); // auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp, // auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp,
spdlog::async_overflow_policy::block); // spdlog::async_overflow_policy::block);
for (size_t i = 0; i < messages; i++) { // for (size_t i = 0; i < messages; i++) {
logger->info("Hello message #{}", i); // logger->info("Hello message #{}", i);
} // }
logger->flush(); // logger->flush();
overrun_counter = tp->overrun_counter(); // overrun_counter = tp->overrun_counter();
} // }
REQUIRE(test_sink->msg_counter() == messages); // REQUIRE(test_sink->msg_counter() == messages);
REQUIRE(test_sink->flush_counter() == 1); // REQUIRE(test_sink->flush_counter() == 1);
REQUIRE(overrun_counter == 0); // REQUIRE(overrun_counter == 0);
} // }
//
TEST_CASE("discard policy ", "[async]") { // TEST_CASE("discard policy ", "[async]") {
auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>(); // auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
test_sink->set_delay(std::chrono::milliseconds(1)); // test_sink->set_delay(std::chrono::milliseconds(1));
size_t queue_size = 4; // size_t queue_size = 4;
size_t messages = 1024; // size_t messages = 1024;
//
auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1); // auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
auto logger = std::make_shared<spdlog::async_logger>( // auto logger = std::make_shared<spdlog::async_logger>(
"as", test_sink, tp, spdlog::async_overflow_policy::overrun_oldest); // "as", test_sink, tp, spdlog::async_overflow_policy::overrun_oldest);
for (size_t i = 0; i < messages; i++) { // for (size_t i = 0; i < messages; i++) {
logger->info("Hello message"); // logger->info("Hello message");
} // }
REQUIRE(test_sink->msg_counter() < messages); // REQUIRE(test_sink->msg_counter() < messages);
REQUIRE(tp->overrun_counter() > 0); // REQUIRE(tp->overrun_counter() > 0);
} // }
//
TEST_CASE("discard policy discard_new ", "[async]") { // TEST_CASE("discard policy discard_new ", "[async]") {
auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>(); // auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
test_sink->set_delay(std::chrono::milliseconds(1)); // test_sink->set_delay(std::chrono::milliseconds(1));
size_t queue_size = 4; // size_t queue_size = 4;
size_t messages = 1024; // size_t messages = 1024;
//
auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1); // auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
auto logger = std::make_shared<spdlog::async_logger>( // auto logger = std::make_shared<spdlog::async_logger>(
"as", test_sink, tp, spdlog::async_overflow_policy::discard_new); // "as", test_sink, tp, spdlog::async_overflow_policy::discard_new);
for (size_t i = 0; i < messages; i++) { // for (size_t i = 0; i < messages; i++) {
logger->info("Hello message"); // logger->info("Hello message");
} // }
REQUIRE(test_sink->msg_counter() < messages); // REQUIRE(test_sink->msg_counter() < messages);
REQUIRE(tp->discard_counter() > 0); // REQUIRE(tp->discard_counter() > 0);
} // }
//
TEST_CASE("discard policy using factory ", "[async]") { // TEST_CASE("discard policy using factory ", "[async]") {
size_t queue_size = 4; // size_t queue_size = 4;
size_t messages = 1024; // size_t messages = 1024;
spdlog::init_thread_pool(queue_size, 1); // auto logger = spdlog::create_async_nb<spdlog::sinks::test_sink_mt>("as2");
// auto test_sink = std::static_pointer_cast<spdlog::sinks::test_sink_mt>(logger->sinks()[0]);
auto logger = spdlog::create_async_nb<spdlog::sinks::test_sink_mt>("as2"); // test_sink->set_delay(std::chrono::milliseconds(3));
auto test_sink = std::static_pointer_cast<spdlog::sinks::test_sink_mt>(logger->sinks()[0]); //
test_sink->set_delay(std::chrono::milliseconds(3)); // for (size_t i = 0; i < messages; i++) {
// logger->info("Hello message");
for (size_t i = 0; i < messages; i++) { // }
logger->info("Hello message"); //
} // REQUIRE(test_sink->msg_counter() < messages);
// }
REQUIRE(test_sink->msg_counter() < messages); //
spdlog::drop_all(); // TEST_CASE("flush", "[async]") {
} // auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
// size_t queue_size = 256;
TEST_CASE("flush", "[async]") { // size_t messages = 256;
auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>(); // {
size_t queue_size = 256; // auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
size_t messages = 256; // auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp,
{ // spdlog::async_overflow_policy::block);
auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1); // for (size_t i = 0; i < messages; i++) {
auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp, // logger->info("Hello message #{}", i);
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));
logger->flush(); // REQUIRE(test_sink->msg_counter() == messages);
} // REQUIRE(test_sink->flush_counter() == 1);
// 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<spdlog::sinks::test_sink_mt>();
TEST_CASE("async periodic flush", "[async]") { // test_sink->set_delay(std::chrono::milliseconds(5));
auto logger = spdlog::create_async<spdlog::sinks::test_sink_mt>("as"); // size_t messages = 100;
auto test_sink = std::static_pointer_cast<spdlog::sinks::test_sink_mt>(logger->sinks()[0]); //
// auto tp = std::make_shared<spdlog::details::thread_pool>(messages, 2);
spdlog::flush_every(std::chrono::seconds(1)); // auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp,
std::this_thread::sleep_for(std::chrono::milliseconds(1700)); // spdlog::async_overflow_policy::block);
REQUIRE(test_sink->flush_counter() == 1); // for (size_t i = 0; i < messages; i++) {
spdlog::flush_every(std::chrono::seconds(0)); // logger->info("Hello message #{}", i);
spdlog::drop_all(); // }
} // logger->flush();
// tp.reset();
TEST_CASE("tp->wait_empty() ", "[async]") { //
auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>(); // REQUIRE(test_sink->msg_counter() == messages);
test_sink->set_delay(std::chrono::milliseconds(5)); // REQUIRE(test_sink->flush_counter() == 1);
size_t messages = 100; // }
//
auto tp = std::make_shared<spdlog::details::thread_pool>(messages, 2); // TEST_CASE("multi threads", "[async]") {
auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp, // auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
spdlog::async_overflow_policy::block); // size_t queue_size = 128;
for (size_t i = 0; i < messages; i++) { // size_t messages = 256;
logger->info("Hello message #{}", i); // size_t n_threads = 10;
} // {
logger->flush(); // auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
tp.reset(); // auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp,
// spdlog::async_overflow_policy::block);
REQUIRE(test_sink->msg_counter() == messages); //
REQUIRE(test_sink->flush_counter() == 1); // std::vector<std::thread> threads;
} // for (size_t i = 0; i < n_threads; i++) {
// threads.emplace_back([logger, messages] {
TEST_CASE("multi threads", "[async]") { // for (size_t j = 0; j < messages; j++) {
auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>(); // logger->info("Hello message #{}", j);
size_t queue_size = 128; // }
size_t messages = 256; // });
size_t n_threads = 10; // logger->flush();
{ // }
auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1); //
auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp, // for (auto &t : threads) {
spdlog::async_overflow_policy::block); // t.join();
// }
std::vector<std::thread> threads; // }
for (size_t i = 0; i < n_threads; i++) { //
threads.emplace_back([logger, messages] { // REQUIRE(test_sink->msg_counter() == messages * n_threads);
for (size_t j = 0; j < messages; j++) { // REQUIRE(test_sink->flush_counter() == n_threads);
logger->info("Hello message #{}", j); // }
} //
}); // TEST_CASE("to_file", "[async]") {
logger->flush(); // prepare_logdir();
} // size_t messages = 1024;
// size_t tp_threads = 1;
for (auto &t : threads) { // spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME);
t.join(); // {
} // auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
} // auto tp = std::make_shared<spdlog::details::thread_pool>(messages, tp_threads);
// auto logger =
REQUIRE(test_sink->msg_counter() == messages * n_threads); // std::make_shared<spdlog::async_logger>("as", std::move(file_sink), std::move(tp));
REQUIRE(test_sink->flush_counter() == n_threads); //
} // for (size_t j = 0; j < messages; j++) {
// logger->info("Hello message #{}", j);
TEST_CASE("to_file", "[async]") { // }
prepare_logdir(); // }
size_t messages = 1024; //
size_t tp_threads = 1; // require_message_count(TEST_FILENAME, messages);
spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME); // auto contents = file_contents(TEST_FILENAME);
{ // using spdlog::details::os::default_eol;
auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true); // REQUIRE(ends_with(contents, spdlog::fmt_lib::format("Hello message #1023{}", default_eol)));
auto tp = std::make_shared<spdlog::details::thread_pool>(messages, tp_threads); // }
auto logger = //
std::make_shared<spdlog::async_logger>("as", std::move(file_sink), std::move(tp)); // TEST_CASE("to_file multi-workers", "[async]") {
// prepare_logdir();
for (size_t j = 0; j < messages; j++) { // size_t messages = 1024 * 10;
logger->info("Hello message #{}", j); // size_t tp_threads = 10;
} // spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME);
} // {
// auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
require_message_count(TEST_FILENAME, messages); // auto tp = std::make_shared<spdlog::details::thread_pool>(messages, tp_threads);
auto contents = file_contents(TEST_FILENAME); // auto logger =
using spdlog::details::os::default_eol; // std::make_shared<spdlog::async_logger>("as", std::move(file_sink), std::move(tp));
REQUIRE(ends_with(contents, spdlog::fmt_lib::format("Hello message #1023{}", default_eol))); //
} // for (size_t j = 0; j < messages; j++) {
// logger->info("Hello message #{}", j);
TEST_CASE("to_file multi-workers", "[async]") { // }
prepare_logdir(); // }
size_t messages = 1024 * 10; // require_message_count(TEST_FILENAME, messages);
size_t tp_threads = 10; // }
spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME); //
{ // TEST_CASE("bad_tp", "[async]") {
auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true); // auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
auto tp = std::make_shared<spdlog::details::thread_pool>(messages, tp_threads); // std::shared_ptr<spdlog::details::thread_pool> const empty_tp;
auto logger = // auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, empty_tp);
std::make_shared<spdlog::async_logger>("as", std::move(file_sink), std::move(tp)); // logger->info("Please throw an exception");
// REQUIRE(test_sink->msg_counter() == 0);
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<spdlog::sinks::test_sink_mt>();
std::shared_ptr<spdlog::details::thread_pool> const empty_tp;
auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, empty_tp);
logger->info("Please throw an exception");
REQUIRE(test_sink->msg_counter() == 0);
}

6
tests/test_backtrace.cpp
Unescape Escape View File

@ -1,6 +1,7 @@
#include "includes.h" #include "includes.h"
#include "test_sink.h" #include "test_sink.h"
#include "spdlog/async.h" #include "spdlog/async.h"
#include "spdlog/async_logger.h"
TEST_CASE("bactrace1", "[bactrace]") { TEST_CASE("bactrace1", "[bactrace]") {
using spdlog::sinks::test_sink_st; using spdlog::sinks::test_sink_st;
@ -47,9 +48,8 @@ TEST_CASE("bactrace-async", "[bactrace]") {
size_t backtrace_size = 5; size_t backtrace_size = 5;
spdlog::init_thread_pool(120, 1); auto tp = std::make_shared<spdlog::details::thread_pool>(8192, 1U);
auto logger = std::make_shared<spdlog::async_logger>("test-bactrace-async", test_sink, auto logger = std::make_shared<spdlog::async_logger>("test-bactrace-async", test_sink, tp);
spdlog::thread_pool());
logger->set_pattern("%v"); logger->set_pattern("%v");
logger->enable_backtrace(backtrace_size); logger->enable_backtrace(backtrace_size);

169
tests/test_cfg.cpp
Unescape Escape View File

@ -1,169 +0,0 @@
#include "includes.h"
#include "test_sink.h"
#include <spdlog/cfg/env.h>
#include <spdlog/cfg/argv.h>
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<test_sink_st>("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<test_sink_st>("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<spdlog::sinks::test_sink_st>("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<test_sink_st>("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<test_sink_st>("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<test_sink_st>("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<test_sink_st>("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<spdlog::sinks::test_sink_st>("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<spdlog::sinks::test_sink_st>("l1");
l1->set_level(spdlog::level::warn);
auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("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<spdlog::sinks::test_sink_st>("l1");
auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("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<spdlog::sinks::test_sink_st>("l1");
auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("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<spdlog::sinks::test_sink_st>("l1");
auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("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);
}

1
tests/test_custom_callbacks.cpp
Unescape Escape View File

@ -31,5 +31,4 @@ TEST_CASE("custom_callback_logger", "[custom_callback_logger]") {
REQUIRE(lines[0] == ref_lines[0]); REQUIRE(lines[0] == ref_lines[0]);
REQUIRE(lines[1] == ref_lines[1]); REQUIRE(lines[1] == ref_lines[1]);
REQUIRE(lines[2] == ref_lines[2]); REQUIRE(lines[2] == ref_lines[2]);
spdlog::drop_all();
} }

12
tests/test_daily_logger.cpp
Unescape Escape View File

@ -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}"), 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); 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);
auto logger = std::make_shared<spdlog::logger>("logger", std::move(sink));
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
logger->info("Test message {}", 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}"), 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); 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) { 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); require_message_count(filename_buf_to_utf8string(w), 10);
} }

50
tests/test_errors.cpp
Unescape Escape View File

@ -3,6 +3,7 @@
* https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
*/ */
#include "includes.h" #include "includes.h"
#include "spdlog/async_logger.h"
#include <iostream> #include <iostream>
@ -24,7 +25,8 @@ TEST_CASE("default_error_handler", "[errors]") {
prepare_logdir(); prepare_logdir();
spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("test-error", filename, true); auto sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
auto logger = std::make_unique<spdlog::logger>("test-error", std::move(sink));
logger->set_pattern("%v"); logger->set_pattern("%v");
logger->info(SPDLOG_FMT_RUNTIME("Test message {} {}"), 1); logger->info(SPDLOG_FMT_RUNTIME("Test message {} {}"), 1);
logger->info("Test message {}", 2); logger->info("Test message {}", 2);
@ -37,29 +39,28 @@ TEST_CASE("default_error_handler", "[errors]") {
TEST_CASE("custom_error_handler", "[errors]") { TEST_CASE("custom_error_handler", "[errors]") {
prepare_logdir(); prepare_logdir();
spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); 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);
logger->flush_on(spdlog::level::info); spdlog::logger logger ("logger", std::move(sink));
logger->set_error_handler([=](const std::string &) { throw custom_ex(); }); logger.flush_on(spdlog::level::info);
logger->info("Good message #1"); 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); REQUIRE_THROWS_AS(logger.info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx"), custom_ex);
logger->info("Good message #2"); logger.info("Good message #2");
require_message_count(SIMPLE_LOG, 2); require_message_count(SIMPLE_LOG, 2);
} }
#endif #endif
TEST_CASE("default_error_handler2", "[errors]") { TEST_CASE("default_error_handler2", "[errors]") {
spdlog::drop_all(); spdlog::logger logger("failed_logger", std::make_shared<failing_sink>());
auto logger = spdlog::create<failing_sink>("failed_logger"); logger.set_error_handler([=](const std::string &) { throw custom_ex(); });
logger->set_error_handler([=](const std::string &) { throw custom_ex(); }); REQUIRE_THROWS_AS(logger.info("Some message"), custom_ex);
REQUIRE_THROWS_AS(logger->info("Some message"), custom_ex);
} }
TEST_CASE("flush_error_handler", "[errors]") { TEST_CASE("flush_error_handler", "[errors]") {
spdlog::drop_all(); spdlog::logger logger("failed_logger", std::make_shared<failing_sink>());
auto logger = spdlog::create<failing_sink>("failed_logger"); logger.set_error_handler([=](const std::string &) { throw custom_ex(); });
logger->set_error_handler([=](const std::string &) { throw custom_ex(); }); REQUIRE_THROWS_AS(logger.flush(), custom_ex);
REQUIRE_THROWS_AS(logger->flush(), custom_ex);
} }
#if !defined(SPDLOG_USE_STD_FORMAT) #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::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_ASYNC_LOG);
{ {
spdlog::init_thread_pool(128, 1); auto sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
auto logger = auto tp = std::make_shared<spdlog::details::thread_pool>(128, 1);
spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("logger", filename, true); auto logger = std::make_shared<spdlog::async_logger>("logger", std::move(sink), std::move(tp));
logger->set_error_handler([=](const std::string &) { logger->set_error_handler([=](const std::string &) {
std::ofstream ofs("test_logs/custom_err.txt"); std::ofstream ofs("test_logs/custom_err.txt");
if (!ofs) { if (!ofs) {
@ -82,9 +83,7 @@ TEST_CASE("async_error_handler", "[errors]") {
logger->info("Good message #1"); logger->info("Good message #1");
logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx"); logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx");
logger->info("Good message #2"); 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_message_count(SIMPLE_ASYNC_LOG, 2);
REQUIRE(file_contents("test_logs/custom_err.txt") == err_msg); 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"); std::string err_msg("This is async handler error message");
{ {
spdlog::details::os::create_dir(SPDLOG_FILENAME_T("test_logs")); spdlog::details::os::create_dir(SPDLOG_FILENAME_T("test_logs"));
spdlog::init_thread_pool(128, 1); auto tp = std::make_shared<spdlog::details::thread_pool>(128, 1);
auto logger = spdlog::create_async<failing_sink>("failed_logger"); spdlog::async_logger logger("failed_logger", std::make_shared<failing_sink>(), tp);
logger->set_error_handler([=](const std::string &) { logger.set_error_handler([=](const std::string &) {
std::ofstream ofs("test_logs/custom_err2.txt"); std::ofstream ofs("test_logs/custom_err2.txt");
if (!ofs) throw std::runtime_error("Failed open test_logs/custom_err2.txt"); if (!ofs) throw std::runtime_error("Failed open test_logs/custom_err2.txt");
ofs << err_msg; ofs << err_msg;
}); });
logger->info("Hello failure"); logger.info("Hello failure");
spdlog::drop("failed_logger"); // force logger to drain the queue and shutdown
} }
spdlog::init_thread_pool(128, 1);
REQUIRE(file_contents("test_logs/custom_err2.txt") == err_msg); REQUIRE(file_contents("test_logs/custom_err2.txt") == err_msg);
} }

28
tests/test_file_logging.cpp
Unescape Escape View File

@ -11,7 +11,8 @@ TEST_CASE("simple_file_logger", "[simple_logger]") {
prepare_logdir(); prepare_logdir();
spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
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_unique<spdlog::logger>("logger", std::move(sink));
logger->set_pattern("%v"); logger->set_pattern("%v");
logger->info("Test message {}", 1); logger->info("Test message {}", 1);
@ -28,7 +29,8 @@ TEST_CASE("flush_on", "[flush_on]") {
prepare_logdir(); prepare_logdir();
spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
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_pattern("%v"); logger->set_pattern("%v");
logger->set_level(spdlog::level::trace); logger->set_level(spdlog::level::trace);
logger->flush_on(spdlog::level::info); logger->flush_on(spdlog::level::info);
@ -49,13 +51,13 @@ TEST_CASE("rotating_file_logger1", "[rotating_logger]") {
prepare_logdir(); prepare_logdir();
size_t max_size = 1024 * 10; size_t max_size = 1024 * 10;
spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG); 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<spdlog::sinks::rotating_file_sink_mt>(basename, max_size, 0);
spdlog::logger logger("logger", std::move(sink));
for (int i = 0; i < 10; ++i) { 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); 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 // 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<spdlog::sinks::rotating_file_sink_mt>(basename, max_size, 2, true);
auto logger = std::make_shared<spdlog::logger>("logger", sink);
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
logger->info("Test message {}", 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 sink = std::make_shared<spdlog::sinks::rotating_file_sink_mt>(basename, max_size, 2, true);
auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 2, true); auto logger = std::make_shared<spdlog::logger>("logger", sink);
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
logger->info("Test message {}", i); logger->info("Test message {}", i);
} }
@ -98,6 +99,7 @@ TEST_CASE("rotating_file_logger3", "[rotating_logger]") {
prepare_logdir(); prepare_logdir();
size_t max_size = 0; size_t max_size = 0;
spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG); spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG);
REQUIRE_THROWS_AS(spdlog::rotating_logger_mt("logger", basename, max_size, 0), REQUIRE_THROWS_AS(
std::make_shared<spdlog::sinks::rotating_file_sink_mt>(basename, max_size, 2, true),
spdlog::spdlog_ex); spdlog::spdlog_ex);
} }

6
tests/test_macros.cpp
Unescape Escape View File

@ -15,7 +15,8 @@ TEST_CASE("debug and trace w/o format string", "[macros]") {
prepare_logdir(); prepare_logdir();
spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME); 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_pattern("%v"); logger->set_pattern("%v");
logger->set_level(spdlog::level::trace); logger->set_level(spdlog::level::trace);
@ -46,7 +47,8 @@ TEST_CASE("disable param evaluation", "[macros]") {
} }
TEST_CASE("pass logger pointer", "[macros]") { TEST_CASE("pass logger pointer", "[macros]") {
auto logger = spdlog::create<spdlog::sinks::null_sink_mt>("refmacro"); auto null_sink = std::make_shared<spdlog::sinks::null_sink_mt>();
auto logger = std::make_unique<spdlog::logger>("refmacro", std::move(null_sink));
auto &ref = *logger; auto &ref = *logger;
SPDLOG_LOGGER_TRACE(&ref, "Test message 1"); SPDLOG_LOGGER_TRACE(&ref, "Test message 1");
SPDLOG_LOGGER_DEBUG(&ref, "Test message 2"); SPDLOG_LOGGER_DEBUG(&ref, "Test message 2");

21
tests/test_misc.cpp
Unescape Escape View File

@ -1,5 +1,6 @@
#include "includes.h" #include "includes.h"
#include "test_sink.h" #include "test_sink.h"
#include "spdlog/async_logger.h"
template <class T> template <class T>
std::string log_info(const T &what, spdlog::level::level_enum logger_level = spdlog::level::info) { 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); 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<test_sink_mt>("periodic_flush");
auto test_sink = std::static_pointer_cast<test_sink_mt>(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]") { TEST_CASE("clone-logger", "[clone]") {
using spdlog::sinks::test_sink_mt; using spdlog::sinks::test_sink_mt;
auto test_sink = std::make_shared<test_sink_mt>(); auto test_sink = std::make_shared<test_sink_mt>();
@ -101,14 +90,13 @@ TEST_CASE("clone-logger", "[clone]") {
REQUIRE(test_sink->lines()[0] == "Some message 1"); REQUIRE(test_sink->lines()[0] == "Some message 1");
REQUIRE(test_sink->lines()[1] == "Some message 2"); REQUIRE(test_sink->lines()[1] == "Some message 2");
spdlog::drop_all();
} }
TEST_CASE("clone async", "[clone]") { TEST_CASE("clone async", "[clone]") {
using spdlog::sinks::test_sink_mt; using spdlog::sinks::test_sink_mt;
spdlog::init_thread_pool(4, 1); auto tp = std::make_shared<spdlog::details::thread_pool>(4, 1);
auto test_sink = std::make_shared<test_sink_mt>(); auto test_sink = std::make_shared<test_sink_mt>();
auto logger = std::make_shared<spdlog::async_logger>("orig", test_sink, spdlog::thread_pool()); auto logger = std::make_shared<spdlog::async_logger>("orig", test_sink, tp);
logger->set_pattern("%v"); logger->set_pattern("%v");
auto cloned = logger->clone("clone"); auto cloned = logger->clone("clone");
@ -125,8 +113,6 @@ TEST_CASE("clone async", "[clone]") {
REQUIRE(test_sink->lines().size() == 2); REQUIRE(test_sink->lines().size() == 2);
REQUIRE(test_sink->lines()[0] == "Some message 1"); REQUIRE(test_sink->lines()[0] == "Some message 1");
REQUIRE(test_sink->lines()[1] == "Some message 2"); REQUIRE(test_sink->lines()[1] == "Some message 2");
spdlog::drop_all();
} }
TEST_CASE("default logger API", "[default logger]") { 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::set_level(spdlog::level::info);
spdlog::debug("should not be logged"); spdlog::debug("should not be logged");
REQUIRE(oss.str().empty()); REQUIRE(oss.str().empty());
spdlog::drop_all();
spdlog::set_pattern("%v"); spdlog::set_pattern("%v");
} }

2
tests/test_mpmc_q.cpp
Unescape Escape View File

@ -1,4 +1,5 @@
#include "includes.h" #include "includes.h"
#include <spdlog/details/mpmc_blocking_q.h>
using std::chrono::milliseconds; using std::chrono::milliseconds;
using test_clock = std::chrono::high_resolution_clock; 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) { static milliseconds millis_from(const test_clock::time_point &tp0) {
return std::chrono::duration_cast<milliseconds>(test_clock::now() - tp0); return std::chrono::duration_cast<milliseconds>(test_clock::now() - tp0);
} }
TEST_CASE("dequeue-empty-nowait", "[mpmc_blocking_q]") { TEST_CASE("dequeue-empty-nowait", "[mpmc_blocking_q]") {
size_t q_size = 100; size_t q_size = 100;
milliseconds tolerance_wait(20); milliseconds tolerance_wait(20);

112
tests/test_registry.cpp
Unescape Escape View File

@ -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<spdlog::sinks::null_sink_mt>(tested_logger_name);
REQUIRE(spdlog::get(tested_logger_name) != nullptr);
// Throw if registering existing name
REQUIRE_THROWS_AS(spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name),
spdlog::spdlog_ex);
}
TEST_CASE("explicit register", "[registry]") {
spdlog::drop_all();
auto logger = std::make_shared<spdlog::logger>(tested_logger_name,
std::make_shared<spdlog::sinks::null_sink_st>());
spdlog::register_logger(logger);
REQUIRE(spdlog::get(tested_logger_name) != nullptr);
// Throw if registering existing name
REQUIRE_THROWS_AS(spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name),
spdlog::spdlog_ex);
}
#endif
TEST_CASE("apply_all", "[registry]") {
spdlog::drop_all();
auto logger = std::make_shared<spdlog::logger>(tested_logger_name,
std::make_shared<spdlog::sinks::null_sink_st>());
spdlog::register_logger(logger);
auto logger2 = std::make_shared<spdlog::logger>(
tested_logger_name2, std::make_shared<spdlog::sinks::null_sink_st>());
spdlog::register_logger(logger2);
int counter = 0;
spdlog::apply_all([&counter](std::shared_ptr<spdlog::logger>) { counter++; });
REQUIRE(counter == 2);
counter = 0;
spdlog::drop(tested_logger_name2);
spdlog::apply_all([&counter](std::shared_ptr<spdlog::logger> l) {
REQUIRE(l->name() == tested_logger_name);
counter++;
});
REQUIRE(counter == 1);
}
TEST_CASE("drop", "[registry]") {
spdlog::drop_all();
spdlog::create<spdlog::sinks::null_sink_mt>(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<spdlog::sinks::null_sink_mt>(tested_logger_name);
spdlog::create<spdlog::sinks::null_sink_mt>(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<spdlog::sinks::null_sink_mt>(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<spdlog::sinks::daily_file_sink_st>(
tested_logger_name, SPDLOG_FILENAME_T("filename"), 11, 59);
auto logger2 = spdlog::create_async<spdlog::sinks::stdout_color_sink_mt>(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);
}

33
tests/test_stdout_api.cpp
Unescape Escape View File

@ -5,71 +5,72 @@
#include "includes.h" #include "includes.h"
#include "spdlog/sinks/stdout_sinks.h" #include "spdlog/sinks/stdout_sinks.h"
#include "spdlog/sinks/stdout_color_sinks.h" #include "spdlog/sinks/stdout_color_sinks.h"
TEST_CASE("stdout_st", "[stdout]") { TEST_CASE("stdout_st", "[stdout]") {
auto l = spdlog::stdout_logger_st("test"); auto sink = std::make_shared<spdlog::sinks::stdout_sink_st>();
auto l = std::make_unique<spdlog::logger>("test", std::move(sink));
l->set_pattern("%+"); l->set_pattern("%+");
l->set_level(spdlog::level::trace); l->set_level(spdlog::level::trace);
l->trace("Test stdout_st"); l->trace("Test stdout_st");
spdlog::drop_all();
} }
TEST_CASE("stdout_mt", "[stdout]") { TEST_CASE("stdout_mt", "[stdout]") {
auto l = spdlog::stdout_logger_mt("test"); auto sink = std::make_shared<spdlog::sinks::stdout_sink_mt>();
auto l = std::make_unique<spdlog::logger>("test", std::move(sink));
l->set_pattern("%+"); l->set_pattern("%+");
l->set_level(spdlog::level::debug); l->set_level(spdlog::level::debug);
l->debug("Test stdout_mt"); l->debug("Test stdout_mt");
spdlog::drop_all();
} }
TEST_CASE("stderr_st", "[stderr]") { TEST_CASE("stderr_st", "[stderr]") {
auto l = spdlog::stderr_logger_st("test"); auto sink = std::make_shared<spdlog::sinks::stderr_sink_st>();
auto l = std::make_unique<spdlog::logger>("test", std::move(sink));
l->set_pattern("%+"); l->set_pattern("%+");
l->info("Test stderr_st"); l->info("Test stderr_st");
spdlog::drop_all();
} }
TEST_CASE("stderr_mt", "[stderr]") { TEST_CASE("stderr_mt", "[stderr]") {
auto l = spdlog::stderr_logger_mt("test"); auto sink = std::make_shared<spdlog::sinks::stderr_sink_mt>();
auto l = std::make_unique<spdlog::logger>("test", std::move(sink));
l->set_pattern("%+"); l->set_pattern("%+");
l->info("Test stderr_mt"); l->info("Test stderr_mt");
l->warn("Test stderr_mt"); l->warn("Test stderr_mt");
l->error("Test stderr_mt"); l->error("Test stderr_mt");
l->critical("Test stderr_mt"); l->critical("Test stderr_mt");
spdlog::drop_all();
} }
// color loggers // color loggers
TEST_CASE("stdout_color_st", "[stdout]") { TEST_CASE("stdout_color_st", "[stdout]") {
auto l = spdlog::stdout_color_st("test"); auto sink = std::make_shared<spdlog::sinks::stdout_color_sink_st>();
auto l = std::make_unique<spdlog::logger>("test", std::move(sink));
l->set_pattern("%+"); l->set_pattern("%+");
l->info("Test stdout_color_st"); l->info("Test stdout_color_st");
spdlog::drop_all();
} }
TEST_CASE("stdout_color_mt", "[stdout]") { TEST_CASE("stdout_color_mt", "[stdout]") {
auto l = spdlog::stdout_color_mt("test"); auto sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
auto l = std::make_unique<spdlog::logger>("test", std::move(sink));
l->set_pattern("%+"); l->set_pattern("%+");
l->set_level(spdlog::level::trace); l->set_level(spdlog::level::trace);
l->trace("Test stdout_color_mt"); l->trace("Test stdout_color_mt");
spdlog::drop_all();
} }
TEST_CASE("stderr_color_st", "[stderr]") { TEST_CASE("stderr_color_st", "[stderr]") {
auto l = spdlog::stderr_color_st("test"); auto sink = std::make_shared<spdlog::sinks::stderr_color_sink_st>();
auto l = std::make_unique<spdlog::logger>("test", std::move(sink));
l->set_pattern("%+"); l->set_pattern("%+");
l->set_level(spdlog::level::debug); l->set_level(spdlog::level::debug);
l->debug("Test stderr_color_st"); l->debug("Test stderr_color_st");
spdlog::drop_all();
} }
TEST_CASE("stderr_color_mt", "[stderr]") { TEST_CASE("stderr_color_mt", "[stderr]") {
auto l = spdlog::stderr_color_mt("test"); auto sink = std::make_shared<spdlog::sinks::stderr_color_sink_mt>();
auto l = std::make_unique<spdlog::logger>("test", std::move(sink));
l->set_pattern("%+"); l->set_pattern("%+");
l->info("Test stderr_color_mt"); l->info("Test stderr_color_mt");
l->warn("Test stderr_color_mt"); l->warn("Test stderr_color_mt");
l->error("Test stderr_color_mt"); l->error("Test stderr_color_mt");
l->critical("Test stderr_color_mt"); l->critical("Test stderr_color_mt");
spdlog::drop_all();
} }
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT

1
tests/test_time_point.cpp
Unescape Escape View File

@ -31,5 +31,4 @@ TEST_CASE("time_point1", "[time_point log_msg]") {
REQUIRE(lines[4] == lines[5]); REQUIRE(lines[4] == lines[5]);
REQUIRE(lines[6] == lines[7]); REQUIRE(lines[6] == lines[7]);
REQUIRE(lines[8] != lines[9]); REQUIRE(lines[8] != lines[9]);
spdlog::drop_all();
} }

1
tests/utils.cpp
Unescape Escape View File

@ -8,7 +8,6 @@
#endif #endif
void prepare_logdir() { void prepare_logdir() {
spdlog::drop_all();
#ifdef _WIN32 #ifdef _WIN32
system("rmdir /S /Q test_logs"); system("rmdir /S /Q test_logs");
#else #else

Write Preview
Loading…
Cancel
Save