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

Renamed default logger to global logger

Browse Source
pull/3285/head
gabime 9 months ago
parent 28af7c211f
commit f96972db0b
11 changed files with 95 additions and 99 deletions
Show Stats Download Patch File Download Diff File

4
CMakeLists.txt
Unescape Escape View File

@ -85,7 +85,7 @@ endif()
option(SPDLOG_PREVENT_CHILD_FD "Prevent from child processes to inherit log file descriptors" OFF) option(SPDLOG_PREVENT_CHILD_FD "Prevent from child processes to inherit log file descriptors" OFF)
option(SPDLOG_NO_THREAD_ID "prevent spdlog from querying the thread id on each log call if thread id is not needed" OFF) option(SPDLOG_NO_THREAD_ID "prevent spdlog from querying the thread id on each log call if thread id is not needed" OFF)
option(SPDLOG_DISABLE_DEFAULT_LOGGER "Disable default logger creation" OFF) option(SPDLOG_DISABLE_GLOBAL_LOGGER "Disable global logger creation" OFF)
option(SPDLOG_NO_TLS "Disable thread local storage" OFF) option(SPDLOG_NO_TLS "Disable thread local storage" OFF)
# clang-tidy # clang-tidy
@ -309,7 +309,7 @@ foreach(SPDLOG_OPTION
SPDLOG_CLOCK_COARSE SPDLOG_CLOCK_COARSE
SPDLOG_PREVENT_CHILD_FD SPDLOG_PREVENT_CHILD_FD
SPDLOG_NO_THREAD_ID SPDLOG_NO_THREAD_ID
SPDLOG_DISABLE_DEFAULT_LOGGER SPDLOG_DISABLE_GLOBAL_LOGGER
SPDLOG_NO_TLS SPDLOG_NO_TLS
SPDLOG_FWRITE_UNLOCKED) SPDLOG_FWRITE_UNLOCKED)
if(${SPDLOG_OPTION}) if(${SPDLOG_OPTION})

6
README.md
Unescape Escape View File

@ -410,10 +410,10 @@ void file_events_example()
--- ---
#### Replace the Default Logger #### Replace the Default Logger
```c++ ```c++
void replace_default_logger_example() void replace_global_logger_example()
{ {
auto new_logger = spdlog::basic_logger_mt("new_default_logger", "logs/new-default-log.txt", true); auto new_logger = spdlog::basic_logger_mt("new_global_logger", "logs/new-default-log.txt", true);
spdlog::set_default_logger(new_logger); spdlog::set_global_logger(new_logger);
spdlog::info("new logger log message"); spdlog::info("new logger log message");
} }
``` ```

14
bench/bench.cpp
Unescape Escape View File

@ -78,7 +78,7 @@ void bench_single_threaded(int iters) {
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
spdlog::set_automatic_registration(false); spdlog::set_automatic_registration(false);
spdlog::default_logger()->set_pattern("[%^%l%$] %v"); spdlog::global_logger()->set_pattern("[%^%l%$] %v");
int iters = 250000; int iters = 250000;
size_t threads = 4; size_t threads = 4;
try { try {
@ -155,8 +155,8 @@ void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log)
using std::chrono::duration; using std::chrono::duration;
using std::chrono::duration_cast; using std::chrono::duration_cast;
auto orig_default = spdlog::default_logger(); auto orig_default = spdlog::global_logger();
spdlog::set_default_logger(log); spdlog::set_global_logger(log);
auto start = high_resolution_clock::now(); auto start = high_resolution_clock::now();
for (auto i = 0; i < howmany; ++i) for (auto i = 0; i < howmany; ++i)
{ {
@ -166,7 +166,7 @@ void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log)
auto delta = high_resolution_clock::now() - start; auto delta = high_resolution_clock::now() - start;
auto delta_d = duration_cast<duration<double>>(delta).count(); auto delta_d = duration_cast<duration<double>>(delta).count();
spdlog::drop(log->name()); spdlog::drop(log->name());
spdlog::set_default_logger(std::move(orig_default)); spdlog::set_global_logger(std::move(orig_default));
spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany / spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany /
delta_d)); delta_d));
} }
@ -184,8 +184,8 @@ non dapibus eros. Donec fringilla dui sed " "augue pretium, nec scelerisque est
convallis, sem nec blandit maximus, nisi turpis ornare " "nisl, sit amet volutpat neque massa eu convallis, sem nec blandit maximus, nisi turpis ornare " "nisl, sit amet volutpat neque massa eu
odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis."; odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
auto orig_default = spdlog::default_logger(); auto orig_default = spdlog::global_logger();
spdlog::set_default_logger(log); spdlog::set_global_logger(log);
auto start = high_resolution_clock::now(); auto start = high_resolution_clock::now();
for (auto i = 0; i < howmany; ++i) for (auto i = 0; i < howmany; ++i)
{ {
@ -195,7 +195,7 @@ odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
auto delta = high_resolution_clock::now() - start; auto delta = high_resolution_clock::now() - start;
auto delta_d = duration_cast<duration<double>>(delta).count(); auto delta_d = duration_cast<duration<double>>(delta).count();
spdlog::drop(log->name()); spdlog::drop(log->name());
spdlog::set_default_logger(std::move(orig_default)); spdlog::set_global_logger(std::move(orig_default));
spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany / spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany /
delta_d)); delta_d));
} }

