Hello community, here is the log from the commit of package spdlog for openSUSE:Factory checked in at 2020-10-02 17:16:59 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/spdlog (Old) and /work/SRC/openSUSE:Factory/.spdlog.new.4249 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "spdlog" Fri Oct 2 17:16:59 2020 rev:15 rq:838947 version:1.8.1 Changes: -------- --- /work/SRC/openSUSE:Factory/spdlog/spdlog.changes 2020-09-04 10:54:30.358475300 +0200 +++ /work/SRC/openSUSE:Factory/.spdlog.new.4249/spdlog.changes 2020-10-02 17:17:26.802111531 +0200 @@ -1,0 +2,8 @@ +Thu Oct 1 10:11:26 UTC 2020 - [email protected] + +- Update to version 1.8.1 + * Fixed load_env_levels() and load_argv_levels() + * Fixed stopwatch's clock to use chrono::steady_clock + * Added support for Rcpp (R cpp compiler) + +------------------------------------------------------------------- Old: ---- spdlog-1.8.0.tar.gz New: ---- spdlog-1.8.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ spdlog.spec ++++++ --- /var/tmp/diff_new_pack.m6eVi2/_old 2020-10-02 17:17:27.854111576 +0200 +++ /var/tmp/diff_new_pack.m6eVi2/_new 2020-10-02 17:17:27.854111576 +0200 @@ -18,7 +18,7 @@ %define _sover 1 Name: spdlog -Version: 1.8.0 +Version: 1.8.1 Release: 0 Summary: C++ logging library License: MIT ++++++ spdlog-1.8.0.tar.gz -> spdlog-1.8.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/CMakeLists.txt new/spdlog-1.8.1/CMakeLists.txt --- old/spdlog-1.8.0/CMakeLists.txt 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/CMakeLists.txt 2020-09-30 16:30:06.000000000 +0200 @@ -18,35 +18,35 @@ # --------------------------------------------------------------------------------------- # Set default build to release # --------------------------------------------------------------------------------------- -if (NOT CMAKE_BUILD_TYPE) +if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose Release or Debug" FORCE) -endif () +endif() # --------------------------------------------------------------------------------------- # Compiler config # --------------------------------------------------------------------------------------- -if (NOT CMAKE_CXX_STANDARD) +if(NOT CMAKE_CXX_STANDARD) set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON) -endif () +endif() set(CMAKE_CXX_EXTENSIONS OFF) -if (CMAKE_SYSTEM_NAME MATCHES "CYGWIN" OR CMAKE_SYSTEM_NAME MATCHES "MSYS") +if(CMAKE_SYSTEM_NAME MATCHES "CYGWIN" OR CMAKE_SYSTEM_NAME MATCHES "MSYS") set(CMAKE_CXX_EXTENSIONS ON) -endif () +endif() # --------------------------------------------------------------------------------------- # Set SPDLOG_MASTER_PROJECT to ON if we are building spdlog # --------------------------------------------------------------------------------------- # Check if spdlog is being used directly or via add_subdirectory, but allow overriding -if (NOT DEFINED SPDLOG_MASTER_PROJECT) - if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR) +if(NOT DEFINED SPDLOG_MASTER_PROJECT) + if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR) set(SPDLOG_MASTER_PROJECT ON) - else () + else() set(SPDLOG_MASTER_PROJECT OFF) - endif () -endif () + endif() +endif() option(SPDLOG_BUILD_ALL "Build all artifacts" OFF) @@ -79,38 +79,38 @@ option(SPDLOG_FMT_EXTERNAL_HO "Use external fmt header-only library instead of bundled" OFF) option(SPDLOG_NO_EXCEPTIONS "Compile with -fno-exceptions. Call abort() on any spdlog exceptions" OFF) -if (SPDLOG_FMT_EXTERNAL AND SPDLOG_FMT_EXTERNAL_HO) +if(SPDLOG_FMT_EXTERNAL AND SPDLOG_FMT_EXTERNAL_HO) message(FATAL_ERROR "SPDLOG_FMT_EXTERNAL and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive") -endif () +endif() # misc tweakme options -if (WIN32) +if(WIN32) option(SPDLOG_WCHAR_SUPPORT "Support wchar api" OFF) option(SPDLOG_WCHAR_FILENAMES "Support wchar filenames" OFF) -endif () -if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux") +endif() +if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux") option(SPDLOG_CLOCK_COARSE - "Use the much faster (but much less accurate) CLOCK_REALTIME_COARSE instead of the regular clock," OFF) -endif () + "Use the much faster (but much less accurate) CLOCK_REALTIME_COARSE instead of the regular clock," OFF) +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_TLS "prevent spdlog from using thread local storage" 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) + SPDLOG_NO_ATOMIC_LEVELS + "prevent spdlog from using of std::atomic log levels (use only if your code never modifies log levels concurrently" + OFF) # clang-tidy -if (${CMAKE_VERSION} VERSION_GREATER "3.5") +if(${CMAKE_VERSION} VERSION_GREATER "3.5") option(SPDLOG_TIDY "run clang-tidy" OFF) -endif () +endif() -if (SPDLOG_TIDY) +if(SPDLOG_TIDY) set(CMAKE_CXX_CLANG_TIDY "clang-tidy") set(CMAKE_EXPORT_COMPILE_COMMANDS ON) message(STATUS "Enabled clang-tidy") -endif () +endif() find_package(Threads REQUIRED) message(STATUS "Build type: " ${CMAKE_BUILD_TYPE}) @@ -119,42 +119,42 @@ # --------------------------------------------------------------------------------------- set(SPDLOG_SRCS src/spdlog.cpp src/stdout_sinks.cpp src/color_sinks.cpp src/file_sinks.cpp src/async.cpp src/cfg.cpp) -if (NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO) +if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO) list(APPEND SPDLOG_SRCS src/fmt.cpp) -endif () +endif() -if (SPDLOG_BUILD_SHARED) - if (WIN32) +if(SPDLOG_BUILD_SHARED) + if(WIN32) configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc @ONLY) list(APPEND SPDLOG_SRCS ${CMAKE_CURRENT_BINARY_DIR}/version.rc) - endif () + endif() add_library(spdlog SHARED ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS}) target_compile_definitions(spdlog PUBLIC SPDLOG_SHARED_LIB) - if (MSVC) + if(MSVC) target_compile_options(spdlog PUBLIC /wd4251 /wd4275) - endif () - if (NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO) + endif() + if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO) target_compile_definitions(spdlog PRIVATE FMT_EXPORT PUBLIC FMT_SHARED) - endif () -else () + endif() +else() add_library(spdlog STATIC ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS}) -endif () +endif() add_library(spdlog::spdlog ALIAS spdlog) target_compile_definitions(spdlog PUBLIC SPDLOG_COMPILED_LIB) target_include_directories(spdlog PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>" - "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>") + "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>") target_link_libraries(spdlog PUBLIC Threads::Threads) spdlog_enable_warnings(spdlog) set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION ${SPDLOG_VERSION_MAJOR}) set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX d) -if (COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH) +if(COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH) configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pch.h.in ${PROJECT_BINARY_DIR}/spdlog_pch.h @ONLY) target_precompile_headers(spdlog PRIVATE ${PROJECT_BINARY_DIR}/spdlog_pch.h) -endif () +endif() # --------------------------------------------------------------------------------------- # Header only version @@ -163,82 +163,82 @@ add_library(spdlog::spdlog_header_only ALIAS spdlog_header_only) target_include_directories(spdlog_header_only INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>" - "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>") + "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>") target_link_libraries(spdlog_header_only INTERFACE Threads::Threads) # --------------------------------------------------------------------------------------- # Use fmt package if using external fmt # --------------------------------------------------------------------------------------- -if (SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO) - if (NOT TARGET fmt::fmt) +if(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO) + if(NOT TARGET fmt::fmt) find_package(fmt 5.3.0 REQUIRED) - endif () + endif() target_compile_definitions(spdlog PUBLIC SPDLOG_FMT_EXTERNAL) target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_FMT_EXTERNAL) # use external fmt-header-nly - if (SPDLOG_FMT_EXTERNAL_HO) + if(SPDLOG_FMT_EXTERNAL_HO) target_link_libraries(spdlog PUBLIC fmt::fmt-header-only) target_link_libraries(spdlog_header_only INTERFACE fmt::fmt-header-only) - else () # use external compile fmt + else() # use external compile fmt target_link_libraries(spdlog PUBLIC fmt::fmt) target_link_libraries(spdlog_header_only INTERFACE fmt::fmt) - endif () + endif() set(PKG_CONFIG_REQUIRES fmt) # add dependency to pkg-config -endif () +endif() # --------------------------------------------------------------------------------------- # Misc definitions according to tweak options # --------------------------------------------------------------------------------------- set(SPDLOG_WCHAR_TO_UTF8_SUPPORT ${SPDLOG_WCHAR_SUPPORT}) -foreach ( - SPDLOG_OPTION - SPDLOG_WCHAR_TO_UTF8_SUPPORT - SPDLOG_WCHAR_FILENAMES - SPDLOG_NO_EXCEPTIONS - SPDLOG_CLOCK_COARSE - SPDLOG_PREVENT_CHILD_FD - SPDLOG_NO_THREAD_ID - SPDLOG_NO_TLS - SPDLOG_NO_ATOMIC_LEVELS) - if (${SPDLOG_OPTION}) +foreach( + SPDLOG_OPTION + SPDLOG_WCHAR_TO_UTF8_SUPPORT + SPDLOG_WCHAR_FILENAMES + SPDLOG_NO_EXCEPTIONS + SPDLOG_CLOCK_COARSE + SPDLOG_PREVENT_CHILD_FD + SPDLOG_NO_THREAD_ID + SPDLOG_NO_TLS + SPDLOG_NO_ATOMIC_LEVELS) + if(${SPDLOG_OPTION}) target_compile_definitions(spdlog PUBLIC ${SPDLOG_OPTION}) target_compile_definitions(spdlog_header_only INTERFACE ${SPDLOG_OPTION}) - endif () -endforeach () + endif() +endforeach() -if (SPDLOG_NO_EXCEPTIONS AND NOT MSVC) +if(SPDLOG_NO_EXCEPTIONS AND NOT MSVC) target_compile_options(spdlog PRIVATE -fno-exceptions) -endif () +endif() # --------------------------------------------------------------------------------------- # Build binaries # --------------------------------------------------------------------------------------- -if (SPDLOG_BUILD_EXAMPLE OR SPDLOG_BUILD_EXAMPLE_HO OR SPDLOG_BUILD_ALL) +if(SPDLOG_BUILD_EXAMPLE OR SPDLOG_BUILD_EXAMPLE_HO OR SPDLOG_BUILD_ALL) message(STATUS "Generating example(s)") add_subdirectory(example) spdlog_enable_warnings(example) - if (SPDLOG_BUILD_EXAMPLE_HO) + if(SPDLOG_BUILD_EXAMPLE_HO) spdlog_enable_warnings(example_header_only) - endif () -endif () + endif() +endif() -if (SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL) +if(SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL) message(STATUS "Generating tests") enable_testing() add_subdirectory(tests) -endif () +endif() -if (SPDLOG_BUILD_BENCH OR SPDLOG_BUILD_ALL) +if(SPDLOG_BUILD_BENCH OR SPDLOG_BUILD_ALL) message(STATUS "Generating benchmarks") add_subdirectory(bench) -endif () +endif() # --------------------------------------------------------------------------------------- # Install # --------------------------------------------------------------------------------------- -if (SPDLOG_INSTALL) +if(SPDLOG_INSTALL) message(STATUS "Generating install") set(project_config_in "${CMAKE_CURRENT_LIST_DIR}/cmake/spdlogConfig.cmake.in") set(project_config_out "${CMAKE_CURRENT_BINARY_DIR}/spdlogConfig.cmake") @@ -253,16 +253,16 @@ # --------------------------------------------------------------------------------------- install(DIRECTORY include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" PATTERN "fmt/bundled" EXCLUDE) install( - TARGETS spdlog spdlog_header_only - EXPORT spdlog - LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} - ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} - RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) + TARGETS spdlog spdlog_header_only + EXPORT spdlog + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) - if (NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO) + if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO) install(DIRECTORY include/${PROJECT_NAME}/fmt/bundled/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}/fmt/bundled/") - endif () + endif() # --------------------------------------------------------------------------------------- # Install pkg-config file @@ -288,4 +288,4 @@ # Support creation of installable packages # --------------------------------------------------------------------------------------- include(cmake/spdlogCPack.cmake) -endif () +endif() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/bench/async_bench.cpp new/spdlog-1.8.1/bench/async_bench.cpp --- old/spdlog-1.8.0/bench/async_bench.cpp 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/bench/async_bench.cpp 2020-09-30 16:30:06.000000000 +0200 @@ -29,7 +29,7 @@ #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable : 4996) // disable fopen warning under msvc -#endif // _MSC_VER +#endif // _MSC_VER int count_lines(const char *filename) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/async.h new/spdlog-1.8.1/include/spdlog/async.h --- old/spdlog-1.8.0/include/spdlog/async.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/async.h 2020-09-30 16:30:06.000000000 +0200 @@ -35,7 +35,7 @@ struct async_factory_impl { template<typename Sink, typename... SinkArgs> - static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&... args) + static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args) { auto ®istry_inst = details::registry::instance(); @@ -61,13 +61,13 @@ using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>; template<typename Sink, typename... SinkArgs> -inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&... sink_args) +inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&...sink_args) { return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); } template<typename Sink, typename... SinkArgs> -inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&... sink_args) +inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&...sink_args) { return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/cfg/argv.h new/spdlog-1.8.1/include/spdlog/cfg/argv.h --- old/spdlog-1.8.0/include/spdlog/cfg/argv.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/cfg/argv.h 2020-09-30 16:30:06.000000000 +0200 @@ -30,8 +30,7 @@ if (arg.find(spdlog_level_prefix) == 0) { auto levels_string = arg.substr(spdlog_level_prefix.size()); - auto levels = helpers::extract_levels(levels_string); - details::registry::instance().update_levels(std::move(levels)); + helpers::load_levels(levels_string); } } } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/cfg/env.h new/spdlog-1.8.1/include/spdlog/cfg/env.h --- old/spdlog-1.8.0/include/spdlog/cfg/env.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/cfg/env.h 2020-09-30 16:30:06.000000000 +0200 @@ -17,7 +17,7 @@ // export SPDLOG_LEVEL=debug // // turn off all logging except for logger1: -// export SPDLOG_LEVEL="off,logger1=debug" +// export SPDLOG_LEVEL="*=off,logger1=debug" // // turn off all logging except for logger1 and logger2: @@ -28,8 +28,10 @@ inline void load_env_levels() { auto env_val = details::os::getenv("SPDLOG_LEVEL"); - auto levels = helpers::extract_levels(env_val); - details::registry::instance().update_levels(std::move(levels)); + if (!env_val.empty()) + { + helpers::load_levels(env_val); + } } } // namespace cfg diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/cfg/helpers-inl.h new/spdlog-1.8.1/include/spdlog/cfg/helpers-inl.h --- old/spdlog-1.8.0/include/spdlog/cfg/helpers-inl.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/cfg/helpers-inl.h 2020-09-30 16:30:06.000000000 +0200 @@ -78,24 +78,40 @@ return rv; } -SPDLOG_INLINE log_levels extract_levels(const std::string &input) +SPDLOG_INLINE void load_levels(const std::string &input) { + if (input.empty() || input.size() > 512) + { + return; + } + auto key_vals = extract_key_vals_(input); - log_levels rv; + std::unordered_map<std::string, level::level_enum> levels; + level::level_enum global_level = level::info; + bool global_level_found = false; for (auto &name_level : key_vals) { auto &logger_name = name_level.first; auto level_name = to_lower_(name_level.second); auto level = level::from_str(level_name); - // fallback to "info" if unrecognized level name + // ignore unrecognized level names if (level == level::off && level_name != "off") { - level = level::info; + continue; + } + if (logger_name.empty()) // no logger name indicate global level + { + global_level_found = true; + global_level = level; + } + else + { + levels[logger_name] = level; } - rv.set(logger_name, level); } - return rv; + + details::registry::instance().set_levels(std::move(levels), global_level_found ? &global_level : nullptr); } } // namespace helpers diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/cfg/helpers.h new/spdlog-1.8.1/include/spdlog/cfg/helpers.h --- old/spdlog-1.8.0/include/spdlog/cfg/helpers.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/cfg/helpers.h 2020-09-30 16:30:06.000000000 +0200 @@ -3,7 +3,8 @@ #pragma once -#include <spdlog/cfg/log_levels.h> +#include <spdlog/common.h> +#include <unordered_map> namespace spdlog { namespace cfg { @@ -17,7 +18,7 @@ // turn off all logging except for logger1: "off,logger1=debug" // turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info" // -SPDLOG_API log_levels extract_levels(const std::string &txt); +SPDLOG_API void load_levels(const std::string &txt); } // namespace helpers } // namespace cfg diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/cfg/log_levels.h new/spdlog-1.8.1/include/spdlog/cfg/log_levels.h --- old/spdlog-1.8.0/include/spdlog/cfg/log_levels.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/cfg/log_levels.h 1970-01-01 01:00:00.000000000 +0100 @@ -1,47 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/common.h> -#include <string> -#include <unordered_map> - -namespace spdlog { -namespace cfg { -class log_levels -{ - std::unordered_map<std::string, spdlog::level::level_enum> levels_; - spdlog::level::level_enum default_level_ = level::info; - -public: - void set(const std::string &logger_name, level::level_enum lvl) - { - if (logger_name.empty()) - { - default_level_ = lvl; - } - else - { - levels_[logger_name] = lvl; - } - } - - void set_default(level::level_enum lvl) - { - default_level_ = lvl; - } - - level::level_enum get(const std::string &logger_name) - { - auto it = levels_.find(logger_name); - return it != levels_.end() ? it->second : default_level_; - } - - level::level_enum default_level() - { - return default_level_; - } -}; -} // namespace cfg -} // namespace spdlog diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/common.h new/spdlog-1.8.1/include/spdlog/common.h --- old/spdlog-1.8.0/include/spdlog/common.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/common.h 2020-09-30 16:30:06.000000000 +0200 @@ -167,7 +167,6 @@ SPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT; SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT; -using level_hasher = std::hash<int>; } // namespace level // @@ -232,7 +231,7 @@ using std::make_unique; #else template<typename T, typename... Args> -std::unique_ptr<T> make_unique(Args &&... args) +std::unique_ptr<T> make_unique(Args &&...args) { static_assert(!std::is_array<T>::value, "arrays not supported"); return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/details/registry-inl.h new/spdlog-1.8.1/include/spdlog/details/registry-inl.h --- old/spdlog-1.8.0/include/spdlog/details/registry-inl.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/details/registry-inl.h 2020-09-30 16:30:06.000000000 +0200 @@ -67,7 +67,11 @@ new_logger->set_error_handler(err_handler_); } - new_logger->set_level(levels_.get(new_logger->name())); + // set new level according to previously configured level or default level + auto it = log_levels_.find(new_logger->name()); + auto new_level = it != log_levels_.end() ? it->second : global_log_level_; + new_logger->set_level(new_level); + new_logger->flush_on(flush_level_); if (backtrace_n_messages_ > 0) @@ -171,7 +175,7 @@ { l.second->set_level(log_level); } - levels_.set_default(log_level); + global_log_level_ = log_level; } SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) @@ -263,14 +267,24 @@ automatic_registration_ = automatic_registration; } -SPDLOG_INLINE void registry::update_levels(cfg::log_levels levels) +SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level) { std::lock_guard<std::mutex> lock(logger_map_mutex_); - levels_ = std::move(levels); - for (auto &l : loggers_) - { - auto &logger = l.second; - logger->set_level(levels_.get(logger->name())); + log_levels_ = std::move(levels); + auto global_level_requested = global_level != nullptr; + global_log_level_ = global_level_requested ? *global_level : global_log_level_; + + for (auto &logger : loggers_) + { + auto logger_entry = log_levels_.find(logger.first); + if (logger_entry != log_levels_.end()) + { + logger.second->set_level(logger_entry->second); + } + else if (global_level_requested) + { + logger.second->set_level(*global_level); + } } } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/details/registry.h new/spdlog-1.8.1/include/spdlog/details/registry.h --- old/spdlog-1.8.0/include/spdlog/details/registry.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/details/registry.h 2020-09-30 16:30:06.000000000 +0200 @@ -9,7 +9,6 @@ // This class is thread safe #include <spdlog/common.h> -#include <spdlog/cfg/log_levels.h> #include <chrono> #include <functional> @@ -28,6 +27,7 @@ class SPDLOG_API registry { public: + using log_levels = std::unordered_map<std::string, level::level_enum>; registry(const registry &) = delete; registry &operator=(const registry &) = delete; @@ -80,7 +80,8 @@ void set_automatic_registration(bool automatic_registration); - void update_levels(cfg::log_levels levels); + // set levels for all existing/future loggers. global_level can be null if should not set. + void set_levels(log_levels levels, level::level_enum *global_level); static registry &instance(); @@ -90,11 +91,13 @@ void throw_if_exists_(const std::string &logger_name); void register_logger_(std::shared_ptr<logger> new_logger); + bool set_level_from_cfg_(logger *logger); std::mutex logger_map_mutex_, flusher_mutex_; std::recursive_mutex tp_mutex_; std::unordered_map<std::string, std::shared_ptr<logger>> loggers_; - cfg::log_levels levels_; + log_levels log_levels_; std::unique_ptr<formatter> formatter_; + spdlog::level::level_enum global_log_level_ = level::info; level::level_enum flush_level_ = level::off; void (*err_handler_)(const std::string &msg); std::shared_ptr<thread_pool> tp_; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/details/synchronous_factory.h new/spdlog-1.8.1/include/spdlog/details/synchronous_factory.h --- old/spdlog-1.8.0/include/spdlog/details/synchronous_factory.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/details/synchronous_factory.h 2020-09-30 16:30:06.000000000 +0200 @@ -13,7 +13,7 @@ struct synchronous_factory { template<typename Sink, typename... SinkArgs> - static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... args) + static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args) { auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...); auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink)); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/fmt/bin_to_hex.h new/spdlog-1.8.1/include/spdlog/fmt/bin_to_hex.h --- old/spdlog-1.8.0/include/spdlog/fmt/bin_to_hex.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/fmt/bin_to_hex.h 2020-09-30 16:30:06.000000000 +0200 @@ -9,7 +9,7 @@ // // Support for logging binary data as hex -// format flags: +// format flags, any combination of the followng: // {:X} - print in uppercase. // {:s} - don't separate each byte with space. // {:p} - don't print the position on each line start. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/logger-inl.h new/spdlog-1.8.1/include/spdlog/logger-inl.h --- old/spdlog-1.8.0/include/spdlog/logger-inl.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/logger-inl.h 2020-09-30 16:30:06.000000000 +0200 @@ -247,7 +247,11 @@ auto tm_time = details::os::localtime(system_clock::to_time_t(now)); char date_buf[64]; std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); - fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] {%s}\n", err_counter, date_buf, name().c_str(), msg.c_str()); +#if defined(USING_R) && defined(R_R_H) // if in R environment + REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] {%s}\n", err_counter, date_buf, name().c_str(), msg.c_str()); +#else + std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] {%s}\n", err_counter, date_buf, name().c_str(), msg.c_str()); +#endif } } } // namespace spdlog diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/logger.h new/spdlog-1.8.1/include/spdlog/logger.h --- old/spdlog-1.8.0/include/spdlog/logger.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/logger.h 2020-09-30 16:30:06.000000000 +0200 @@ -75,56 +75,56 @@ // FormatString is a type derived from fmt::compile_string template<typename FormatString, typename std::enable_if<fmt::is_compile_string<FormatString>::value, int>::type = 0, typename... Args> - void log(source_loc loc, level::level_enum lvl, const FormatString &fmt, const Args &... args) + void log(source_loc loc, level::level_enum lvl, const FormatString &fmt, const Args &...args) { log_(loc, lvl, fmt, args...); } // FormatString is NOT a type derived from fmt::compile_string but is a string_view_t or can be implicitly converted to one template<typename... Args> - void log(source_loc loc, level::level_enum lvl, string_view_t fmt, const Args &... args) + void log(source_loc loc, level::level_enum lvl, string_view_t fmt, const Args &...args) { log_(loc, lvl, fmt, args...); } template<typename FormatString, typename... Args> - void log(level::level_enum lvl, const FormatString &fmt, const Args &... args) + void log(level::level_enum lvl, const FormatString &fmt, const Args &...args) { log(source_loc{}, lvl, fmt, args...); } template<typename FormatString, typename... Args> - void trace(const FormatString &fmt, const Args &... args) + void trace(const FormatString &fmt, const Args &...args) { log(level::trace, fmt, args...); } template<typename FormatString, typename... Args> - void debug(const FormatString &fmt, const Args &... args) + void debug(const FormatString &fmt, const Args &...args) { log(level::debug, fmt, args...); } template<typename FormatString, typename... Args> - void info(const FormatString &fmt, const Args &... args) + void info(const FormatString &fmt, const Args &...args) { log(level::info, fmt, args...); } template<typename FormatString, typename... Args> - void warn(const FormatString &fmt, const Args &... args) + void warn(const FormatString &fmt, const Args &...args) { log(level::warn, fmt, args...); } template<typename FormatString, typename... Args> - void error(const FormatString &fmt, const Args &... args) + void error(const FormatString &fmt, const Args &...args) { log(level::err, fmt, args...); } template<typename FormatString, typename... Args> - void critical(const FormatString &fmt, const Args &... args) + void critical(const FormatString &fmt, const Args &...args) { log(level::critical, fmt, args...); } @@ -225,7 +225,7 @@ #else template<typename... Args> - void log(source_loc loc, level::level_enum lvl, wstring_view_t fmt, const Args &... args) + void log(source_loc loc, level::level_enum lvl, wstring_view_t fmt, const Args &...args) { bool log_enabled = should_log(lvl); bool traceback_enabled = tracer_.enabled(); @@ -326,7 +326,7 @@ // common implementation for after templated public api has been resolved template<typename FormatString, typename... Args> - void log_(source_loc loc, level::level_enum lvl, const FormatString &fmt, const Args &... args) + void log_(source_loc loc, level::level_enum lvl, const FormatString &fmt, const Args &...args) { bool log_enabled = should_log(lvl); bool traceback_enabled = tracer_.enabled(); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/pattern_formatter-inl.h new/spdlog-1.8.1/include/spdlog/pattern_formatter-inl.h --- old/spdlog-1.8.0/include/spdlog/pattern_formatter-inl.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/pattern_formatter-inl.h 2020-09-30 16:30:06.000000000 +0200 @@ -45,12 +45,12 @@ return; } - if (padinfo_.side_ == padding_info::left) + if (padinfo_.side_ == padding_info::pad_side::left) { pad_it(remaining_pad_); remaining_pad_ = 0; } - else if (padinfo_.side_ == padding_info::center) + else if (padinfo_.side_ == padding_info::pad_side::center) { auto half_pad = remaining_pad_ / 2; auto reminder = remaining_pad_ & 1; @@ -1285,15 +1285,15 @@ switch (*it) { case '-': - side = padding_info::right; + side = padding_info::pad_side::right; ++it; break; case '=': - side = padding_info::center; + side = padding_info::pad_side::center; ++it; break; default: - side = details::padding_info::left; + side = details::padding_info::pad_side::left; break; } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/pattern_formatter.h new/spdlog-1.8.1/include/spdlog/pattern_formatter.h --- old/spdlog-1.8.0/include/spdlog/pattern_formatter.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/pattern_formatter.h 2020-09-30 16:30:06.000000000 +0200 @@ -22,7 +22,7 @@ // padding information. struct padding_info { - enum pad_side + enum class pad_side { left, right, @@ -42,7 +42,7 @@ return enabled_; } size_t width_ = 0; - pad_side side_ = left; + pad_side side_ = pad_side::left; bool truncate_ = false; bool enabled_ = false; }; @@ -92,7 +92,7 @@ void format(const details::log_msg &msg, memory_buf_t &dest) override; template<typename T, typename... Args> - pattern_formatter &add_flag(char flag, const Args &... args) + pattern_formatter &add_flag(char flag, const Args &...args) { custom_handlers_[flag] = details::make_unique<T>(args...); return *this; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/sinks/msvc_sink.h new/spdlog-1.8.1/include/spdlog/sinks/msvc_sink.h --- old/spdlog-1.8.0/include/spdlog/sinks/msvc_sink.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/sinks/msvc_sink.h 2020-09-30 16:30:06.000000000 +0200 @@ -8,12 +8,13 @@ #include <spdlog/details/null_mutex.h> #include <spdlog/sinks/base_sink.h> -#include <spdlog/details/windows_include.h> -#include <winbase.h> - #include <mutex> #include <string> + +// Avoid including windows.h (https://stackoverflow.com/a/30741042) +extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString); + namespace spdlog { namespace sinks { /* @@ -23,12 +24,11 @@ class msvc_sink : public base_sink<Mutex> { public: - explicit msvc_sink() {} + msvc_sink() = default; protected: void sink_it_(const details::log_msg &msg) override { - memory_buf_t formatted; base_sink<Mutex>::formatter_->format(msg, formatted); OutputDebugStringA(fmt::to_string(formatted).c_str()); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/sinks/stdout_sinks-inl.h new/spdlog-1.8.1/include/spdlog/sinks/stdout_sinks-inl.h --- old/spdlog-1.8.0/include/spdlog/sinks/stdout_sinks-inl.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/sinks/stdout_sinks-inl.h 2020-09-30 16:30:06.000000000 +0200 @@ -11,6 +11,15 @@ #include <spdlog/pattern_formatter.h> #include <memory> +#ifdef _WIN32 +// under windows using fwrite to non-binary stream results in \r\r\n (see issue #1675) +// so instead we use ::FileWrite +#include <spdlog/details/windows_include.h> +#include <fileapi.h> // WriteFile (..) +#include <io.h> // _get_osfhandle(..) +#include <stdio.h> // _fileno(..) +#endif // WIN32 + namespace spdlog { namespace sinks { @@ -20,7 +29,16 @@ : mutex_(ConsoleMutex::mutex()) , file_(file) , formatter_(details::make_unique<spdlog::pattern_formatter>()) -{} +{ +#ifdef _WIN32 + // get windows handle from the FILE* object + handle_ = (HANDLE)::_get_osfhandle(::_fileno(file_)); + if (handle_ == INVALID_HANDLE_VALUE) + { + throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno); + } +#endif // WIN32 +} template<typename ConsoleMutex> SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &msg) @@ -28,8 +46,19 @@ std::lock_guard<mutex_t> lock(mutex_); memory_buf_t formatted; formatter_->format(msg, formatted); - fwrite(formatted.data(), sizeof(char), formatted.size(), file_); - fflush(file_); // flush every line to terminal +#ifdef _WIN32 + ::fflush(file_); // flush in case there is somthing in this file_ already + auto size = static_cast<DWORD>(formatted.size()); + DWORD bytes_written = 0; + bool ok = ::WriteFile(handle_, formatted.data(), size, &bytes_written, nullptr) != 0; + if (!ok) + { + throw_spdlog_ex("stdout_sink_base: WriteFile() failed. GetLastError(): " + std::to_string(::GetLastError())); + } +#else + ::fwrite(formatted.data(), sizeof(char), formatted.size(), file_); + ::fflush(file_); // flush every line to terminal +#endif // WIN32 } template<typename ConsoleMutex> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/sinks/stdout_sinks.h new/spdlog-1.8.1/include/spdlog/sinks/stdout_sinks.h --- old/spdlog-1.8.0/include/spdlog/sinks/stdout_sinks.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/sinks/stdout_sinks.h 2020-09-30 16:30:06.000000000 +0200 @@ -8,6 +8,10 @@ #include <spdlog/sinks/sink.h> #include <cstdio> +#ifdef _WIN32 +#include <spdlog/details/windows_include.h> +#endif + namespace spdlog { namespace sinks { @@ -36,6 +40,9 @@ mutex_t &mutex_; FILE *file_; std::unique_ptr<spdlog::formatter> formatter_; +#ifdef _WIN32 + HANDLE handle_; +#endif // WIN32 }; template<typename ConsoleMutex> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/sinks/wincolor_sink-inl.h new/spdlog-1.8.1/include/spdlog/sinks/wincolor_sink-inl.h --- old/spdlog-1.8.0/include/spdlog/sinks/wincolor_sink-inl.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/sinks/wincolor_sink-inl.h 2020-09-30 16:30:06.000000000 +0200 @@ -146,22 +146,12 @@ return; } auto size = static_cast<DWORD>(formatted.size()); - if (size == 0) + DWORD bytes_written = 0; + bool ok = ::WriteFile(out_handle_, formatted.data(), size, &bytes_written, nullptr) != 0; + if (!ok) { - return; + throw_spdlog_ex("wincolor_sink: ::WriteFile() failed. GetLastError(): " + std::to_string(::GetLastError())); } - - DWORD total_written = 0; - do - { - DWORD bytes_written = 0; - bool ok = ::WriteFile(out_handle_, formatted.data() + total_written, size - total_written, &bytes_written, nullptr) != 0; - if (!ok || bytes_written == 0) - { - throw_spdlog_ex("wincolor_sink: write_to_file_ failed. GetLastError(): " + std::to_string(::GetLastError())); - } - total_written += bytes_written; - } while (total_written < size); } // wincolor_stdout_sink diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/spdlog.h new/spdlog-1.8.1/include/spdlog/spdlog.h --- old/spdlog-1.8.0/include/spdlog/spdlog.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/spdlog.h 2020-09-30 16:30:06.000000000 +0200 @@ -31,7 +31,7 @@ // Example: // spdlog::create<daily_file_sink_st>("logger_name", "dailylog_filename", 11, 59); template<typename Sink, typename... SinkArgs> -inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... sink_args) +inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...sink_args) { return default_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...); } @@ -128,49 +128,49 @@ SPDLOG_API void set_default_logger(std::shared_ptr<spdlog::logger> default_logger); template<typename FormatString, typename... Args> -inline void log(source_loc source, level::level_enum lvl, const FormatString &fmt, const Args &... args) +inline void log(source_loc source, level::level_enum lvl, const FormatString &fmt, const Args &...args) { default_logger_raw()->log(source, lvl, fmt, args...); } template<typename FormatString, typename... Args> -inline void log(level::level_enum lvl, const FormatString &fmt, const Args &... args) +inline void log(level::level_enum lvl, const FormatString &fmt, const Args &...args) { default_logger_raw()->log(source_loc{}, lvl, fmt, args...); } template<typename FormatString, typename... Args> -inline void trace(const FormatString &fmt, const Args &... args) +inline void trace(const FormatString &fmt, const Args &...args) { default_logger_raw()->trace(fmt, args...); } template<typename FormatString, typename... Args> -inline void debug(const FormatString &fmt, const Args &... args) +inline void debug(const FormatString &fmt, const Args &...args) { default_logger_raw()->debug(fmt, args...); } template<typename FormatString, typename... Args> -inline void info(const FormatString &fmt, const Args &... args) +inline void info(const FormatString &fmt, const Args &...args) { default_logger_raw()->info(fmt, args...); } template<typename FormatString, typename... Args> -inline void warn(const FormatString &fmt, const Args &... args) +inline void warn(const FormatString &fmt, const Args &...args) { default_logger_raw()->warn(fmt, args...); } template<typename FormatString, typename... Args> -inline void error(const FormatString &fmt, const Args &... args) +inline void error(const FormatString &fmt, const Args &...args) { default_logger_raw()->error(fmt, args...); } template<typename FormatString, typename... Args> -inline void critical(const FormatString &fmt, const Args &... args) +inline void critical(const FormatString &fmt, const Args &...args) { default_logger_raw()->critical(fmt, args...); } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/stopwatch.h new/spdlog-1.8.1/include/spdlog/stopwatch.h --- old/spdlog-1.8.0/include/spdlog/stopwatch.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/stopwatch.h 2020-09-30 16:30:06.000000000 +0200 @@ -5,7 +5,7 @@ #include <spdlog/fmt/fmt.h> -// Stopwatch support for spdlog (using std::chrono::high_resolution_clock). +// Stopwatch support for spdlog (using std::chrono::steady_clock). // Displays elapsed seconds since construction as double. // // Usage: @@ -27,7 +27,7 @@ namespace spdlog { class stopwatch { - using clock = std::chrono::high_resolution_clock; + using clock = std::chrono::steady_clock; std::chrono::time_point<clock> start_tp_; public: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/include/spdlog/version.h new/spdlog-1.8.1/include/spdlog/version.h --- old/spdlog-1.8.0/include/spdlog/version.h 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/include/spdlog/version.h 2020-09-30 16:30:06.000000000 +0200 @@ -5,6 +5,6 @@ #define SPDLOG_VER_MAJOR 1 #define SPDLOG_VER_MINOR 8 -#define SPDLOG_VER_PATCH 0 +#define SPDLOG_VER_PATCH 1 #define SPDLOG_VERSION (SPDLOG_VER_MAJOR * 10000 + SPDLOG_VER_MINOR * 100 + SPDLOG_VER_PATCH) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/tests/CMakeLists.txt new/spdlog-1.8.1/tests/CMakeLists.txt --- old/spdlog-1.8.0/tests/CMakeLists.txt 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/tests/CMakeLists.txt 2020-09-30 16:30:06.000000000 +0200 @@ -1,47 +1,47 @@ cmake_minimum_required(VERSION 3.10) project(spdlog_utests CXX) -if (NOT TARGET spdlog) +if(NOT TARGET spdlog) # Stand-alone build find_package(spdlog REQUIRED) -endif () +endif() include(../cmake/utils.cmake) find_package(PkgConfig) -if (PkgConfig_FOUND) +if(PkgConfig_FOUND) pkg_check_modules(systemd libsystemd) -endif () +endif() set(SPDLOG_UTESTS_SOURCES - test_file_helper.cpp - test_file_logging.cpp - test_daily_logger.cpp - test_misc.cpp - test_eventlog.cpp - test_pattern_formatter.cpp - test_async.cpp - test_registry.cpp - test_macros.cpp - utils.cpp - main.cpp - test_mpmc_q.cpp - test_dup_filter.cpp - test_fmt_helper.cpp - test_stdout_api.cpp - test_backtrace.cpp - test_create_dir.cpp - test_cfg.cpp - test_time_point.cpp - test_stopwatch.cpp) + test_file_helper.cpp + test_file_logging.cpp + test_daily_logger.cpp + test_misc.cpp + test_eventlog.cpp + test_pattern_formatter.cpp + test_async.cpp + test_registry.cpp + test_macros.cpp + utils.cpp + main.cpp + test_mpmc_q.cpp + test_dup_filter.cpp + test_fmt_helper.cpp + test_stdout_api.cpp + test_backtrace.cpp + test_create_dir.cpp + test_cfg.cpp + test_time_point.cpp + test_stopwatch.cpp) -if (NOT SPDLOG_NO_EXCEPTIONS) +if(NOT SPDLOG_NO_EXCEPTIONS) list(APPEND SPDLOG_UTESTS_SOURCES test_errors.cpp) -endif () +endif() -if (systemd_FOUND) +if(systemd_FOUND) list(APPEND SPDLOG_UTESTS_SOURCES test_systemd.cpp) -endif () +endif() enable_testing() @@ -49,22 +49,22 @@ add_executable(${test_target} ${SPDLOG_UTESTS_SOURCES}) spdlog_enable_warnings(${test_target}) target_link_libraries(${test_target} PRIVATE ${spdlog_lib}) - if (systemd_FOUND) + if(systemd_FOUND) target_link_libraries(${test_target} PRIVATE ${systemd_LIBRARIES}) - endif () - if (SPDLOG_SANITIZE_ADDRESS) + endif() + if(SPDLOG_SANITIZE_ADDRESS) spdlog_enable_sanitizer(${test_target}) - endif () + endif() add_test(NAME ${test_target} COMMAND ${test_target}) set_tests_properties(${test_target} PROPERTIES RUN_SERIAL ON) endfunction() # The compiled library tests -if (SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_ALL) +if(SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_ALL) spdlog_prepare_test(spdlog-utests spdlog::spdlog) -endif () +endif() # The header-only library version tests -if (SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL) +if(SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL) spdlog_prepare_test(spdlog-utests-ho spdlog::spdlog_header_only) -endif () +endif() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/tests/test_cfg.cpp new/spdlog-1.8.1/tests/test_cfg.cpp --- old/spdlog-1.8.0/tests/test_cfg.cpp 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/tests/test_cfg.cpp 2020-09-30 16:30:06.000000000 +0200 @@ -1,3 +1,4 @@ + #include "includes.h" #include "test_sink.h" @@ -41,21 +42,23 @@ auto l1 = spdlog::create<test_sink_st>("l1"); REQUIRE(l1->level() == spdlog::level::warn); REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace); - spdlog::set_level(spdlog::level::info); } TEST_CASE("argv3", "[cfg]") { + spdlog::set_level(spdlog::level::trace); + spdlog::drop("l1"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL="}; + const char *argv[] = {"ignore", "SPDLOG_LEVEL=junk_name=warn"}; load_argv_levels(2, argv); auto l1 = spdlog::create<test_sink_st>("l1"); - REQUIRE(l1->level() == spdlog::level::info); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); + REQUIRE(l1->level() == spdlog::level::trace); + REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace); } TEST_CASE("argv4", "[cfg]") { + spdlog::set_level(spdlog::level::info); spdlog::drop("l1"); const char *argv[] = {"ignore", "SPDLOG_LEVEL=junk"}; load_argv_levels(2, argv); @@ -65,6 +68,7 @@ TEST_CASE("argv5", "[cfg]") { + spdlog::set_level(spdlog::level::info); spdlog::drop("l1"); const char *argv[] = {"ignore", "ignore", "SPDLOG_LEVEL=l1=warn,trace"}; load_argv_levels(3, argv); @@ -91,3 +95,89 @@ REQUIRE(spdlog::default_logger()->level() == spdlog::level::err); spdlog::set_level(spdlog::level::info); } + +TEST_CASE("level-not-set-test1", "[cfg]") +{ + spdlog::drop("l1"); + const char *argv[] = {"ignore", ""}; + load_argv_levels(2, argv); + auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1"); + l1->set_level(spdlog::level::trace); + REQUIRE(l1->level() == spdlog::level::trace); + REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); +} + +TEST_CASE("level-not-set-test2", "[cfg]") +{ + spdlog::drop("l1"); + spdlog::drop("l2"); + const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace"}; + + auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1"); + l1->set_level(spdlog::level::warn); + auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2"); + l2->set_level(spdlog::level::warn); + + load_argv_levels(2, argv); + + REQUIRE(l1->level() == spdlog::level::trace); + REQUIRE(l2->level() == spdlog::level::warn); + REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); +} + +TEST_CASE("level-not-set-test3", "[cfg]") +{ + spdlog::drop("l1"); + spdlog::drop("l2"); + const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace"}; + + load_argv_levels(2, argv); + + auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1"); + auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2"); + + REQUIRE(l1->level() == spdlog::level::trace); + REQUIRE(l2->level() == spdlog::level::info); + REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); +} + +TEST_CASE("level-not-set-test4", "[cfg]") +{ + spdlog::drop("l1"); + spdlog::drop("l2"); + const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace,warn"}; + + load_argv_levels(2, argv); + + auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1"); + auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2"); + + REQUIRE(l1->level() == spdlog::level::trace); + REQUIRE(l2->level() == spdlog::level::warn); + REQUIRE(spdlog::default_logger()->level() == spdlog::level::warn); +} + +TEST_CASE("level-not-set-test5", "[cfg]") +{ + spdlog::drop("l1"); + spdlog::drop("l2"); + const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=junk,warn"}; + + load_argv_levels(2, argv); + + auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1"); + auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2"); + + REQUIRE(l1->level() == spdlog::level::warn); + REQUIRE(l2->level() == spdlog::level::warn); + REQUIRE(spdlog::default_logger()->level() == spdlog::level::warn); +} + +TEST_CASE("restore-to-default", "[cfg]") +{ + spdlog::drop("l1"); + spdlog::drop("l2"); + const char *argv[] = {"ignore", "SPDLOG_LEVEL=info"}; + load_argv_levels(2, argv); + REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spdlog-1.8.0/tests/test_pattern_formatter.cpp new/spdlog-1.8.1/tests/test_pattern_formatter.cpp --- old/spdlog-1.8.0/tests/test_pattern_formatter.cpp 2020-09-01 11:34:59.000000000 +0200 +++ new/spdlog-1.8.1/tests/test_pattern_formatter.cpp 2020-09-30 16:30:06.000000000 +0200 @@ -5,7 +5,7 @@ // log to str and return it template<typename... Args> -static std::string log_to_str(const std::string &msg, const Args &... args) +static std::string log_to_str(const std::string &msg, const Args &...args) { std::ostringstream oss; auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
