Update slick_queue; Change namespace

Author: freshthinking

CHANGELOG

@@ -1,3 +1,7 @@
+# v1.0.0.7 - 10-21-2025
+- Update slick_queue to v1.1.0.1
+- Change namespace from slick_logger to slick::logger
+
 # v1.0.0.6 - 10-14-2025
 - Update slick_queue to v1.1.0.0
 - Added GitHub CI workflow for automated testing across Ubuntu, Windows, and macOS

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.20)
 
-set(BUILD_VERSION 1.0.0.6)
+set(BUILD_VERSION 1.0.0.7)
 project(slick_logger VERSION ${BUILD_VERSION} LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 20)
@@ -13,7 +13,7 @@ set(BUILD_SLICK_QUEUE_TESTS OFF CACHE BOOL "" FORCE)
 FetchContent_Declare(
     slick_queue
     GIT_REPOSITORY https://github.com/SlickQuant/slick_queue.git
-    GIT_TAG v1.1.0.0
+    GIT_TAG v1.1.0.1
 )
 FetchContent_MakeAvailable(slick_queue)
 

README.md

@@ -116,7 +116,7 @@ add_executable(your_app main.cpp)
 
 int main() {
     // Initialize the logger (traditional way)
-    slick_logger::Logger::instance().init("app.log", 1024); // queue size
+    slick::logger::Logger::instance().init("app.log", 1024); // queue size
 
     // Log messages - formatting happens in background thread for performance
     LOG_INFO("Application started");
@@ -126,7 +126,7 @@ int main() {
     LOG_INFO("User {} balance: ${:.2f}", "Alice", 1234.56); // Format specifiers supported
 
     // Shutdown (optional, called automatically on destruction)
-    slick_logger::Logger::instance().shutdown();
+    slick::logger::Logger::instance().shutdown();
     return 0;
 }
 ```
@@ -139,7 +139,7 @@ slick_logger uses C++20's `std::format` for type-safe and efficient string forma
 #include <slick_logger/logger.hpp>
 
 int main() {
-    slick_logger::Logger::instance().init("app.log");
+    slick::logger::Logger::instance().init("app.log");
 
     // Basic placeholders
     LOG_INFO("Simple message: {}", "hello");
@@ -167,7 +167,7 @@ int main() {
     std::vector<int> numbers = {1, 2, 3, 4, 5};
     LOG_INFO("Vector size: {}", numbers.size());
 
-    slick_logger::Logger::instance().shutdown();
+    slick::logger::Logger::instance().shutdown();
     return 0;
 }
 ```
@@ -218,7 +218,7 @@ You can log messages to specific sinks by name or get a reference to a sink. Eac
 #include <slick_logger/logger.hpp>
 
 int main() {
-    using namespace slick_logger;
+    using namespace slick::logger;
 
     Logger::instance().clear_sinks();
     Logger::instance().add_file_sink("app.log", "app_sink");
@@ -269,7 +269,7 @@ Dedicated sinks only receive messages logged directly to them, not broadcast mes
 #include <slick_logger/logger.hpp>
 
 int main() {
-    using namespace slick_logger;
+    using namespace slick::logger;
 
     Logger::instance().clear_sinks();
 
@@ -313,7 +313,7 @@ int main() {
 #include <slick_logger/logger.hpp>
 
 int main() {
-    using namespace slick_logger;
+    using namespace slick::logger;
 
     // Create configuration
     LogConfig config;
@@ -373,7 +373,7 @@ Date-based log rotation:
 ## Rotation Configuration
 
 ```cpp
-slick_logger::RotationConfig config;
+slick::logger::RotationConfig config;
 config.max_file_size = 50 * 1024 * 1024;  // 50MB
 config.max_files = 10;                     // keep last 10 files
 config.compress_old = false;               // future feature
@@ -444,7 +444,7 @@ Being a header-only library provides several advantages:
 Creating custom sinks is straightforward - just inherit from `ISink`:
 
 ```cpp
-class JsonSink : public slick_logger::ISink {
+class JsonSink : public slick::logger::ISink {
     std::ofstream file_;
     bool first_entry_ = true;
 
@@ -453,7 +453,7 @@ public:
         file_ << "[\n"; // Start JSON array
     }
 
-    void write(const slick_logger::LogEntry& entry) override {
+    void write(const slick::logger::LogEntry& entry) override {
         // Format as JSON - see examples/multi_sink_example.cpp for full implementation
         const char* level_str = /* convert level to string */;
         auto [message, _] = format_log_message(entry);

benchmarks/benchmark_main.cpp

@@ -96,9 +96,9 @@ class SlickLoggerScenario : public BenchmarkScenario {
         : BenchmarkScenario("slick_logger"), msg_size_(msg_size) {}
 
     void setup() override {
-        slick_logger::Logger::instance().reset();
-        slick_logger::Logger::instance().add_file_sink(FileUtils::get_unique_filename("slick"));
-        slick_logger::Logger::instance().init(65536);
+        slick::logger::Logger::instance().reset();
+        slick::logger::Logger::instance().add_file_sink(FileUtils::get_unique_filename("slick"));
+        slick::logger::Logger::instance().init(65536);
 
         // Warm up
         for (int i = 0; i < 100; ++i) {
@@ -108,7 +108,7 @@ class SlickLoggerScenario : public BenchmarkScenario {
     }
 
     void cleanup() override {
-        slick_logger::Logger::instance().shutdown();
+        slick::logger::Logger::instance().shutdown();
     }
 
     void log_single_message() override {

benchmarks/latency_benchmark.cpp

@@ -128,9 +128,9 @@ class LatencyAnalyzer {
 void measure_slick_logger_latency() {
     std::cout << "=== SLICK LOGGER LATENCY TEST ===" << std::endl;
 
-    slick_logger::Logger::instance().reset();
-    slick_logger::Logger::instance().add_file_sink(FileUtils::get_unique_filename("slick_latency"));
-    slick_logger::Logger::instance().init(65536);
+    slick::logger::Logger::instance().reset();
+    slick::logger::Logger::instance().add_file_sink(FileUtils::get_unique_filename("slick_latency"));
+    slick::logger::Logger::instance().init(65536);
 
     LatencyAnalyzer analyzer;
     MessageGenerator msg_gen;
@@ -158,7 +158,7 @@ void measure_slick_logger_latency() {
 
     analyzer.analyze_and_report();
 
-    slick_logger::Logger::instance().shutdown();
+    slick::logger::Logger::instance().shutdown();
 }
 
 // Measure spdlog sync latency
@@ -202,9 +202,9 @@ void measure_spdlog_sync_latency() {
 void measure_queue_pressure_effects() {
     std::cout << "=== QUEUE PRESSURE EFFECTS ===" << std::endl;
 
-    slick_logger::Logger::instance().reset();
-    slick_logger::Logger::instance().add_file_sink(FileUtils::get_unique_filename("slick_pressure"));
-    slick_logger::Logger::instance().init(65536);
+    slick::logger::Logger::instance().reset();
+    slick::logger::Logger::instance().add_file_sink(FileUtils::get_unique_filename("slick_pressure"));
+    slick::logger::Logger::instance().init(65536);
 
     MessageGenerator msg_gen;
 
@@ -263,7 +263,7 @@ void measure_queue_pressure_effects() {
         std::cout << std::endl;
     }
 
-    slick_logger::Logger::instance().shutdown();
+    slick::logger::Logger::instance().shutdown();
 }
 
 int main(int argc, char* argv[]) {

benchmarks/memory_benchmark.cpp

@@ -61,14 +61,14 @@ class MemoryAnalyzer {
         size_t baseline_memory = baseline_usage.memory_bytes;
 
         // Initialize logger
-        slick_logger::Logger::instance().reset();
+        slick::logger::Logger::instance().reset();
         std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Let cleanup complete
 
         monitor.start_monitoring();
 
-        slick_logger::Logger::instance().add_file_sink(
+        slick::logger::Logger::instance().add_file_sink(
             FileUtils::get_unique_filename("slick_memory"));
-        slick_logger::Logger::instance().init(queue_size);
+        slick::logger::Logger::instance().init(queue_size);
 
         // Log test messages
         MessageGenerator msg_gen;
@@ -89,7 +89,7 @@ class MemoryAnalyzer {
         monitor.stop_monitoring();
         auto final_usage = monitor.get_current_usage();
 
-        slick_logger::Logger::instance().shutdown();
+        slick::logger::Logger::instance().shutdown();
 
         MemoryProfile profile;
         profile.logger_name = "SlickLogger";
@@ -208,10 +208,10 @@ class MemoryAnalyzer {
         {
             std::cout << "Testing SlickLogger..." << std::endl;
 
-            slick_logger::Logger::instance().reset();
-            slick_logger::Logger::instance().add_file_sink(
+            slick::logger::Logger::instance().reset();
+            slick::logger::Logger::instance().add_file_sink(
                 FileUtils::get_unique_filename("slick_sustained"));
-            slick_logger::Logger::instance().init(65536);
+            slick::logger::Logger::instance().init(65536);
 
             SystemMonitor monitor;
             monitor.start_monitoring();
@@ -248,7 +248,7 @@ class MemoryAnalyzer {
             std::cout << "  Final memory: " << (usage.memory_bytes / 1024.0 / 1024.0) << " MB" << std::endl;
             std::cout << std::endl;
 
-            slick_logger::Logger::instance().shutdown();
+            slick::logger::Logger::instance().shutdown();
         }
     }
 
@@ -263,18 +263,18 @@ class MemoryAnalyzer {
         SystemMonitor monitor;
 
         for (size_t cycle = 0; cycle < num_cycles; ++cycle) {
-            slick_logger::Logger::instance().reset();
-            slick_logger::Logger::instance().add_file_sink(
+            slick::logger::Logger::instance().reset();
+            slick::logger::Logger::instance().add_file_sink(
                 FileUtils::get_unique_filename("slick_frag_" + std::to_string(cycle)));
-            slick_logger::Logger::instance().init(8192);
+            slick::logger::Logger::instance().init(8192);
 
             MessageGenerator msg_gen;
             for (size_t i = 0; i < messages_per_cycle; ++i) {
                 LOG_INFO("Fragmentation test cycle {} message {} - {}", 
                        cycle, i, msg_gen.generate_small());
             }
 
-            slick_logger::Logger::instance().shutdown();
+            slick::logger::Logger::instance().shutdown();
 
             // Small delay to let cleanup complete
             std::this_thread::sleep_for(std::chrono::milliseconds(50));

benchmarks/quick_benchmark.cpp

@@ -43,16 +43,16 @@ int main() {
 
     // SlickLogger test
     std::cout << "\nSlickLogger (single thread):\n";
-    slick_logger::Logger::instance().reset();
-    slick_logger::Logger::instance().add_file_sink("bench_slick.log");
-    slick_logger::Logger::instance().init(8192);
+    slick::logger::Logger::instance().reset();
+    slick::logger::Logger::instance().add_file_sink("bench_slick.log");
+    slick::logger::Logger::instance().init(8192);
 
     timer.start();
     for (size_t i = 0; i < test_messages; ++i) {
         LOG_INFO("Benchmark message {} value: {:.3f}", i, i * 1.618);
     }
     double slick_time = timer.stop();
-    slick_logger::Logger::instance().shutdown();
+    slick::logger::Logger::instance().shutdown();
 
     std::cout << "Time: " << slick_time << " ms\n";
     std::cout << "Rate: " << static_cast<size_t>(timer.rate(test_messages, slick_time)) << " msg/sec\n";
@@ -73,9 +73,9 @@ int main() {
 
     // Multi-threaded SlickLogger
     std::cout << "\nSlickLogger (4 threads):\n";
-    slick_logger::Logger::instance().reset();
-    slick_logger::Logger::instance().add_file_sink("bench_slick_mt.log");
-    slick_logger::Logger::instance().init(8192);
+    slick::logger::Logger::instance().reset();
+    slick::logger::Logger::instance().add_file_sink("bench_slick_mt.log");
+    slick::logger::Logger::instance().init(8192);
 
     const size_t num_threads = 4;
     const size_t msgs_per_thread = test_messages / num_threads;
@@ -95,7 +95,7 @@ int main() {
     }
 
     double slick_mt_time = timer.stop();
-    slick_logger::Logger::instance().shutdown();
+    slick::logger::Logger::instance().shutdown();
 
     std::cout << "Time: " << slick_mt_time << " ms\n";
     std::cout << "Rate: " << static_cast<size_t>(timer.rate(test_messages, slick_mt_time)) << " msg/sec\n";

benchmarks/simple_benchmark.cpp

@@ -43,9 +43,9 @@ class BenchmarkTimer {
 void benchmark_slick_logger(const std::string& filename, size_t message_count) {
     std::cout << "\n=== SlickLogger Benchmark ===\n";
 
-    slick_logger::Logger::instance().reset();
-    slick_logger::Logger::instance().add_file_sink(filename);
-    slick_logger::Logger::instance().init(65536);
+    slick::logger::Logger::instance().reset();
+    slick::logger::Logger::instance().add_file_sink(filename);
+    slick::logger::Logger::instance().init(65536);
 
     // Single-threaded test
     BenchmarkTimer timer;
@@ -56,7 +56,7 @@ void benchmark_slick_logger(const std::string& filename, size_t message_count) {
     }
 
     timer.stop();
-    slick_logger::Logger::instance().shutdown();
+    slick::logger::Logger::instance().shutdown();
 
     std::cout << "Messages: " << message_count << "\n";
     std::cout << "Time: " << timer.elapsed_ms() << " ms\n";
@@ -65,9 +65,9 @@ void benchmark_slick_logger(const std::string& filename, size_t message_count) {
     // Multi-threaded test
     std::cout << "\n--- Multi-threaded (4 threads) ---\n";
 
-    slick_logger::Logger::instance().reset();
-    slick_logger::Logger::instance().add_file_sink(filename + "_mt");
-    slick_logger::Logger::instance().init(65536);
+    slick::logger::Logger::instance().reset();
+    slick::logger::Logger::instance().add_file_sink(filename + "_mt");
+    slick::logger::Logger::instance().init(65536);
 
     const size_t num_threads = 4;
     const size_t messages_per_thread = message_count / num_threads;
@@ -88,7 +88,7 @@ void benchmark_slick_logger(const std::string& filename, size_t message_count) {
     }
 
     timer.stop();
-    slick_logger::Logger::instance().shutdown();
+    slick::logger::Logger::instance().shutdown();
 
     std::cout << "Messages: " << message_count << " (4 threads)\n";
     std::cout << "Time: " << timer.elapsed_ms() << " ms\n";
@@ -179,9 +179,9 @@ void benchmark_latency() {
 
     // SlickLogger latency
     std::cout << "Measuring SlickLogger latency...\n";
-    slick_logger::Logger::instance().reset();
-    slick_logger::Logger::instance().add_file_sink("latency_slick.log");
-    slick_logger::Logger::instance().init(65536);
+    slick::logger::Logger::instance().reset();
+    slick::logger::Logger::instance().add_file_sink("latency_slick.log");
+    slick::logger::Logger::instance().init(65536);
 
     // Warmup
     for (int i = 0; i < 1000; ++i) {
@@ -197,7 +197,7 @@ void benchmark_latency() {
         slick_latencies.push_back(duration_cast<nanoseconds>(end - start).count());
     }
 
-    slick_logger::Logger::instance().shutdown();
+    slick::logger::Logger::instance().shutdown();
 
     // spdlog latency
     std::cout << "Measuring spdlog latency...\n";