diff --git a/bench/bench.cpp b/bench/bench.cpp index 1c3e45b7..1573ac55 100644 --- a/bench/bench.cpp +++ b/bench/bench.cpp @@ -37,34 +37,20 @@ void bench_threaded_logging(size_t threads, int iters) auto basic_mt = spdlog::basic_logger_mt("basic_mt", "logs/basic_mt.log", true); bench_mt(iters, std::move(basic_mt), threads); - auto basic_mt_tracing = spdlog::basic_logger_mt("basic_mt/backtrace-on", "logs/basic_mt.log", true); - basic_mt_tracing->enable_backtrace(32); - bench_mt(iters, std::move(basic_mt_tracing), threads); spdlog::info(""); auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size, rotating_files); bench_mt(iters, std::move(rotating_mt), threads); - auto rotating_mt_tracing = spdlog::rotating_logger_mt("rotating_mt/backtrace-on", "logs/rotating_mt.log", file_size, rotating_files); - rotating_mt_tracing->enable_backtrace(32); - bench_mt(iters, std::move(rotating_mt_tracing), threads); spdlog::info(""); auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt.log"); bench_mt(iters, std::move(daily_mt), threads); - auto daily_mt_tracing = spdlog::daily_logger_mt("daily_mt/backtrace-on", "logs/daily_mt.log"); - daily_mt_tracing->enable_backtrace(32); - bench_mt(iters, std::move(daily_mt_tracing), threads); spdlog::info(""); auto empty_logger = std::make_shared("level-off"); empty_logger->set_level(spdlog::level::off); bench(iters, empty_logger); - auto empty_logger_tracing = std::make_shared("level-off/backtrace-on"); - empty_logger_tracing->set_level(spdlog::level::off); - empty_logger_tracing->enable_backtrace(32); - bench(iters, empty_logger_tracing); } - void bench_single_threaded(int iters) { spdlog::info("**************************************************************"); @@ -74,32 +60,18 @@ void bench_single_threaded(int iters) auto basic_st = spdlog::basic_logger_st("basic_st", "logs/basic_st.log", true); bench(iters, std::move(basic_st)); - auto basic_st_tracing = spdlog::basic_logger_st("basic_st/backtrace-on", "logs/basic_st.log", true); - bench(iters, std::move(basic_st_tracing)); - spdlog::info(""); auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size, rotating_files); bench(iters, std::move(rotating_st)); - auto rotating_st_tracing = spdlog::rotating_logger_st("rotating_st/backtrace-on", "logs/rotating_st.log", file_size, rotating_files); - rotating_st_tracing->enable_backtrace(32); - bench(iters, std::move(rotating_st_tracing)); spdlog::info(""); auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st.log"); bench(iters, std::move(daily_st)); - auto daily_st_tracing = spdlog::daily_logger_st("daily_st/backtrace-on", "logs/daily_st.log"); - daily_st_tracing->enable_backtrace(32); - bench(iters, std::move(daily_st_tracing)); spdlog::info(""); auto empty_logger = std::make_shared("level-off"); empty_logger->set_level(spdlog::level::off); bench(iters, empty_logger); - - auto empty_logger_tracing = std::make_shared("level-off/backtrace-on"); - empty_logger_tracing->set_level(spdlog::level::off); - empty_logger_tracing->enable_backtrace(32); - bench(iters, empty_logger_tracing); } int main(int argc, char *argv[]) diff --git a/bench/latency.cpp b/bench/latency.cpp index a0a4678e..9704977b 100644 --- a/bench/latency.cpp +++ b/bench/latency.cpp @@ -90,19 +90,11 @@ int main(int argc, char *argv[]) disabled_logger->set_level(spdlog::level::off); benchmark::RegisterBenchmark("disabled-at-compile-time", bench_disabled_macro, disabled_logger); benchmark::RegisterBenchmark("disabled-at-runtime", bench_logger, disabled_logger); - // with backtrace of 64 - auto tracing_disabled_logger = std::make_shared("bench", std::make_shared()); - tracing_disabled_logger->enable_backtrace(64); - benchmark::RegisterBenchmark("disabled-at-runtime/backtrace", bench_logger, tracing_disabled_logger); auto null_logger_st = std::make_shared("bench", std::make_shared()); benchmark::RegisterBenchmark("null_sink_st (500_bytes c_str)", bench_c_string, std::move(null_logger_st)); benchmark::RegisterBenchmark("null_sink_st", bench_logger, null_logger_st); benchmark::RegisterBenchmark("null_sink_fmt_string", bench_logger_fmt_string, null_logger_st); - // with backtrace of 64 - auto tracing_null_logger_st = std::make_shared("bench", std::make_shared()); - tracing_null_logger_st->enable_backtrace(64); - benchmark::RegisterBenchmark("null_sink_st/backtrace", bench_logger, tracing_null_logger_st); #ifdef __linux bench_dev_null(); @@ -114,29 +106,16 @@ int main(int argc, char *argv[]) auto basic_st = spdlog::basic_logger_st("basic_st", "latency_logs/basic_st.log", true); benchmark::RegisterBenchmark("basic_st", bench_logger, std::move(basic_st))->UseRealTime(); spdlog::drop("basic_st"); - // with backtrace of 64 - auto tracing_basic_st = spdlog::basic_logger_st("tracing_basic_st", "latency_logs/tracing_basic_st.log", true); - tracing_basic_st->enable_backtrace(64); - benchmark::RegisterBenchmark("basic_st/backtrace", bench_logger, std::move(tracing_basic_st))->UseRealTime(); - spdlog::drop("tracing_basic_st"); // rotating st auto rotating_st = spdlog::rotating_logger_st("rotating_st", "latency_logs/rotating_st.log", file_size, rotating_files); benchmark::RegisterBenchmark("rotating_st", bench_logger, std::move(rotating_st))->UseRealTime(); spdlog::drop("rotating_st"); - // with backtrace of 64 - auto tracing_rotating_st = - spdlog::rotating_logger_st("tracing_rotating_st", "latency_logs/tracing_rotating_st.log", file_size, rotating_files); - benchmark::RegisterBenchmark("rotating_st/backtrace", bench_logger, std::move(tracing_rotating_st))->UseRealTime(); - spdlog::drop("tracing_rotating_st"); // daily st auto daily_st = spdlog::daily_logger_mt("daily_st", "latency_logs/daily_st.log"); benchmark::RegisterBenchmark("daily_st", bench_logger, std::move(daily_st))->UseRealTime(); spdlog::drop("daily_st"); - auto tracing_daily_st = spdlog::daily_logger_mt("tracing_daily_st", "latency_logs/daily_st.log"); - benchmark::RegisterBenchmark("daily_st/backtrace", bench_logger, std::move(tracing_daily_st))->UseRealTime(); - spdlog::drop("tracing_daily_st"); // // Multi threaded bench, 10 loggers using same logger concurrently @@ -167,11 +146,6 @@ int main(int argc, char *argv[]) "async_logger", std::make_shared(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest); benchmark::RegisterBenchmark("async_logger", bench_logger, async_logger)->Threads(n_threads)->UseRealTime(); - auto async_logger_tracing = std::make_shared( - "async_logger_tracing", std::make_shared(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest); - async_logger_tracing->enable_backtrace(32); - benchmark::RegisterBenchmark("async_logger/tracing", bench_logger, async_logger_tracing)->Threads(n_threads)->UseRealTime(); - benchmark::Initialize(&argc, argv); benchmark::RunSpecifiedBenchmarks(); } diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h index d596d568..9839f98c 100644 --- a/include/spdlog/logger.h +++ b/include/spdlog/logger.h @@ -146,27 +146,24 @@ public: void log(log_clock::time_point log_time, source_loc loc, level::level_enum lvl, string_view_t msg) { - bool log_enabled = should_log(lvl); - - if (!log_enabled) + if (!should_log(lvl)) { return; } details::log_msg log_msg(log_time, loc, name_, lvl, msg); - log_it_(log_msg, log_enabled); + sink_it_(log_msg); } void log(source_loc loc, level::level_enum lvl, string_view_t msg) { - bool log_enabled = should_log(lvl); - if (!log_enabled) + if (!should_log(lvl)) { return; } details::log_msg log_msg(loc, name_, lvl, msg); - log_it_(log_msg, log_enabled); + sink_it_(log_msg); } void log(level::level_enum lvl, string_view_t msg) @@ -227,8 +224,7 @@ public: template void log(source_loc loc, level::level_enum lvl, wstring_view_t fmt, const Args &... args) { - bool log_enabled = should_log(lvl); - if (!log_enabled) + if (!should_log(lvl)) { return; } @@ -241,7 +237,7 @@ public: memory_buf_t buf; details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf); details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); - log_it_(log_msg, log_enabled); + sink_it_(log_msg); } SPDLOG_LOGGER_CATCH() } @@ -250,8 +246,7 @@ public: template::value, T>::type * = nullptr> void log(source_loc loc, level::level_enum lvl, const T &msg) { - bool log_enabled = should_log(lvl); - if (!log_enabled) + if (!should_log(lvl)) { return; } @@ -261,7 +256,7 @@ public: memory_buf_t buf; details::os::wstr_to_utf8buf(msg, buf); details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); - log_it_(log_msg, log_enabled); + sink_it_(log_msg); } SPDLOG_LOGGER_CATCH() } @@ -313,8 +308,7 @@ protected: template void log_(source_loc loc, level::level_enum lvl, const FormatString &fmt, const Args &... args) { - bool log_enabled = should_log(lvl); - if (!log_enabled) + if (!should_log(lvl)) { return; } @@ -323,13 +317,12 @@ protected: memory_buf_t buf; fmt::format_to(buf, fmt, args...); details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); - log_it_(log_msg, log_enabled); + sink_it_(log_msg); } SPDLOG_LOGGER_CATCH() } // log the given message (if the given log level is high enough), - void log_it_(const details::log_msg &log_msg, bool log_enabled); virtual void sink_it_(const details::log_msg &msg); virtual void flush_(); bool should_flush_(const details::log_msg &msg); diff --git a/src/logger.cpp b/src/logger.cpp index 9117ac4e..a35a5708 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -136,15 +136,6 @@ SPDLOG_INLINE std::shared_ptr logger::clone(std::string logger_name) return cloned; } -// protected methods -SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, bool log_enabled) -{ - if (log_enabled) - { - sink_it_(log_msg); - } -} - SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) { for (auto &sink : sinks_)