4
bench/latency.cpp
Unescape Escape View File

@ -40,7 +40,7 @@ void bench_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logge
} }
void bench_global_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) { void bench_global_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) {
spdlog::set_default_logger(std::move(logger)); spdlog::set_global_logger(std::move(logger));
int i = 0; int i = 0;
for (auto _ : state) { for (auto _ : state) {
spdlog::info("Hello logger: msg number {}...............", ++i); spdlog::info("Hello logger: msg number {}...............", ++i);
@ -57,7 +57,7 @@ void bench_disabled_macro(benchmark::State &state, std::shared_ptr<spdlog::logge
} }
void bench_disabled_macro_global_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) { void bench_disabled_macro_global_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) {
spdlog::set_default_logger(std::move(logger)); spdlog::set_global_logger(std::move(logger));
int i = 0; int i = 0;
benchmark::DoNotOptimize(i); // prevent unused warnings benchmark::DoNotOptimize(i); // prevent unused warnings
benchmark::DoNotOptimize(logger); // prevent unused warnings benchmark::DoNotOptimize(logger); // prevent unused warnings

18
example/example.cpp
Unescape Escape View File

@ -24,7 +24,7 @@ void syslog_example();
void udp_example(); void udp_example();
void custom_flags_example(); void custom_flags_example();
void file_events_example(); void file_events_example();
void replace_default_logger_example(); void replace_global_logger_example();
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#include "spdlog/version.h" #include "spdlog/version.h"
@ -66,7 +66,7 @@ int main(int, char *[]) {
udp_example(); udp_example();
custom_flags_example(); custom_flags_example();
file_events_example(); file_events_example();
replace_default_logger_example(); replace_global_logger_example();
// Release all spdlog resources // Release all spdlog resources
// This is optional (only mandatory if using windows + async log). // This is optional (only mandatory if using windows + async log).
@ -165,9 +165,9 @@ void vector_example() {
// Compile time log levels. // Compile time log levels.
// define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE) // define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE)
void trace_example() { void trace_example() {
// trace from default logger // trace from global logger
SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23); SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23);
// debug from default logger // debug from global logger
SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23); SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23);
} }
@ -287,15 +287,15 @@ void file_events_example() {
my_logger.info("Some log line"); my_logger.info("Some log line");
} }
void replace_default_logger_example() { void replace_global_logger_example() {
// store the old logger so we don't break other examples. // store the old logger so we don't break other examples.
auto old_logger = spdlog::default_logger(); auto old_logger = spdlog::global_logger();
auto new_logger = spdlog::basic_logger_mt("new_default_logger", "logs/new-default-log.txt", true); auto new_logger = spdlog::basic_logger_mt("new_global_logger", "logs/new-default-log.txt", true);
spdlog::set_default_logger(new_logger); spdlog::set_global_logger(new_logger);
spdlog::set_level(spdlog::level::info); spdlog::set_level(spdlog::level::info);
spdlog::debug("This message should not be displayed!"); spdlog::debug("This message should not be displayed!");
spdlog::set_level(spdlog::level::trace); spdlog::set_level(spdlog::level::trace);
spdlog::debug("This message should be displayed.."); spdlog::debug("This message should be displayed..");
spdlog::set_default_logger(old_logger); spdlog::set_global_logger(old_logger);
} }

