Expand ringbuffer sink tests

.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
@@ -224,7 +224,7 @@ void binary_example()
 ```c++
 
 // create a logger with 2 targets, with different log levels and formats.
-// The console will show only warnings or errors, while the file will log all. 
+// The console will show only warnings or errors, while the file will log all.
 void multi_sink_example()
 {
     auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
@@ -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++

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
 

include/spdlog/details/tcp_client-windows.h

@@ -57,82 +57,9 @@ 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/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());
     }

tests/CMakeLists.txt

@@ -75,7 +75,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

@@ -15,10 +15,9 @@ TEST_CASE("ringbuffer stores formatted messages", "[ringbuffer]") {
 
     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));
+    REQUIRE(formatted[0] == "msg1");
+    REQUIRE(formatted[1] == "msg2");
+    REQUIRE(formatted[2] == "msg3");
 }
 
 TEST_CASE("ringbuffer overrun keeps last items", "[ringbuffer]") {
@@ -31,9 +30,8 @@ TEST_CASE("ringbuffer overrun keeps last items", "[ringbuffer]") {
 
     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));
+    REQUIRE(formatted[0] == "second");
+    REQUIRE(formatted[1] == "third");
 }
 
 TEST_CASE("ringbuffer retrieval limit", "[ringbuffer]") {
@@ -46,8 +44,7 @@ TEST_CASE("ringbuffer retrieval limit", "[ringbuffer]") {
 
     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));
+    REQUIRE(formatted[0] == "B");
+    REQUIRE(formatted[1] == "C");
 }