outman/spdlog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Renamed default logger to global logger

Browse Source
This commit is contained in:
gabime 2024-12-06 10:58:42 +02:00
parent 28af7c211f
commit f96972db0b
11 changed files with 94 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -85,7 +85,7 @@ endif()
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_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)
# clang-tidy
@ -309,7 +309,7 @@ foreach(SPDLOG_OPTION
SPDLOG_CLOCK_COARSE
SPDLOG_PREVENT_CHILD_FD
SPDLOG_NO_THREAD_ID
SPDLOG_DISABLE_DEFAULT_LOGGER
SPDLOG_DISABLE_GLOBAL_LOGGER
SPDLOG_NO_TLS
SPDLOG_FWRITE_UNLOCKED)
if(${SPDLOG_OPTION})

6
README.md
View File

@ -410,10 +410,10 @@ void file_events_example()
---
#### Replace the Default Logger
```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);
spdlog::set_default_logger(new_logger);
auto new_logger = spdlog::basic_logger_mt("new_global_logger", "logs/new-default-log.txt", true);
spdlog::set_global_logger(new_logger);
spdlog::info("new logger log message");
}
```

14
bench/bench.cpp
View File

@ -78,7 +78,7 @@ void bench_single_threaded(int iters) {
int main(int argc, char *argv[]) {
spdlog::set_automatic_registration(false);
spdlog::default_logger()->set_pattern("[%^%l%$] %v");
spdlog::global_logger()->set_pattern("[%^%l%$] %v");
int iters = 250000;
size_t threads = 4;
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_cast;
auto orig_default = spdlog::default_logger();
spdlog::set_default_logger(log);
auto orig_default = spdlog::global_logger();
spdlog::set_global_logger(log);
auto start = high_resolution_clock::now();
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_d = duration_cast<duration<double>>(delta).count();
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 /
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
odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
auto orig_default = spdlog::default_logger();
spdlog::set_default_logger(log);
auto orig_default = spdlog::global_logger();
spdlog::set_global_logger(log);
auto start = high_resolution_clock::now();
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_d = duration_cast<duration<double>>(delta).count();
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 /
delta_d));
}

4
bench/latency.cpp
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) {
spdlog::set_default_logger(std::move(logger));
spdlog::set_global_logger(std::move(logger));
int i = 0;
for (auto _ : state) {
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) {
spdlog::set_default_logger(std::move(logger));
spdlog::set_global_logger(std::move(logger));
int i = 0;
benchmark::DoNotOptimize(i); // prevent unused warnings
benchmark::DoNotOptimize(logger); // prevent unused warnings

18
example/example.cpp
View File

@ -24,7 +24,7 @@ void syslog_example();
void udp_example();
void custom_flags_example();
void file_events_example();
void replace_default_logger_example();
void replace_global_logger_example();
#include "spdlog/spdlog.h"
#include "spdlog/version.h"
@ -66,7 +66,7 @@ int main(int, char *[]) {
udp_example();
custom_flags_example();
file_events_example();
replace_default_logger_example();
replace_global_logger_example();
// Release all spdlog resources
// This is optional (only mandatory if using windows + async log).
@ -165,9 +165,9 @@ void vector_example() {
// Compile time log levels.
// define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE)
void trace_example() {
// trace from default logger
// trace from global logger
SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23);
// debug from default logger
// debug from global logger
SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23);
}
@ -287,15 +287,15 @@ void file_events_example() {
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.
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);
spdlog::set_default_logger(new_logger);
auto new_logger = spdlog::basic_logger_mt("new_global_logger", "logs/new-default-log.txt", true);
spdlog::set_global_logger(new_logger);
spdlog::set_level(spdlog::level::info);
spdlog::debug("This message should not be displayed!");
spdlog::set_level(spdlog::level::trace);
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
View File

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

52
include/spdlog/spdlog.h
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)...);
}
// 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);
// 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");
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();
// Set logging level of the default logger
// Set logging level of the global logger
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);
// Set flush level of the default logger.
// Set flush level of the global logger.
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));
// calls context::shutdown() to perform final cleanups
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);
//
// 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:
// 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.
//
// IMPORTANT:
// The default API is thread safe (for _mt loggers), but:
// 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.
// Do not call set_global_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>
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>
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>
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
#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
#define SPDLOG_LOGGER_TRACE(logger, ...) (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
#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
#define SPDLOG_LOGGER_DEBUG(logger, ...) (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
#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
#define SPDLOG_LOGGER_INFO(logger, ...) (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
#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
#define SPDLOG_LOGGER_WARN(logger, ...) (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
#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
#define SPDLOG_LOGGER_ERROR(logger, ...) (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
#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
#define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0
#define SPDLOG_CRITICAL(...) (void)0

36
src/details/context.cpp
View File

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

27
src/spdlog.cpp
View File

@ -13,34 +13,33 @@
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) {
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) {
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); }
bool should_log(level level) { return global_logger_raw()->should_log(level); }
void set_level(level level) { default_logger_raw()->set_level(level); }
void set_level(level level) { global_logger_raw()->set_level(level); }
void flush_on(level level) { default_logger_raw()->flush_on(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(); }
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

6
tests/test_macros.cpp
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(count_lines(TEST_FILENAME) == 1);
auto orig_default_logger = spdlog::default_logger();
spdlog::set_default_logger(logger);
auto orig_global_logger = spdlog::global_logger();
spdlog::set_global_logger(logger);
SPDLOG_TRACE("Test message 3");
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(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]") {

6
tests/test_misc.cpp
View File

@ -115,14 +115,14 @@ TEST_CASE("clone async", "[clone]") {
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;
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::default_logger()->set_level(spdlog::level::trace);
spdlog::global_logger()->set_level(spdlog::level::trace);
spdlog::trace("hello trace");
REQUIRE(oss.str() == "*** hello trace" + std::string(spdlog::details::os::default_eol));