19
include/spdlog/details/context.h
Unescape Escape View File

@ -30,18 +30,17 @@ public:
context(const context &) = delete; context(const context &) = delete;
context &operator=(const context &) = delete; context &operator=(const context &) = delete;
std::shared_ptr<logger> default_logger(); std::shared_ptr<logger> global_logger();
// Return raw ptr to the default logger. // Return raw ptr to the global logger.
// To be used directly by the spdlog default api (e.g. spdlog::info) // To be used directly by the spdlog global api (e.g. spdlog::info)
// This make the default API faster, but cannot be used concurrently with set_default_logger(). // This make the global API faster, but cannot be used concurrently with set_global_logger().
// e.g do not call set_default_logger() from one thread while calling spdlog::info() from // e.g do not call set_global_logger() from one thread while calling spdlog::info() from
// another. // another.
logger *get_default_raw() const noexcept; logger *global_logger_raw() const noexcept;
// set default logger. // set logger instance.
// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. void set_logger(std::shared_ptr<logger> new_logger);
void set_default_logger(std::shared_ptr<logger> new_default_logger);
void set_tp(std::shared_ptr<thread_pool> tp); void set_tp(std::shared_ptr<thread_pool> tp);
@ -58,7 +57,7 @@ private:
std::recursive_mutex tp_mutex_; std::recursive_mutex tp_mutex_;
std::shared_ptr<thread_pool> tp_; std::shared_ptr<thread_pool> tp_;
std::shared_ptr<logger> default_logger_; std::shared_ptr<logger> global_logger_;
}; };
} // namespace details } // namespace details

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

