mirrors/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2024-12-26 10:31:34 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Removed tweak options and spdlog_config.h

Browse Source
This commit is contained in:
gabime 2024-11-30 19:55:45 +02:00
parent 21e0810791
commit 3c9963a495
14 changed files with 47 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
CMakeLists.txt
View File

@ -76,7 +76,6 @@ option(SPDLOG_BUILD_WARNINGS "Enable compiler warnings" OFF)
option(SPDLOG_SYSTEM_INCLUDES "Include as system headers (skip for clang-tidy)." OFF)
option(SPDLOG_INSTALL "Generate the install target" ${SPDLOG_MASTER_PROJECT})
option(SPDLOG_FMT_EXTERNAL "Use external fmt library instead of of fetching from gitub." OFF)
option(SPDLOG_NO_EXCEPTIONS "Compile with -fno-exceptions. Call abort() on any spdlog exceptions" OFF)
if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
option(SPDLOG_CLOCK_COARSE "Use CLOCK_REALTIME_COARSE instead of the regular clock," OFF)
@ -86,10 +85,6 @@ 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_NO_ATOMIC_LEVELS
"prevent spdlog from using of std::atomic log levels (use only if your code never modifies log levels concurrently"
OFF)
option(SPDLOG_DISABLE_DEFAULT_LOGGER "Disable default logger creation" OFF)
# clang-tidy
@ -245,14 +240,6 @@ if(HAVE_FWRITE_UNLOCKED)
set(SPDLOG_FWRITE_UNLOCKED 1)
endif()
# ---------------------------------------------------------------------------------------
# Generate spdlog_config.h based on the current configuration
# ---------------------------------------------------------------------------------------
set(OUT_CONFIG_FILE "${CMAKE_CURRENT_SOURCE_DIR}/include/spdlog/spdlog_config.h")
message(STATUS "Generating ${OUT_CONFIG_FILE}")
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/spdlog_config.h.in" ${OUT_CONFIG_FILE} @ONLY)
list(APPEND SPDLOG_HEADERS ${OUT_CONFIG_FILE})
# ---------------------------------------------------------------------------------------
# spdlog library
# ---------------------------------------------------------------------------------------
@ -307,17 +294,20 @@ if(ANDROID)
endif()
# ---------------------------------------------------------------------------------------
# If exceptions are disabled, disable them in the bundled fmt as well
# spdlog private defines according to the options
# ---------------------------------------------------------------------------------------
if(SPDLOG_NO_EXCEPTIONS)
# Add compile definition for the fmt target
target_compile_definitions(fmt PUBLIC FMT_EXCEPTIONS=0)
if(NOT MSVC)
target_compile_options(spdlog PRIVATE -fno-exceptions)
else()
target_compile_options(spdlog PRIVATE /EHs-c-)
foreach(
SPDLOG_OPTION
SPDLOG_CLOCK_COARSE
SPDLOG_PREVENT_CHILD_FD
SPDLOG_NO_THREAD_ID
SPDLOG_DISABLE_DEFAULT_LOGGER
SPDLOG_FWRITE_UNLOCKED)
if(${SPDLOG_OPTION})
target_compile_definitions(spdlog PRIVATE ${SPDLOG_OPTION})
endif()
endif()
endforeach()
# ---------------------------------------------------------------------------------------
# Build binaries
# ---------------------------------------------------------------------------------------
@ -394,8 +384,4 @@ if(SPDLOG_INSTALL)
# Support creation of installable packages
# ---------------------------------------------------------------------------------------
include(cmake/spdlogCPack.cmake)
# Install spdlog_config.h file Assume your tweakme.h.in is located in the same directory as CMakeLists.txt
set(TWEAKME_IN "${CMAKE_CURRENT_SOURCE_DIR}/tweakme.h.in")
set(TWEAKME_OUT "${CMAKE_CURRENT_BINARY_DIR}/include/spdlog/tweakme.h")
endif()

32
cmake/spdlog_config.h.in
View File

@ -1,32 +0,0 @@
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
// DO NOT EDIT
// Auto generated file with compile time flags with which spdlog was compiled
#pragma once
// No exceptions. Will do std::abort() instead
#cmakedefine SPDLOG_NO_EXCEPTIONS
// Use CLOCK_REALTIME_COARSE on Linux
#cmakedefine SPDLOG_CLOCK_COARSE
// Prevent child processes from inheriting log file descriptors
#cmakedefine SPDLOG_PREVENT_CHILD_FD
// Prevent spdlog from querying the thread id on each log call
#cmakedefine SPDLOG_NO_THREAD_ID
// Prevent spdlog from using std::atomic for log levels
#cmakedefine SPDLOG_NO_ATOMIC_LEVELS
// Disable default logger creation
#cmakedefine SPDLOG_DISABLE_DEFAULT_LOGGER
// Use external fmtlib instead of bundled
#cmakedefine SPDLOG_FMT_EXTERNAL
// Whether fwrite_unlocked is available
#cmakedefine SPDLOG_FWRITE_UNLOCKED

