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

Removed tweak options and spdlog_config.h

Browse Source
docs2.x
gabime 9 months ago
parent 21e0810791
commit 3c9963a495
14 changed files with 47 additions and 124 deletions
Show Stats Download Patch File Download Diff File

38
CMakeLists.txt
Unescape Escape 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-)
endif()
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()
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
Unescape Escape 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
Unescape Escape 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
Unescape Escape View File

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

10
include/spdlog/logger.h
Unescape Escape View File

@ -22,7 +22,7 @@
#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()) { \
@ -35,9 +35,7 @@
err_handler_("Rethrowing unknown exception in logger"); \
throw; \
}
#else
#define SPDLOG_LOGGER_CATCH(location)
#endif
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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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
Unescape Escape 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();

Write Preview
Loading…
Cancel
Save