Updated fmt bundled files

.github/workflows/coverity_scan.yml

@@ -1,52 +0,0 @@
-name: coverity-linux
-
-on: [push, pull_request]
-
-permissions:
-  contents: read
-
-jobs:
-  coverity_scan:
-    runs-on: ubuntu-latest
-    name: Coverity Scan
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y curl build-essential cmake pkg-config libsystemd-dev
-
-      - name: Download Coverity Tool
-        run: |
-          curl -s -L --output coverity_tool.tgz "https://scan.coverity.com/download/linux64?token=${{ secrets.COVERITY_TOKEN }}&project=gabime%2Fspdlog"
-          mkdir coverity_tool
-          tar -C coverity_tool --strip-components=1 -xf coverity_tool.tgz
-          echo "$PWD/coverity_tool/bin" >> $GITHUB_PATH
-
-      - name: Build with Coverity
-        run: |
-          mkdir build && cd build
-          cmake .. -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_STANDARD=17
-          cd ..
-          cov-build --dir cov-int make -C build -j4
-
-      - name: Submit results to Coverity
-        run: |
-          tar czf cov-int.tgz cov-int
-          response=$(curl --silent --show-error --fail \
-            --form email="${{ secrets.EMAIL }}" \
-            --form token="${{ secrets.COVERITY_TOKEN }}" \
-            --form file=@cov-int.tgz \
-            --form version="GitHub PR #${{ github.event.pull_request.number }}" \
-            --form description="CI run for PR" \
-            https://scan.coverity.com/builds?project=gabime%2Fspdlog)
-
-          echo "$response"
-
-          if echo "$response" | grep -qi "Build successfully submitted"; then
-            echo "Coverity upload succeeded"
-          else
-            echo "Coverity upload failed or was rejected"
-            exit 1
-          fi

.github/workflows/linux.yml

@@ -18,8 +18,9 @@ jobs:
       fail-fast: false
       matrix:
         config:
-          - { compiler: gcc, version: 9, build_type: Release, cppstd: 11 }
-          - { compiler: gcc, version: 11, build_type: Debug, cppstd: 17 }
+          - { compiler: gcc, version: 7, build_type: Release, cppstd: 11 }
+          - { compiler: gcc, version: 9, build_type: Release, cppstd: 17 }
+          - { compiler: gcc, version: 11, build_type: Debug, cppstd: 20 }
           - { compiler: gcc, version: 12, build_type: Release, cppstd: 20 }
           - { compiler: gcc, version: 12, build_type: Debug, cppstd: 20, asan: ON }
           - { compiler: clang, version: 12, build_type: Debug, cppstd: 17 }

.github/workflows/windows.yml

@@ -75,5 +75,74 @@ jobs:
         run: |
           build\tests\${{ matrix.config.BUILD_TYPE }}\spdlog-utests.exe
 
+  # -----------------------------------------------------------------------
+  # MSVC 2019 build matrix
+  # -----------------------------------------------------------------------
+  build_2019:
+    runs-on: windows-2019
+    strategy:
+      fail-fast: true
+      matrix:
+        config:
+          - GENERATOR: "Visual Studio 16 2019"
+            BUILD_TYPE: Release
+            BUILD_SHARED: 'ON'
+            FATAL_ERRORS: 'ON'
+            WCHAR: 'OFF'
+            WCHAR_FILES: 'OFF'
+            BUILD_EXAMPLE: 'ON'
+            USE_STD_FORMAT: 'OFF'
+            CXX_STANDARD: 17
+          - GENERATOR: "Visual Studio 16 2019"
+            BUILD_TYPE: Release
+            BUILD_SHARED: 'ON'
+            FATAL_ERRORS: 'ON'
+            WCHAR: 'OFF'
+            WCHAR_FILES: 'OFF'
+            BUILD_EXAMPLE: 'ON'
+            USE_STD_FORMAT: 'OFF'
+            CXX_STANDARD: 14
+          - GENERATOR: "Visual Studio 16 2019"
+            BUILD_TYPE: Release
+            BUILD_SHARED: 'ON'
+            FATAL_ERRORS: 'ON'
+            WCHAR: 'OFF'
+            WCHAR_FILES: 'OFF'
+            BUILD_EXAMPLE: 'ON'
+            USE_STD_FORMAT: 'OFF'
+            CXX_STANDARD: 11
 
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
 
+      - name: CMake ${{ matrix.config.GENERATOR }} CXX=${{matrix.config.CXX_STANDARD}} WCHAR=${{matrix.config.WCHAR_FILES}} STD_FORMAT=${{matrix.config.USE_STD_FORMAT}}
+        shell: pwsh
+        run: |
+          mkdir build
+          cd build
+          cmake -G "${{ matrix.config.GENERATOR }}"  -A x64 `
+            -D CMAKE_BUILD_TYPE=${{ matrix.config.BUILD_TYPE }} `
+            -D BUILD_SHARED_LIBS=${{ matrix.config.BUILD_SHARED }} `
+            -D SPDLOG_WCHAR_SUPPORT=${{ matrix.config.WCHAR }} `
+            -D SPDLOG_WCHAR_FILENAMES=${{ matrix.config.WCHAR_FILES }} `
+            -D SPDLOG_BUILD_EXAMPLE=${{ matrix.config.BUILD_EXAMPLE }} `
+            -D SPDLOG_BUILD_EXAMPLE_HO=${{ matrix.config.BUILD_EXAMPLE }} `
+            -D SPDLOG_BUILD_TESTS=ON `
+            -D SPDLOG_BUILD_TESTS_HO=OFF `
+            -D SPDLOG_BUILD_WARNINGS=${{ matrix.config.FATAL_ERRORS }} `
+            -D SPDLOG_USE_STD_FORMAT=${{ matrix.config.USE_STD_FORMAT }} `
+            -D CMAKE_CXX_STANDARD=${{ matrix.config.CXX_STANDARD }} ..
+
+      - name: Build
+        shell: pwsh
+        run: |
+          cd build
+          cmake --build  . --parallel --config ${{ matrix.config.BUILD_TYPE }}
+
+      - name: Run Tests
+        shell: pwsh
+        env:
+          PATH: ${{ env.PATH }};${{ github.workspace }}\build\_deps\catch2-build\src\${{ matrix.config.BUILD_TYPE }};${{ github.workspace }}\build\${{ matrix.config.BUILD_TYPE }}
+        run: |
+          build\tests\${{ matrix.config.BUILD_TYPE }}\spdlog-utests.exe

CMakeLists.txt

@@ -62,9 +62,6 @@ option(SPDLOG_ENABLE_PCH "Build static or shared library using precompiled heade
 # build position independent code
 option(SPDLOG_BUILD_PIC "Build position independent code (-fPIC)" OFF)
 
-# debug build postfix
-set(SPDLOG_DEBUG_POSTFIX "d" CACHE STRING "Filename postfix for libraries in debug builds")
-
 # example options
 option(SPDLOG_BUILD_EXAMPLE "Build example" ${SPDLOG_MASTER_PROJECT})
 option(SPDLOG_BUILD_EXAMPLE_HO "Build header only example" OFF)
@@ -194,7 +191,7 @@ spdlog_enable_warnings(spdlog)
 
 set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION
                                                                   ${SPDLOG_VERSION_MAJOR}.${SPDLOG_VERSION_MINOR})
-set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX ${SPDLOG_DEBUG_POSTFIX})
+set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX d)
 
 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)

README.md

@@ -80,7 +80,7 @@ int main()
     spdlog::info("Positional args are {1} {0}..", "too", "supported");
     spdlog::info("{:<30}", "left aligned");
     
-    spdlog::set_level(spdlog::level::debug); // Set *global* log level to debug
+    spdlog::set_level(spdlog::level::debug); // Set global log level to debug
     spdlog::debug("This message should be displayed..");    
     
     // change log pattern
@@ -241,29 +241,6 @@ void multi_sink_example()
 }
 ```
 
----
-#### Register several loggers - change global level
-```c++
-
-// Creation of loggers. Set levels to all registered loggers. 
-void set_level_example()
-{
-    auto logger1 = spdlog::basic_logger_mt("logger1", "logs/logger1.txt");
-    auto logger2 = spdlog::basic_logger_mt("logger2", "logs/logger2.txt");
-
-    spdlog::set_default_logger(logger2);
-    spdlog::default_logger()->set_level(spdlog::level::trace); // set level for the default logger (logger2) to trace
-
-    spdlog::trace("trace message to the logger2 (specified as default)");
-
-    spdlog::set_level(spdlog::level::off) // (sic!) set level for *all* registered loggers to off (disable)
-  
-    logger1.warn("warn message will not appear because the level set to off");
-    logger2.warn("warn message will not appear because the level set to off");
-    spdlog::warn("warn message will not appear because the level set to off");
-}
-```
-
 ---
 #### User-defined callbacks about log events
 ```c++
@@ -547,7 +524,6 @@ Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki)
 
 ---
 
-### Powered by
-<a href="https://jb.gg/OpenSource">
-  <img src="https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.svg" alt="JetBrains logo" width="200">
-</a>
+Thanks to [JetBrains](https://www.jetbrains.com/?from=spdlog) for donating product licenses to help develop **spdlog** <a href="https://www.jetbrains.com/?from=spdlog"><img src="logos/jetbrains-variant-4.svg" width="94" align="center" /></a>
+
+

example/example.cpp

@@ -33,7 +33,6 @@ void mdc_example();
 #include "spdlog/fmt/ostr.h"  // support for user defined types
 
 int main(int, char *[]) {
-    try {
     // Log levels can be loaded from argv/env using "SPDLOG_LEVEL"
     load_levels_example();
 
@@ -59,8 +58,8 @@ int main(int, char *[]) {
     spdlog::set_level(spdlog::level::info);
 
     // Backtrace support
-        // Loggers can store in a ring buffer all messages (including debug/trace) for later
-        // inspection. When needed, call dump_backtrace() to see what happened:
+    // Loggers can store in a ring buffer all messages (including debug/trace) for later inspection.
+    // When needed, call dump_backtrace() to see what happened:
     spdlog::enable_backtrace(10);  // create ring buffer with capacity of 10  messages
     for (int i = 0; i < 100; i++) {
         spdlog::debug("Backtrace message {}", i);  // not logged..
@@ -68,6 +67,7 @@ int main(int, char *[]) {
     // e.g. if some error happened:
     spdlog::dump_backtrace();  // log them now!
 
+    try {
         stdout_logger_example();
         basic_example();
         rotating_example();
@@ -371,13 +371,15 @@ void replace_default_logger_example() {
     // store the old logger so we don't break other examples.
     auto old_logger = spdlog::default_logger();
 
-    auto new_logger = spdlog::basic_logger_mt("new_default_logger", "logs/somelog.txt", true);
-    spdlog::set_default_logger(std::move(new_logger));
+    auto new_logger =
+        spdlog::basic_logger_mt("new_default_logger", "logs/new-default-log.txt", true);
+    spdlog::set_default_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(std::move(old_logger));
+
+    spdlog::set_default_logger(old_logger);
 }
 
 // Mapped Diagnostic Context (MDC) is a map that stores key-value pairs (string values) in thread

include/spdlog/cfg/helpers-inl.h

@@ -9,6 +9,7 @@
 
 #include <spdlog/details/os.h>
 #include <spdlog/details/registry.h>
+#include <spdlog/spdlog.h>
 
 #include <algorithm>
 #include <sstream>
@@ -35,7 +36,7 @@ inline std::string &trim_(std::string &str) {
     return str;
 }
 
-// return (name,value) trimmed pair from the given "name = value" string.
+// return (name,value) trimmed pair from given "name=value" string.
 // return empty string on missing parts
 // "key=val" => ("key", "val")
 // " key  =  val " => ("key", "val")
@@ -54,7 +55,7 @@ inline std::pair<std::string, std::string> extract_kv_(char sep, const std::stri
     return std::make_pair(trim_(k), trim_(v));
 }
 
-// return vector of key/value pairs from a sequence of "K1=V1,K2=V2,.."
+// return vector of key/value pairs from sequence of "K1=V1,K2=V2,.."
 // "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...}
 inline std::unordered_map<std::string, std::string> extract_key_vals_(const std::string &str) {
     std::string token;
@@ -71,7 +72,7 @@ inline std::unordered_map<std::string, std::string> extract_key_vals_(const std:
 }
 
 SPDLOG_INLINE void load_levels(const std::string &input) {
-    if (input.empty() || input.size() >= 32768) {
+    if (input.empty() || input.size() > 512) {
         return;
     }
 
@@ -81,14 +82,14 @@ SPDLOG_INLINE void load_levels(const std::string &input) {
     bool global_level_found = false;
 
     for (auto &name_level : key_vals) {
-        const auto &logger_name = name_level.first;
-        const auto &level_name = to_lower_(name_level.second);
+        auto &logger_name = name_level.first;
+        auto level_name = to_lower_(name_level.second);
         auto level = level::from_str(level_name);
         // ignore unrecognized level names
         if (level == level::off && level_name != "off") {
             continue;
         }
-        if (logger_name.empty())  // no logger name indicates global level
+        if (logger_name.empty())  // no logger name indicate global level
         {
             global_level_found = true;
             global_level = level;

include/spdlog/details/file_helper-inl.h

@@ -11,8 +11,10 @@
 #include <spdlog/details/os.h>
 
 #include <cerrno>
+#include <chrono>
 #include <cstdio>
 #include <string>
+#include <thread>
 #include <tuple>
 
 namespace spdlog {

include/spdlog/details/os-inl.h

@@ -23,6 +23,7 @@
 
 #ifdef _WIN32
     #include <spdlog/details/windows_include.h>
+    #include <fileapi.h>  // for FlushFileBuffers
     #include <io.h>       // for _get_osfhandle, _isatty, _fileno
     #include <process.h>  // for _get_pid
 
@@ -562,21 +563,21 @@ SPDLOG_INLINE filename_t dir_name(const filename_t &path) {
     return pos != filename_t::npos ? path.substr(0, pos) : filename_t{};
 }
 
-#ifdef _MSC_VER
-    #pragma warning(push)
-    #pragma warning(disable : 4996)
-#endif  // _MSC_VER
 std::string SPDLOG_INLINE getenv(const char *field) {
-#if defined(_MSC_VER) && defined(__cplusplus_winrt)
+#if defined(_MSC_VER)
+    #if defined(__cplusplus_winrt)
     return std::string{};  // not supported under uwp
-#else
-    char *buf = std::getenv(field);
+    #else
+    size_t len = 0;
+    char buf[128];
+    bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0;
+    return ok ? buf : std::string{};
+    #endif
+#else  // revert to getenv
+    char *buf = ::getenv(field);
     return buf ? buf : std::string{};
 #endif
 }
-#ifdef _MSC_VER
-    #pragma warning(pop)
-#endif  // _MSC_VER
 
 // Do fsync by FILE handlerpointer
 // Return true on success

include/spdlog/details/registry-inl.h

@@ -101,7 +101,7 @@ SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger() {
 SPDLOG_INLINE logger *registry::get_default_raw() { return default_logger_.get(); }
 
 // set default logger.
-// the default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
+// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
 SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger) {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);
     if (new_default_logger != nullptr) {

include/spdlog/details/tcp_client-windows.h

@@ -58,81 +58,8 @@ public:
 
     SOCKET fd() const { return socket_; }
 
-    int connect_socket_with_timeout(SOCKET sockfd,
-                                    const struct sockaddr *addr,
-                                    int addrlen,
-                                    const timeval &tv) {
-        // If no timeout requested, do a normal blocking connect.
-        if (tv.tv_sec == 0 && tv.tv_usec == 0) {
-            int rv = ::connect(sockfd, addr, addrlen);
-            if (rv == SOCKET_ERROR && WSAGetLastError() == WSAEISCONN) {
-                return 0;
-            }
-            return rv;
-        }
-
-        // Switch to non‐blocking mode
-        u_long mode = 1UL;
-        if (::ioctlsocket(sockfd, FIONBIO, &mode) == SOCKET_ERROR) {
-            return SOCKET_ERROR;
-        }
-
-        int rv = ::connect(sockfd, addr, addrlen);
-        int last_error = WSAGetLastError();
-        if (rv == 0 || last_error == WSAEISCONN) {
-            mode = 0UL;
-            if (::ioctlsocket(sockfd, FIONBIO, &mode) == SOCKET_ERROR) {
-                return SOCKET_ERROR;
-            }
-            return 0;
-        }
-        if (last_error != WSAEWOULDBLOCK) {
-            // Real error
-            mode = 0UL;
-            if (::ioctlsocket(sockfd, FIONBIO, &mode)) {
-                return SOCKET_ERROR;
-            }
-            return SOCKET_ERROR;
-        }
-
-        // Wait until socket is writable or timeout expires
-        fd_set wfds;
-        FD_ZERO(&wfds);
-        FD_SET(sockfd, &wfds);
-
-        rv = ::select(0, nullptr, &wfds, nullptr, const_cast<timeval *>(&tv));
-
-        // Restore blocking mode regardless of select result
-        mode = 0UL;
-        if (::ioctlsocket(sockfd, FIONBIO, &mode) == SOCKET_ERROR) {
-            return SOCKET_ERROR;
-        }
-
-        if (rv == 0) {
-            WSASetLastError(WSAETIMEDOUT);
-            return SOCKET_ERROR;
-        }
-        if (rv == SOCKET_ERROR) {
-            return SOCKET_ERROR;
-        }
-
-        int so_error = 0;
-        int len = sizeof(so_error);
-        if (::getsockopt(sockfd, SOL_SOCKET, SO_ERROR, reinterpret_cast<char *>(&so_error), &len) ==
-            SOCKET_ERROR) {
-            return SOCKET_ERROR;
-        }
-        if (so_error != 0 && so_error != WSAEISCONN) {
-            // connection failed
-            WSASetLastError(so_error);
-            return SOCKET_ERROR;
-        }
-
-        return 0;  // success
-    }
-
     // try to connect or throw on failure
-    void connect(const std::string &host, int port, int timeout_ms = 0) {
+    void connect(const std::string &host, int port) {
         if (is_connected()) {
             close();
         }
@@ -144,10 +71,6 @@ public:
         hints.ai_flags = AI_NUMERICSERV;  // port passed as as numeric value
         hints.ai_protocol = 0;
 
-        timeval tv;
-        tv.tv_sec = timeout_ms / 1000;
-        tv.tv_usec = (timeout_ms % 1000) * 1000;
-
         auto port_str = std::to_string(port);
         struct addrinfo *addrinfo_result;
         auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
@@ -159,6 +82,7 @@ public:
         }
 
         // Try each address until we successfully connect(2).
+
         for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next) {
             socket_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
             if (socket_ == INVALID_SOCKET) {
@@ -166,24 +90,18 @@ public:
                 WSACleanup();
                 continue;
             }
-            if (connect_socket_with_timeout(socket_, rp->ai_addr, (int)rp->ai_addrlen, tv) == 0) {
-                last_error = 0;
+            if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0) {
                 break;
+            } else {
+                last_error = ::WSAGetLastError();
+                close();
             }
-            last_error = WSAGetLastError();
-            ::closesocket(socket_);
-            socket_ = INVALID_SOCKET;
         }
         ::freeaddrinfo(addrinfo_result);
         if (socket_ == INVALID_SOCKET) {
             WSACleanup();
             throw_winsock_error_("connect failed", last_error);
         }
-        if (timeout_ms > 0) {
-            DWORD tv = static_cast<DWORD>(timeout_ms);
-            ::setsockopt(socket_, SOL_SOCKET, SO_RCVTIMEO, (const char *)&tv, sizeof(tv));
-            ::setsockopt(socket_, SOL_SOCKET, SO_SNDTIMEO, (const char *)&tv, sizeof(tv));
-        }
 
         // set TCP_NODELAY
         int enable_flag = 1;

include/spdlog/details/tcp_client.h

@@ -39,72 +39,8 @@ public:
 
     ~tcp_client() { close(); }
 
-    int connect_socket_with_timeout(int sockfd,
-                                    const struct sockaddr *addr,
-                                    socklen_t addrlen,
-                                    const timeval &tv) {
-        // Blocking connect if timeout is zero
-        if (tv.tv_sec == 0 && tv.tv_usec == 0) {
-            int rv = ::connect(sockfd, addr, addrlen);
-            if (rv < 0 && errno == EISCONN) {
-                // already connected, treat as success
-                return 0;
-            }
-            return rv;
-        }
-
-        // Non-blocking path
-        int orig_flags = ::fcntl(sockfd, F_GETFL, 0);
-        if (orig_flags < 0) {
-            return -1;
-        }
-        if (::fcntl(sockfd, F_SETFL, orig_flags | O_NONBLOCK) < 0) {
-            return -1;
-        }
-
-        int rv = ::connect(sockfd, addr, addrlen);
-        if (rv == 0 || (rv < 0 && errno == EISCONN)) {
-            // immediate connect or already connected
-            ::fcntl(sockfd, F_SETFL, orig_flags);
-            return 0;
-        }
-        if (errno != EINPROGRESS) {
-            ::fcntl(sockfd, F_SETFL, orig_flags);
-            return -1;
-        }
-
-        // wait for writability
-        fd_set wfds;
-        FD_ZERO(&wfds);
-        FD_SET(sockfd, &wfds);
-
-        struct timeval tv_copy = tv;
-        rv = ::select(sockfd + 1, nullptr, &wfds, nullptr, &tv_copy);
-        if (rv <= 0) {
-            // timeout or error
-            ::fcntl(sockfd, F_SETFL, orig_flags);
-            if (rv == 0) errno = ETIMEDOUT;
-            return -1;
-        }
-
-        // check socket error
-        int so_error = 0;
-        socklen_t len = sizeof(so_error);
-        if (::getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &so_error, &len) < 0) {
-            ::fcntl(sockfd, F_SETFL, orig_flags);
-            return -1;
-        }
-        ::fcntl(sockfd, F_SETFL, orig_flags);
-        if (so_error != 0 && so_error != EISCONN) {
-            errno = so_error;
-            return -1;
-        }
-
-        return 0;
-    }
-
     // try to connect or throw on failure
-    void connect(const std::string &host, int port, int timeout_ms = 0) {
+    void connect(const std::string &host, int port) {
         close();
         struct addrinfo hints {};
         memset(&hints, 0, sizeof(struct addrinfo));
@@ -113,10 +49,6 @@ public:
         hints.ai_flags = AI_NUMERICSERV;  // port passed as as numeric value
         hints.ai_protocol = 0;
 
-        struct timeval tv;
-        tv.tv_sec = timeout_ms / 1000;
-        tv.tv_usec = (timeout_ms % 1000) * 1000;
-
         auto port_str = std::to_string(port);
         struct addrinfo *addrinfo_result;
         auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
@@ -137,9 +69,8 @@ public:
                 last_errno = errno;
                 continue;
             }
-            ::fcntl(socket_, F_SETFD, FD_CLOEXEC);
-            if (connect_socket_with_timeout(socket_, rp->ai_addr, rp->ai_addrlen, tv) == 0) {
-                last_errno = 0;
+            rv = ::connect(socket_, rp->ai_addr, rp->ai_addrlen);
+            if (rv == 0) {
                 break;
             }
             last_errno = errno;
@@ -151,12 +82,6 @@ public:
             throw_spdlog_ex("::connect failed", last_errno);
         }
 
-        if (timeout_ms > 0) {
-            // Set timeouts for send and recv
-            ::setsockopt(socket_, SOL_SOCKET, SO_RCVTIMEO, (const char *)&tv, sizeof(tv));
-            ::setsockopt(socket_, SOL_SOCKET, SO_SNDTIMEO, (const char *)&tv, sizeof(tv));
-        }
-
         // set TCP_NODELAY
         int enable_flag = 1;
         ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&enable_flag),

include/spdlog/details/thread_pool-inl.h

@@ -35,7 +35,7 @@ SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,
 SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items,
                                        size_t threads_n,
                                        std::function<void()> on_thread_start)
-    : thread_pool(q_max_items, threads_n, std::move(on_thread_start), [] {}) {}
+    : thread_pool(q_max_items, threads_n, on_thread_start, [] {}) {}
 
 SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
     : thread_pool(q_max_items, threads_n, [] {}, [] {}) {}
@@ -94,7 +94,8 @@ void SPDLOG_INLINE thread_pool::worker_loop_() {
 }
 
 // process next message in the queue
-// returns true if this thread should still be active (while no terminated msg was received)
+// return true if this thread should still be active (while no terminate msg
+// was received)
 bool SPDLOG_INLINE thread_pool::process_next_msg_() {
     async_msg incoming_async_msg;
     q_.dequeue(incoming_async_msg);

include/spdlog/fmt/fmt.h

@@ -20,7 +20,11 @@
     #ifndef FMT_USE_WINDOWS_H
         #define FMT_USE_WINDOWS_H 0
     #endif
+
+    #include <spdlog/fmt/bundled/base.h>
     #include <spdlog/fmt/bundled/format.h>
+
 #else  // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib
+    #include <fmt/base.h>
     #include <fmt/format.h>
 #endif

include/spdlog/logger-inl.h

@@ -57,7 +57,7 @@ SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT {
     std::swap(tracer_, other.tracer_);
 }
 
-SPDLOG_INLINE void swap(logger &a, logger &b) noexcept { a.swap(b); }
+SPDLOG_INLINE void swap(logger &a, logger &b) { a.swap(b); }
 
 SPDLOG_INLINE void logger::set_level(level::level_enum log_level) { level_.store(log_level); }
 
@@ -163,12 +163,12 @@ SPDLOG_INLINE void logger::dump_backtrace_() {
     }
 }
 
-SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) const {
+SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) {
     auto flush_level = flush_level_.load(std::memory_order_relaxed);
     return (msg.level >= flush_level) && (msg.level != level::off);
 }
 
-SPDLOG_INLINE void logger::err_handler_(const std::string &msg) const {
+SPDLOG_INLINE void logger::err_handler_(const std::string &msg) {
     if (custom_err_handler_) {
         custom_err_handler_(msg);
     } else {

include/spdlog/logger.h

@@ -363,14 +363,14 @@ protected:
     virtual void sink_it_(const details::log_msg &msg);
     virtual void flush_();
     void dump_backtrace_();
-    bool should_flush_(const details::log_msg &msg) const;
+    bool should_flush_(const details::log_msg &msg);
 
     // handle errors during logging.
     // default handler prints the error to stderr at max rate of 1 message/sec.
-    void err_handler_(const std::string &msg) const;
+    void err_handler_(const std::string &msg);
 };
 
-void swap(logger &a, logger &b) noexcept;
+void swap(logger &a, logger &b);
 
 }  // namespace spdlog
 

include/spdlog/sinks/ansicolor_sink.h

@@ -40,7 +40,7 @@ public:
 
     void log(const details::log_msg &msg) override;
     void flush() override;
-    void set_pattern(const std::string &pattern) override;
+    void set_pattern(const std::string &pattern) final override;
     void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;
 
     // Formatting codes

include/spdlog/sinks/ringbuffer_sink.h

@@ -21,11 +21,7 @@ template <typename Mutex>
 class ringbuffer_sink final : public base_sink<Mutex> {
 public:
     explicit ringbuffer_sink(size_t n_items)
-        : q_{n_items} {
-        if (n_items == 0) {
-            throw_spdlog_ex("ringbuffer_sink: n_items cannot be zero");
-        }
-    }
+        : q_{n_items} {}
 
     std::vector<details::log_msg_buffer> last_raw(size_t lim = 0) {
         std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);

include/spdlog/sinks/tcp_sink.h

@@ -31,7 +31,6 @@ namespace sinks {
 struct tcp_sink_config {
     std::string server_host;
     int server_port;
-    int timeout_ms = 0; // The timeout for all 3 major socket operations that is connect, send, and recv
     bool lazy_connect = false;  // if true connect on first log call instead of on construction
 
     tcp_sink_config(std::string host, int port)
@@ -45,22 +44,10 @@ public:
     // connect to tcp host/port or throw if failed
     // host can be hostname or ip address
 
-    explicit tcp_sink(const std::string &host,
-                      int port,
-                      int timeout_ms = 0,
-                      bool lazy_connect = false)
-        : config_{host, port} {
-        config_.timeout_ms = timeout_ms;
-        config_.lazy_connect = lazy_connect;
-        if (!config_.lazy_connect) {
-            client_.connect(config_.server_host, config_.server_port, config_.timeout_ms);
-        }
-    }
-
     explicit tcp_sink(tcp_sink_config sink_config)
         : config_{std::move(sink_config)} {
         if (!config_.lazy_connect) {
-            client_.connect(config_.server_host, config_.server_port, config_.timeout_ms);
+            this->client_.connect(config_.server_host, config_.server_port);
         }
     }
 
@@ -71,7 +58,7 @@ protected:
         spdlog::memory_buf_t formatted;
         spdlog::sinks::base_sink<Mutex>::formatter_->format(msg, formatted);
         if (!client_.is_connected()) {
-            client_.connect(config_.server_host, config_.server_port, config_.timeout_ms);
+            client_.connect(config_.server_host, config_.server_port);
         }
         client_.send(formatted.data(), formatted.size());
     }

include/spdlog/sinks/wincolor_sink.h

@@ -31,10 +31,10 @@ public:
 
     // change the color for the given level
     void set_color(level::level_enum level, std::uint16_t color);
-    void log(const details::log_msg &msg) override;
-    void flush() override;
-    void set_pattern(const std::string &pattern) override;
-    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;
+    void log(const details::log_msg &msg) final override;
+    void flush() final override;
+    void set_pattern(const std::string &pattern) override final;
+    void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override final;
     void set_color_mode(color_mode mode);
 
 protected:

include/spdlog/spdlog.h

@@ -95,7 +95,7 @@ SPDLOG_API void set_error_handler(void (*handler)(const std::string &msg));
 SPDLOG_API void register_logger(std::shared_ptr<logger> logger);
 
 // Register the given logger with the given name
-// Will replace any existing logger with the same name.
+// Will replace any the existing logger with the same name if exists.
 SPDLOG_API void register_or_replace(std::shared_ptr<logger> logger);
 
 // Apply a user-defined function on all registered loggers

include/spdlog/version.h

@@ -5,7 +5,7 @@
 
 #define SPDLOG_VER_MAJOR 1
 #define SPDLOG_VER_MINOR 15
-#define SPDLOG_VER_PATCH 3
+#define SPDLOG_VER_PATCH 2
 
 #define SPDLOG_TO_VERSION(major, minor, patch) (major * 10000 + minor * 100 + patch)
 #define SPDLOG_VERSION SPDLOG_TO_VERSION(SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH)

tests/CMakeLists.txt

@@ -49,8 +49,7 @@ set(SPDLOG_UTESTS_SOURCES
     test_time_point.cpp
     test_stopwatch.cpp
     test_circular_q.cpp
-    test_bin_to_hex.cpp
-    test_ringbuffer.cpp)
+    test_bin_to_hex.cpp)
 
 if(NOT SPDLOG_NO_EXCEPTIONS)
     list(APPEND SPDLOG_UTESTS_SOURCES test_errors.cpp)
@@ -75,7 +74,7 @@ function(spdlog_prepare_test test_target spdlog_lib)
     elseif(SPDLOG_SANITIZE_THREAD)
         spdlog_enable_thread_sanitizer(${test_target})
     endif()
-    add_test(NAME ${test_target} COMMAND ${test_target} --order decl)
+    add_test(NAME ${test_target} COMMAND ${test_target})
     set_tests_properties(${test_target} PROPERTIES RUN_SERIAL ON)
 endfunction()
 

tests/test_ringbuffer.cpp

@@ -1,53 +0,0 @@
-#include "includes.h"
-#include "spdlog/sinks/ringbuffer_sink.h"
-
-TEST_CASE("ringbuffer invalid size", "[ringbuffer]") {
-    REQUIRE_THROWS_AS(spdlog::sinks::ringbuffer_sink_mt(0), spdlog::spdlog_ex);
-}
-
-TEST_CASE("ringbuffer stores formatted messages", "[ringbuffer]") {
-    spdlog::sinks::ringbuffer_sink_st sink(3);
-    sink.set_pattern("%v");
-
-    sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "msg1"});
-    sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "msg2"});
-    sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "msg3"});
-
-    auto formatted = sink.last_formatted();
-    REQUIRE(formatted.size() == 3);
-    using spdlog::details::os::default_eol;
-    REQUIRE(formatted[0] == spdlog::fmt_lib::format("msg1{}", default_eol));
-    REQUIRE(formatted[1] == spdlog::fmt_lib::format("msg2{}", default_eol));
-    REQUIRE(formatted[2] == spdlog::fmt_lib::format("msg3{}", default_eol));
-}
-
-TEST_CASE("ringbuffer overrun keeps last items", "[ringbuffer]") {
-    spdlog::sinks::ringbuffer_sink_st sink(2);
-    sink.set_pattern("%v");
-
-    sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "first"});
-    sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "second"});
-    sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "third"});
-
-    auto formatted = sink.last_formatted();
-    REQUIRE(formatted.size() == 2);
-    using spdlog::details::os::default_eol;
-    REQUIRE(formatted[0] == spdlog::fmt_lib::format("second{}", default_eol));
-    REQUIRE(formatted[1] == spdlog::fmt_lib::format("third{}", default_eol));
-}
-
-TEST_CASE("ringbuffer retrieval limit", "[ringbuffer]") {
-    spdlog::sinks::ringbuffer_sink_st sink(3);
-    sink.set_pattern("%v");
-
-    sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "A"});
-    sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "B"});
-    sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "C"});
-
-    auto formatted = sink.last_formatted(2);
-    REQUIRE(formatted.size() == 2);
-    using spdlog::details::os::default_eol;
-    REQUIRE(formatted[0] == spdlog::fmt_lib::format("B{}", default_eol));
-    REQUIRE(formatted[1] == spdlog::fmt_lib::format("C{}", default_eol));
-}
-

tests/test_stopwatch.cpp

@@ -5,7 +5,7 @@
 TEST_CASE("stopwatch1", "[stopwatch]") {
     using std::chrono::milliseconds;
     using clock = std::chrono::steady_clock;
-    milliseconds wait_ms(500);
+    milliseconds wait_ms(200);
     milliseconds tolerance_ms(250);
     auto start = clock::now();
     spdlog::stopwatch sw;
@@ -22,7 +22,7 @@ TEST_CASE("stopwatch2", "[stopwatch]") {
     using std::chrono::milliseconds;
     using clock = std::chrono::steady_clock;
 
-    clock::duration wait_duration(milliseconds(500));
+    clock::duration wait_duration(milliseconds(200));
     clock::duration tolerance_duration(milliseconds(250));
 
     auto test_sink = std::make_shared<test_sink_st>();