22
include/spdlog/common.h
View File

@ -15,7 +15,7 @@
#include <type_traits>
#include "./source_loc.h"
#include "./spdlog_config.h"
#if defined(SPDLOG_SHARED_LIB)
#if defined(_WIN32)
@ -40,22 +40,6 @@
#define SPDLOG_FUNCTION static_cast<const char *>(__FUNCTION__)
#endif
#ifdef SPDLOG_NO_EXCEPTIONS
#define SPDLOG_TRY
#define SPDLOG_THROW(ex) \
do { \
printf("spdlog fatal error: %s\n", ex.what()); \
std::abort(); \
} while (0)
#define SPDLOG_CATCH_STD
#else
#define SPDLOG_TRY try
#define SPDLOG_THROW(ex) throw(ex)
#define SPDLOG_CATCH_STD \
catch (const std::exception &) { \
}
#endif
namespace spdlog {
class formatter;
@ -106,11 +90,7 @@ enum class level {
n_levels
};
#if defined(SPDLOG_NO_ATOMIC_LEVELS)
using atomic_level_t = details::null_atomic<level>;
#else
using atomic_level_t = std::atomic<level>;
#endif
[[nodiscard]] constexpr size_t level_to_number(level lvl) noexcept { return static_cast<size_t>(lvl); }

1
include/spdlog/fmt/fmt.h
View File

@ -5,5 +5,4 @@
#pragma once
#include "../spdlog_config.h"
#include "fmt/format.h"

34
include/spdlog/logger.h
View File

@ -22,22 +22,20 @@
#include "./details/log_msg.h"
#include "./sinks/sink.h"
#ifndef SPDLOG_NO_EXCEPTIONS
#define SPDLOG_LOGGER_CATCH(location) \
catch (const std::exception &ex) { \
if (!location.empty()) { \
err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), location.filename, location.line)); \
} else { \
err_handler_(ex.what()); \
} \
} \
catch (...) { \
err_handler_("Rethrowing unknown exception in logger"); \
throw; \
}
#else
#define SPDLOG_LOGGER_CATCH(location)
#endif
#define SPDLOG_LOGGER_CATCH(location) \
catch (const std::exception &ex) { \
if (!location.empty()) { \
err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), location.filename, location.line)); \
} else { \
err_handler_(ex.what()); \
} \
} \
catch (...) { \
err_handler_("Rethrowing unknown exception in logger"); \
throw; \
}
namespace spdlog {
@ -186,7 +184,7 @@ protected:
template <typename... Args>
void log_with_format_(source_loc loc, const level lvl, const format_string_t<Args...> &format_string, Args &&...args) {
assert(should_log(lvl));
SPDLOG_TRY {
try {
memory_buf_t buf;
fmt::vformat_to(std::back_inserter(buf), format_string, fmt::make_format_args(args...));
sink_it_(details::log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())));
@ -199,7 +197,7 @@ protected:
assert(should_log(msg.log_level));
for (auto &sink : sinks_) {
if (sink->should_log(msg.log_level)) {
SPDLOG_TRY { sink->log(msg); }
try { sink->log(msg); }
SPDLOG_LOGGER_CATCH(msg.source)
}
}

2
include/spdlog/sinks/hourly_file_sink.h
View File

@ -146,7 +146,7 @@ private:
bool ok = remove_if_exists(old_filename) == 0;
if (!ok) {
filenames_q_.push_back(std::move(current_file));
SPDLOG_THROW(spdlog_ex("Failed removing hourly file " + filename_to_str(old_filename), errno));
throw(spdlog_ex("Failed removing hourly file " + filename_to_str(old_filename), errno));
}
}
filenames_q_.push_back(std::move(current_file));

4
include/spdlog/sinks/systemd_sink.h
View File

@ -69,17 +69,13 @@ protected:
// Note: function call inside '()' to avoid macro expansion
err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(), "PRIORITY=%d",
syslog_level(msg.log_level),
#ifndef SPDLOG_NO_THREAD_ID
"TID=%zu", msg.thread_id,
#endif
"SYSLOG_IDENTIFIER=%.*s", static_cast<int>(syslog_identifier.size()),
syslog_identifier.data(), nullptr);
} else {
err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(), "PRIORITY=%d",
syslog_level(msg.log_level),
#ifndef SPDLOG_NO_THREAD_ID
"TID=%zu", msg.thread_id,
#endif
"SYSLOG_IDENTIFIER=%.*s", static_cast<int>(syslog_identifier.size()),
syslog_identifier.data(), "CODE_FILE=%s", msg.source.filename, "CODE_LINE=%d",
msg.source.line, "CODE_FUNC=%s", msg.source.funcname, nullptr);