@ -31,67 +31,65 @@ std::shared_ptr<logger> create(std::string logger_name, SinkArgs &&...sink_args)
return default_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); return default_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
} }
// Set formatter of the default logger. Each sink in each logger will get a clone of this object // Set formatter of the global logger. Each sink in each logger will get a clone of this object
SPDLOG_API void set_formatter(std::unique_ptr<formatter> formatter); SPDLOG_API void set_formatter(std::unique_ptr<formatter> formatter);
// Set format string of the default logger. // Set format string of the global logger.
// example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v"); // example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v");
SPDLOG_API void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local); SPDLOG_API void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local);
// Get logging level of the default logger // Get logging level of the global logger
SPDLOG_API level get_level(); SPDLOG_API level get_level();
// Set logging level of the default logger // Set logging level of the global logger
SPDLOG_API void set_level(level level); SPDLOG_API void set_level(level level);
// Determine whether the default logger should log messages with a certain level // Determine whether the global logger should log messages with a certain level
SPDLOG_API bool should_log(level level); SPDLOG_API bool should_log(level level);
// Set flush level of the default logger. // Set flush level of the global logger.
SPDLOG_API void flush_on(level level); SPDLOG_API void flush_on(level level);
// Set error handler for the default logger // Set error handler for the global logger
SPDLOG_API void set_error_handler(void (*handler)(const std::string &msg)); SPDLOG_API void set_error_handler(void (*handler)(const std::string &msg));
// calls context::shutdown() to perform final cleanups // calls context::shutdown() to perform final cleanups
SPDLOG_API void shutdown(); SPDLOG_API void shutdown();
// API for using default logger (stdout_color_mt), // API for using global logger (stdout_color_mt),
// e.g: spdlog::info("Message {}", 1); // e.g: spdlog::info("Message {}", 1);
// //
// The default logger object can be accessed using the spdlog::default_logger(): // The global logger object can be accessed using the spdlog::global_logger():
// For example, to add another sink to it: // For example, to add another sink to it:
// spdlog::default_logger()->sinks().push_back(some_sink); // spdlog::global_logger()->sinks().push_back(some_sink);
// //
// The default logger can be replaced using spdlog::set_default_logger(new_logger). // The global logger can be replaced using spdlog::set_global_logger(new_logger).
// For example, to replace it with a file logger. // For example, to replace it with a file logger.
// //
// IMPORTANT: // IMPORTANT:
// The default API is thread safe (for _mt loggers), but: // Do not call set_global_logger() from one thread while calling spdlog::info() from another.
// set_default_logger() *should not* be used concurrently with the default API.
// e.g. do not call set_default_logger() from one thread while calling spdlog::info() from another.
SPDLOG_API std::shared_ptr<logger> default_logger(); SPDLOG_API std::shared_ptr<logger> global_logger();
SPDLOG_API logger *default_logger_raw(); SPDLOG_API logger *global_logger_raw();
SPDLOG_API void set_default_logger(std::shared_ptr<logger> default_logger); SPDLOG_API void set_global_logger(std::shared_ptr<logger> global_logger);
template <typename... Args> template <typename... Args>
void log(source_loc source, level lvl, format_string_t<Args...> fmt, Args &&...args) { void log(source_loc source, level lvl, format_string_t<Args...> fmt, Args &&...args) {
default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...); global_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...);
} }
template <typename... Args> template <typename... Args>
void log(level lvl, format_string_t<Args...> fmt, Args &&...args) { void log(level lvl, format_string_t<Args...> fmt, Args &&...args) {
default_logger_raw()->log(lvl, fmt, std::forward<Args>(args)...); global_logger_raw()->log(lvl, fmt, std::forward<Args>(args)...);
} }
inline void log(level lvl, std::string_view msg) { default_logger_raw()->log(lvl, msg); } inline void log(level lvl, std::string_view msg) { global_logger_raw()->log(lvl, msg); }
inline void log(source_loc loc, level lvl, std::string_view msg) { default_logger_raw()->log(loc, lvl, msg); } inline void log(source_loc loc, level lvl, std::string_view msg) { global_logger_raw()->log(loc, lvl, msg); }
template <typename... Args> template <typename... Args>
void trace(format_string_t<Args...> fmt, Args &&...args) { void trace(format_string_t<Args...> fmt, Args &&...args) {
@ -160,7 +158,7 @@ inline void critical(std::string_view msg) { log(level::critical, msg); }
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE
#define SPDLOG_LOGGER_TRACE(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__) #define SPDLOG_LOGGER_TRACE(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__)
#define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__) #define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::global_logger_raw(), __VA_ARGS__)
#else #else
#define SPDLOG_LOGGER_TRACE(logger, ...) (void)0 #define SPDLOG_LOGGER_TRACE(logger, ...) (void)0
#define SPDLOG_TRACE(...) (void)0 #define SPDLOG_TRACE(...) (void)0
@ -168,7 +166,7 @@ inline void critical(std::string_view msg) { log(level::critical, msg); }
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG
#define SPDLOG_LOGGER_DEBUG(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__) #define SPDLOG_LOGGER_DEBUG(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__)
#define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__) #define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::global_logger_raw(), __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
@ -176,7 +174,7 @@ inline void critical(std::string_view msg) { log(level::critical, msg); }
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO
#define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__) #define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__)
#define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__) #define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::global_logger_raw(), __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
@ -184,7 +182,7 @@ inline void critical(std::string_view msg) { log(level::critical, msg); }
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN
#define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__) #define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__)
#define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__) #define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::global_logger_raw(), __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
@ -192,7 +190,7 @@ inline void critical(std::string_view msg) { log(level::critical, msg); }
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR
#define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__) #define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__)
#define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__) #define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::global_logger_raw(), __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
@ -200,7 +198,7 @@ inline void critical(std::string_view msg) { log(level::critical, msg); }
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL
#define SPDLOG_LOGGER_CRITICAL(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__) #define SPDLOG_LOGGER_CRITICAL(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__)
#define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__) #define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::global_logger_raw(), __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

38
src/details/context.cpp
Unescape Escape View File

@ -6,8 +6,8 @@
#include "spdlog/logger.h" #include "spdlog/logger.h"
#include "spdlog/pattern_formatter.h" #include "spdlog/pattern_formatter.h"
#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER #ifndef SPDLOG_DISABLE_GLOBAL_LOGGER
// support for the default stdout color logger // support for the global stdout color logger
#ifdef _WIN32 #ifdef _WIN32
#include "spdlog/sinks/wincolor_sink.h" #include "spdlog/sinks/wincolor_sink.h"
#else #else
@ -15,7 +15,7 @@
#include "spdlog/sinks/ansicolor_sink.h" #include "spdlog/sinks/ansicolor_sink.h"
#endif #endif
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER #endif // SPDLOG_DISABLE_GLOBAL_LOGGER
#include <memory> #include <memory>
#include <string> #include <string>
@ -27,35 +27,35 @@ namespace spdlog {
namespace details { namespace details {
context::context() { context::context() {
#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER #ifndef SPDLOG_DISABLE_GLOBAL_LOGGER
// create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows). // create global logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
#ifdef _WIN32 #ifdef _WIN32
auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>(); auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
#else #else
auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>(); auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
#endif #endif
const char *default_logger_name = ""; const char *global_logger_name = "";
default_logger_ = std::make_shared<logger>(default_logger_name, std::move(color_sink)); global_logger_ = std::make_shared<logger>(global_logger_name, std::move(color_sink));
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER #endif // SPDLOG_DISABLE_GLOBAL_LOGGER
} }
context::~context() = default; context::~context() = default;
std::shared_ptr<logger> context::default_logger() { std::shared_ptr<logger> context::global_logger() {
return default_logger_; return global_logger_;
} }
// Return raw ptr to the default logger. // Return raw ptr to the global logger.
// To be used directly by the spdlog default api (e.g. spdlog::info) // 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(). // This make the default API faster, but cannot be used concurrently with set_global_logger().
// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another. // e.g do not call set_global_logger() from one thread while calling spdlog::info() from another.
logger *context::get_default_raw() const noexcept{ return default_logger_.get(); } logger *context::global_logger_raw() const noexcept{ return global_logger_.get(); }
// set default logger. // set global logger.
// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. // global logger is stored in global_logger_ (for faster retrieval) and in the loggers_ map.
void context::set_default_logger(std::shared_ptr<logger> new_default_logger) { void context::set_logger(std::shared_ptr<logger> new_global_logger) {
default_logger_ = std::move(new_default_logger); global_logger_ = std::move(new_global_logger);
} }
void context::set_tp(std::shared_ptr<thread_pool> tp) { void context::set_tp(std::shared_ptr<thread_pool> tp) {

27
src/spdlog.cpp
Unescape Escape View File

@ -13,34 +13,33 @@
namespace spdlog { namespace spdlog {
std::shared_ptr<logger> global_logger() { return details::context::instance().global_logger(); }
logger *global_logger_raw() { return details::context::instance().global_logger_raw(); }
void set_global_logger(std::shared_ptr<logger> global_logger) {
details::context::instance().set_logger(std::move(global_logger));
}
void set_formatter(std::unique_ptr<formatter> formatter) { void set_formatter(std::unique_ptr<formatter> formatter) {
default_logger_raw()->set_formatter(std::move(formatter)); global_logger_raw()->set_formatter(std::move(formatter));
} }
void set_pattern(std::string pattern, pattern_time_type time_type) { void set_pattern(std::string pattern, pattern_time_type time_type) {
set_formatter(std::make_unique<pattern_formatter>(std::move(pattern), time_type)); set_formatter(std::make_unique<pattern_formatter>(std::move(pattern), time_type));
} }
level get_level() { return default_logger_raw()->log_level(); } level get_level() { return global_logger_raw()->log_level(); }
bool should_log(level level) { return default_logger_raw()->should_log(level); }
void set_level(level level) { default_logger_raw()->set_level(level); } bool should_log(level level) { return global_logger_raw()->should_log(level); }
void flush_on(level level) { default_logger_raw()->flush_on(level); } void set_level(level level) { global_logger_raw()->set_level(level); }
void set_error_handler(void (*handler)(const std::string &msg)) { default_logger_raw()->set_error_handler(handler); } void flush_on(level level) { global_logger_raw()->flush_on(level); }
void set_error_handler(void (*handler)(const std::string &msg)) { global_logger_raw()->set_error_handler(handler); }
void shutdown() { details::context::instance().shutdown(); } void shutdown() { details::context::instance().shutdown(); }
std::shared_ptr<logger> default_logger() { return details::context::instance().default_logger(); }
logger *default_logger_raw() { return details::context::instance().get_default_raw(); }
void set_default_logger(std::shared_ptr<logger> default_logger) {
details::context::instance().set_default_logger(std::move(default_logger));
}
} // namespace spdlog } // namespace spdlog

6
tests/test_macros.cpp
Unescape Escape View File

@ -27,8 +27,8 @@ TEST_CASE("debug and trace w/o format string", "[macros]") {
REQUIRE(ends_with(file_contents(TEST_FILENAME), spdlog::fmt_lib::format("Test message 2{}", default_eol))); REQUIRE(ends_with(file_contents(TEST_FILENAME), spdlog::fmt_lib::format("Test message 2{}", default_eol)));
REQUIRE(count_lines(TEST_FILENAME) == 1); REQUIRE(count_lines(TEST_FILENAME) == 1);
auto orig_default_logger = spdlog::default_logger(); auto orig_global_logger = spdlog::global_logger();
spdlog::set_default_logger(logger); spdlog::set_global_logger(logger);
SPDLOG_TRACE("Test message 3"); SPDLOG_TRACE("Test message 3");
SPDLOG_DEBUG("Test message {}", 4); SPDLOG_DEBUG("Test message {}", 4);
@ -36,7 +36,7 @@ TEST_CASE("debug and trace w/o format string", "[macros]") {
require_message_count(TEST_FILENAME, 2); require_message_count(TEST_FILENAME, 2);
REQUIRE(ends_with(file_contents(TEST_FILENAME), spdlog::fmt_lib::format("Test message 4{}", default_eol))); REQUIRE(ends_with(file_contents(TEST_FILENAME), spdlog::fmt_lib::format("Test message 4{}", default_eol)));
spdlog::set_default_logger(std::move(orig_default_logger)); spdlog::set_global_logger(std::move(orig_global_logger));
} }
TEST_CASE("disable param evaluation", "[macros]") { TEST_CASE("disable param evaluation", "[macros]") {

6
tests/test_misc.cpp
Unescape Escape View File

@ -115,14 +115,14 @@ TEST_CASE("clone async", "[clone]") {
REQUIRE(test_sink->lines()[1] == "Some message 2"); REQUIRE(test_sink->lines()[1] == "Some message 2");
} }
TEST_CASE("default logger API", "[default logger]") { TEST_CASE("global logger API", "[global logger]") {
std::ostringstream oss; std::ostringstream oss;
auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss); auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
spdlog::set_default_logger(std::make_shared<spdlog::logger>("oss", oss_sink)); spdlog::set_global_logger(std::make_shared<spdlog::logger>("oss", oss_sink));
spdlog::set_pattern("*** %v"); spdlog::set_pattern("*** %v");
spdlog::default_logger()->set_level(spdlog::level::trace); spdlog::global_logger()->set_level(spdlog::level::trace);
spdlog::trace("hello trace"); spdlog::trace("hello trace");
REQUIRE(oss.str() == "*** hello trace" + std::string(spdlog::details::os::default_eol)); REQUIRE(oss.str() == "*** hello trace" + std::string(spdlog::details::os::default_eol));

Write Preview
Loading…
Cancel
Save