Migrate logging from spdlog to slick_logger

- Replace spdlog with slick_logger via FetchContent for better integration
- Update slick_queue handling and remove obsolete cmake/slick_queue.cmake
- Enhance Windows shared memory security with session-isolated names
- Bump version to 1.1.0.0 and update CHANGELOG, README.md, and build files
- Refactor includes and dependencies in source files for consistency

Author: kzhdev

CHANGELOG

@@ -1,3 +1,10 @@
+1.1.0.0 - [8/29/2025]
+- Replace spdlog with slick_logger via FetchContent for better integration
+- Update slick_queue handling and remove obsolete cmake/slick_queue.cmake
+- Enhance Windows shared memory security with session-isolated names
+- Bump version to 1.1.0.0 and update CHANGELOG, README.md, and build files
+- Refactor includes and dependencies in source files for consistency
+
 1.0.0.3
 - Rotate log file
 

CMakeLists.txt

@@ -23,34 +23,40 @@ if (CMAKE_BUILD_TYPE MATCHES Release)
 endif()
 
 set(Boost_USE_STATIC_LIBS ON)
-find_package(Boost REQUIRED COMPONENTS beast context)
+find_package(Boost CONFIG REQUIRED COMPONENTS beast context)
 
 set(OPENSSL_USE_STATIC_LIBS TRUE)
 set(OPENSSL_MSVC_STATIC_RT TRUE)
 find_package(OpenSSL REQUIRED)
 
-find_package(spdlog REQUIRED CONFIG)
-add_definitions(-DSPDLOG_USE_STD_FORMAT -DSPDLOG_USE_STD_FORMAT_HO)
-
-include(cmake/slick_queue.cmake)
+include(FetchContent)
+# Disable examples, tests, and benchmarks for slick_logger
+set(BUILD_SLICK_LOGGER_EXAMPLES OFF CACHE BOOL "" FORCE)
+set(BUILD_SLICK_LOGGER_TESTING OFF CACHE BOOL "" FORCE)
+set(BUILD_SLICK_LOGGER_BENCHMARKS OFF CACHE BOOL "" FORCE)
+FetchContent_Declare(
+    slick_logger
+    GIT_REPOSITORY https://github.com/SlickTech/slick_logger.git
+    GIT_TAG main
+)
+FetchContent_MakeAvailable(slick_logger)
 
+message(STATUS "Slick Queue: ${slick_queue_SOURCE_DIR}")
+message(STATUS "Slick Logger: ${slick_logger_SOURCE_DIR}")
 message(STATUS "OpenSSL: ${OPENSSL_INCLUDE_DIR}")
 message(STATUS "Beast: ${boost_beast_CONFIG}")
-message(STATUS "spdlog: ${spdlog_CONFIG}")
 
 set(RELEASE_DIR "${CMAKE_CURRENT_BINARY_DIR}/dist")
 configure_file(src/version.h.in dist/include/websocket_proxy/version.h)
 
 set(SOURCES
-    # src/pch.cpp
     src/main.cpp
     src/websocket_proxy.cpp
 )
 
 add_executable(websocket_proxy ${SOURCES})
-target_include_directories(websocket_proxy PUBLIC include ${slick_queue_SOURCE_DIR}/include ${RELEASE_DIR}/include)
-target_link_libraries(websocket_proxy PRIVATE spdlog::spdlog_header_only Boost::asio Boost::beast Boost::context OpenSSL::SSL OpenSSL::Crypto)
-target_link_libraries(websocket_proxy PRIVATE ${VCPKG_ROOT})
+target_include_directories(websocket_proxy PUBLIC include ${RELEASE_DIR}/include)
+target_link_libraries(websocket_proxy PRIVATE slick_queue slick_logger Boost::asio Boost::beast Boost::context OpenSSL::SSL OpenSSL::Crypto)
 # target_precompile_headers(websocket_proxy PRIVATE "src/pch.hpp")
 
 if (MSVC)
@@ -65,7 +71,7 @@ if (MSVC)
     target_compile_options(websocket_proxy PRIVATE "/bigobj")
     set_target_properties(websocket_proxy PROPERTIES MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 else()
-    set(CMAKE_CXX_FLAGS_RELEASE "-O3")
+    set(CMAKE_CXX_FLAGS_RELEASE "-O3 -march=native -flto")
 endif()
 
 if (CMAKE_BUILD_TYPE MATCHES Release)
@@ -80,4 +86,10 @@ if (CMAKE_BUILD_TYPE MATCHES Release)
     )
 endif()
 
-add_subdirectory(example EXLCUDE_FROM_ALL)
+option(BUILD_EXAMPLE "Build example" ON)
+if(BUILD_EXAMPLE)
+    message(STATUS "Building example")
+    add_subdirectory(example)
+else()
+    message(STATUS "Skipping example")
+endif()

README.md

@@ -33,7 +33,6 @@ WebsocketProxy relies on several external libraries. You can install these depen
 
 2. **Install Required Libraries**:
     ```sh
-    ./vcpkg install spdlog:x64-windows-static
     ./vcpkg install boost-beast:x64-windows-static
     ./vcpkg install openssl:x64-windows-static
     ```