8
src/async_logger.cpp
View File

@ -23,7 +23,7 @@ spdlog::async_logger::async_logger(std::string logger_name,
// send the log message to the thread pool
void spdlog::async_logger::sink_it_(const details::log_msg &msg) {
SPDLOG_TRY {
try {
if (auto pool_ptr = thread_pool_.lock()) {
pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
} else {
@ -35,7 +35,7 @@ void spdlog::async_logger::sink_it_(const details::log_msg &msg) {
// send flush request to the thread pool
void spdlog::async_logger::flush_() {
SPDLOG_TRY {
try {
if (auto pool_ptr = thread_pool_.lock()) {
pool_ptr->post_flush(shared_from_this(), overflow_policy_);
} else {
@ -51,7 +51,7 @@ void spdlog::async_logger::flush_() {
void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) {
for (auto &sink : sinks_) {
if (sink->should_log(msg.log_level)) {
SPDLOG_TRY { sink->log(msg); }
try { sink->log(msg); }
SPDLOG_LOGGER_CATCH(msg.source)
}
}
@ -63,7 +63,7 @@ void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) {
void spdlog::async_logger::backend_flush_() {
for (auto &sink : sinks_) {
SPDLOG_TRY { sink->flush(); }
try { sink->flush(); }
SPDLOG_LOGGER_CATCH(source_loc())
}
}

4
src/common.cpp
View File

@ -33,8 +33,8 @@ spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) {
const char *spdlog_ex::what() const noexcept { return msg_.c_str(); }
void throw_spdlog_ex(const std::string &msg, int last_errno) { SPDLOG_THROW(spdlog_ex(msg, last_errno)); }
void throw_spdlog_ex(const std::string &msg, int last_errno) { throw(spdlog_ex(msg, last_errno)); }
void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); }
void throw_spdlog_ex(std::string msg) { throw(spdlog_ex(std::move(msg))); }
} // namespace spdlog

11
src/details/log_msg.cpp
View File

@ -15,12 +15,13 @@ log_msg::log_msg(spdlog::log_clock::time_point log_time,
spdlog::string_view_t msg)
: logger_name(a_logger_name),
log_level(lvl),
time(log_time)
#ifndef SPDLOG_NO_THREAD_ID
,
thread_id(os::thread_id())
time(log_time),
#ifdef SPDLOG_NO_THREAD_ID
thread_id(0),
#else
thread_id(os::thread_id()),
#endif
,
source(loc),
payload(msg) {
}

4
src/details/thread_pool.cpp
View File

@ -37,7 +37,7 @@ thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
// message all threads to terminate gracefully join them
thread_pool::~thread_pool() {
SPDLOG_TRY {
try {
for (size_t i = 0; i < threads_.size(); i++) {
post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
}
@ -46,7 +46,7 @@ thread_pool::~thread_pool() {
t.join();
}
}
SPDLOG_CATCH_STD
catch (...) {}
}
void thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy) {

2
src/logger.cpp
View File

@ -75,7 +75,7 @@ std::shared_ptr<logger> logger::clone(std::string logger_name) {
// private/protected methods
void logger::flush_() {
for (auto &sink : sinks_) {
SPDLOG_TRY { sink->flush(); }
try { sink->flush(); }
SPDLOG_LOGGER_CATCH(source_loc())
}
}

7
tests/CMakeLists.txt
View File

@ -53,16 +53,13 @@ set(SPDLOG_UTESTS_SOURCES
test_no_source_location.cpp
test_log_level.cpp
test_include_sinks.cpp
test_bin_to_hex.cpp)
test_bin_to_hex.cpp
test_errors.cpp)
if(WIN32)
list(APPEND SPDLOG_UTESTS_SOURCES test_eventlog.cpp)
endif()
if(NOT SPDLOG_NO_EXCEPTIONS)
list(APPEND SPDLOG_UTESTS_SOURCES test_errors.cpp)
endif()
if(systemd_FOUND)
list(APPEND SPDLOG_UTESTS_SOURCES test_systemd.cpp)
endif()

2
tests/test_registry.cpp
View File

@ -7,7 +7,6 @@
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);
@ -24,7 +23,6 @@ TEST_CASE("explicit register", "[registry]") {
// 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();