cmake/slick_queue.cmake

@@ -17,11 +17,11 @@
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.#pragma once
+// SOFTWARE.
 
 #pragma once
 
-#include "slick_queue.h"
+#include <slick_queue/slick_queue.h>
 #include <atomic>
 #include <chrono>
 
@@ -38,7 +38,7 @@ namespace websocket_proxy {
 #pragma pack(1)
 struct Message {
     enum Type : uint8_t {
-        Regster,
+        Register,
         Unregister,
         OpenWs,
         CloseWs,
@@ -48,6 +48,7 @@ struct Message {
         WsError,
         Subscribe,
         Unsubscribe,
+        LogLevel,
     };
 
     enum Status : uint8_t {
@@ -117,6 +118,21 @@ struct WsData {
     uint32_t remaining;
     char data[0];
 };
+
+struct LogLevel {
+    enum level_enum : uint8_t {
+        trace = 0,
+        debug = 1,
+        info = 2,
+        warn = 3,
+        err = 4,
+        critical = 5,
+        off = 6,
+        n_levels
+    };
+
+    level_enum level;
+};
 #pragma pack()
 #pragma warning( pop )
 

include/websocket_proxy/types.h

@@ -67,12 +67,13 @@ class WebsocketProxyClient {
     bool closeWebSocket(uint64_t id = 0);
     bool subscribe(uint64_t id, const std::string& symbol, const char* subscription_request, uint32_t request_len, SubscriptionType type, bool& existing);
     bool unsubscribe(uint64_t id, const std::string& symbol, const char* unsubscription_request, uint32_t request_len);
+    bool setLogLevel(LogLevel::level_enum level);
     void send(uint64_t id, const char* msg, uint32_t len);
 
 private:
     bool connect();
     bool spawnWebsocketsProxyServer();
-    void waitForServerReady();
+    bool waitForServerReady();
     bool _register();
     void unregister();
     void sendMessage(Message* msg, uint64_t index, uint32_t size);
@@ -192,8 +193,12 @@ inline bool WebsocketProxyClient::connect() {
         return false;
     }
 
-    waitForServerReady();
-    return _register();
+    if (server_queue_index_ != 0 || waitForServerReady())
+    {
+        return _register();
+    }
+    callback_->logError([]() { return "Failed to connect to websocket proxy server"; });
+    return false;
 }
 
 inline void WebsocketProxyClient::sendMessage(Message* msg, uint64_t index, uint32_t size) {
@@ -247,7 +252,8 @@ inline bool WebsocketProxyClient::spawnWebsocketsProxyServer() {
             server_queue_ = std::make_unique<SHM_QUEUE_T>(SERVER_TO_CLIENT_QUEUE);
             break;
         }
-        catch (const std::runtime_error&) {
+        catch (const std::runtime_error &e) {
+            callback_->logError([&e]() { return e.what(); });
             std::this_thread::sleep_for(std::chrono::seconds(1));
         }
     }
@@ -269,22 +275,24 @@ inline bool WebsocketProxyClient::spawnWebsocketsProxyServer() {
     return true;
 }
 
-inline void WebsocketProxyClient::waitForServerReady()
+inline bool WebsocketProxyClient::waitForServerReady()
 {
     auto start = get_timestamp();
     while ((get_timestamp() - start) < 10000) {
         auto result = server_queue_->read(server_queue_index_);
         if (result.first) {
-            break;
+            return true;
         }
     }
+    return false;
 }
 
 inline bool WebsocketProxyClient::_register() {
     auto [msg, index, size] = reserveMessage<RegisterMessage>();
-    msg->type = Message::Type::Regster;
+    msg->type = Message::Type::Register;
     auto reg = reinterpret_cast<RegisterMessage*>(msg->data);
-    strcpy_s(reg->name, 32, name_.c_str());
+    strcpy_s(reg->name, 31, name_.c_str());
+    reg->name[31] = 0;
     sendMessage(msg, index, size);
     if (!waitForResponse(msg, 20000)) {
         callback_->logError([]() { return "Unable to connect to websocket_proxy. timeout"; });
@@ -402,6 +410,15 @@ inline bool WebsocketProxyClient::unsubscribe(uint64_t id, const std::string& sy
     return true;
 }
 
+inline bool WebsocketProxyClient::setLogLevel(LogLevel::level_enum level) {
+    auto [msg, index, size] = reserveMessage<LogLevel>();
+    msg->type = Message::Type::LogLevel;
+    auto req = reinterpret_cast<LogLevel*>(msg->data);
+    req->level = level;
+    sendMessage(msg, index, size);
+    return true;
+}
+
 inline void WebsocketProxyClient::send(uint64_t id, const char* data, uint32_t len) {
     auto [msg, index, size] = reserveMessage<WsRequest>(len);
     msg->type = Message::Type::WsRequest;

include/websocket_proxy/websocket_proxy_client.h

@@ -21,9 +21,6 @@
 
 #include "pch.hpp"
 
-#ifdef DEBUG
-#include <spdlog/sinks/stdout_color_sinks.h>
-#endif
 #include "websocket_proxy.h"
 #include <websocket_proxy/version.h>
 #include <csignal>
@@ -33,11 +30,7 @@
 #endif
 
 using namespace websocket_proxy;
-
-void atexit_hanlder()
-{
-    spdlog::shutdown();
-}
+using namespace slick_logger;
 
 /**
 * Usage:
@@ -50,20 +43,19 @@ void atexit_hanlder()
 */
 int main(int argc, char* argv[])
 {
-    std::atexit(atexit_hanlder);
-    spdlog::init_thread_pool(8192, 1);
+    Logger::instance().clear_sinks();
+    LogConfig config;
+    config.queue_size = 65536;
+
 #ifdef DEBUG
-    auto stdout_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("./log/WebsocketProxy.log");
-    std::vector<spdlog::sink_ptr> sinks {stdout_sink, file_sink};
-    auto logger = std::make_shared<spdlog::async_logger>("websocket_proxy_logger", sinks.begin(), sinks.end(), spdlog::thread_pool(), spdlog::async_overflow_policy::overrun_oldest);
-    spdlog::set_default_logger(logger);
-    spdlog::flush_on(spdlog::level::trace);
-#else
-    auto async_sink = std::make_shared<spdlog::sinks::rotating_file_sink_mt>("./Log/WebsocketProxy.log", 524288000, 5);
-    auto async_logger = std::make_shared<spdlog::async_logger>("async_logger", async_sink, spdlog::thread_pool(), spdlog::async_overflow_policy::overrun_oldest);
-    spdlog::set_default_logger(async_logger);
+    config.sinks.push_back(std::make_shared<ConsoleSink>(true, true));
+    config.min_level = slick_logger::LogLevel::L_TRACE;
 #endif
+    // Configure rotation
+    RotationConfig rotation;
+    rotation.max_file_size = 200 * 1024 * 1024;  // 200MB
+    rotation.max_files = 10;                     // keep last 10 files
+    config.sinks.push_back(std::make_shared<RotatingFileSink>("./Log/WebsocketProxy.log", rotation));
 
     uint32_t server_queue_size = 1 << 24;   // 16MB
     [[maybe_unused]] bool log_level_set = false;
@@ -73,28 +65,25 @@ int main(int argc, char* argv[])
             std::transform(l.begin(), l.end(), l.begin(), [](char c){ return std::tolower(c); });
             log_level_set = true;
             if (l == "off") {
-                spdlog::set_level(spdlog::level::off);
+                config.min_level = slick_logger::LogLevel::L_OFF;
             }
             else if (l == "critical") {
-                spdlog::set_level(spdlog::level::critical);
-                spdlog::flush_on(spdlog::level::critical);
+                config.min_level = slick_logger::LogLevel::L_FATAL;
             }
             else if (l == "error") {
-                spdlog::set_level(spdlog::level::err);
-                spdlog::flush_on(spdlog::level::err);
+                config.min_level = slick_logger::LogLevel::L_ERROR;
             }
             else if (l == "warning") {
-                spdlog::set_level(spdlog::level::warn);
-                spdlog::flush_on(spdlog::level::warn);
+                config.min_level = slick_logger::LogLevel::L_WARN;
             }
             else if (l == "info") {
-                spdlog::set_level(spdlog::level::info);
+                config.min_level = slick_logger::LogLevel::L_INFO;
             }
             else if (l == "debug") {
-                spdlog::set_level(spdlog::level::debug);
+                config.min_level = slick_logger::LogLevel::L_DEBUG;
             }
             else if (l == "trace") {
-                spdlog::set_level(spdlog::level::trace);
+                config.min_level = slick_logger::LogLevel::L_TRACE;
             }
             else {
                 log_level_set = false;
@@ -105,18 +94,10 @@ int main(int argc, char* argv[])
         }
     }
 
-#ifdef DEBUG
-    if (!log_level_set) {
-        spdlog::set_level(spdlog::level::trace);
-    }
-#endif
-
-    spdlog::set_pattern("[%Y-%m-%d %H:%M:%S.%F][%t][%l][%s:%#] %v");
-    spdlog::flush_every(std::chrono::seconds(2));
+    Logger::instance().init(config);
 
-    SPDLOG_INFO(std::format("Start WebsocketProxy {} ...", VERSION));
+    LOG_INFO(std::format("Start WebsocketProxy {} ...", VERSION));
     WebsocketProxy proxy(server_queue_size);
     proxy.run();
-    SPDLOG_INFO("WebsocketProxy Exit.");
-    spdlog::shutdown();
+    LOG_INFO("WebsocketProxy Exit.");
 }

src/main.cpp

@@ -29,10 +29,8 @@
 #include <boost/beast/core.hpp>
 #include <boost/beast/websocket.hpp>
 #include <boost/beast/websocket/ssl.hpp>
-#include "spdlog_include.h"
-#include <spdlog/async.h>
-#include <spdlog/sinks/rotating_file_sink.h>
-#include "slick_queue.h"
+#include <slick_queue/slick_queue.h>
+#include <slick_logger/logger.hpp>
 
 #if defined(_MSC_VER)
 #include <windows.h>