Allow dynamic format string with arguments; bump version to v1.0.6

Author: kzhdev

CHANGELOG

@@ -1,3 +1,10 @@
+# v1.0.6 - 02-13-2026
+- Fix logging through downstream `const char*` format bridge with `std::format_args`
+  - Dynamic (non-literal) format strings are now copied into the internal string queue so they remain valid across the async writer boundary
+  - Dynamic format strings now support arguments instead of requiring zero args
+- Fix string queue copy path to null-terminate using explicit payload length
+- Add regression test for `const char* + std::format_args` bridge logging
+
 # v1.0.5 - 02-10-2026
 - Add `std::format_args` support: pass a pre-built `std::format_args` object directly to any log call
   - Arguments are unpacked and copied into the log entry on the calling thread (safe across thread boundary)

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(slick-logger
-    VERSION 1.0.5
+    VERSION 1.0.6
     LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 20)

include/slick/logger.hpp

@@ -55,8 +55,8 @@
 
 #define SLICK_LOGGER_VERSION_MAJOR 1
 #define SLICK_LOGGER_VERSION_MINOR 0
-#define SLICK_LOGGER_VERSION_PATCH 5
-#define SLICK_LOGGER_VERSION "1.0.5"
+#define SLICK_LOGGER_VERSION_PATCH 6
+#define SLICK_LOGGER_VERSION "1.0.6"
 
 #ifndef SLICK_LOGGER_MAX_ARGS
 #define SLICK_LOGGER_MAX_ARGS 20
@@ -1441,26 +1441,27 @@ inline void Logger::log_to_sink(int sink_index, LogLevel level, FormatT&& format
     entry.sink_index = sink_index;
     if constexpr (IS_STRING_LITERAL(format)) {
         entry.format_ptr = format;  // String literal - safe to store pointer
-
-        if constexpr (is_single_format_args_v<Args...>) {
-            // Pre-built std::format_args: unpack values into the entry on the
-            // calling thread (format_args holds non-owning references).
-            enqueue_format_args(entry,
-                std::get<0>(std::forward_as_tuple(std::forward<Args>(args)...)));
-        } else {
-            // Normal path: push individual arguments
-            entry.arg_count = sizeof...(args);
-            size_t arg_idx = 0;
-            static_assert(sizeof...(args) <= SLICK_LOGGER_MAX_ARGS, "Too many log arguments");
-            (enqueue_argument(entry.args[arg_idx++], std::forward<Args>(args)), ...);
-        }
     }
     else {
-        // Store dynamic string in string queue
-        static_assert(sizeof...(args) == 0, "Dynamic format strings are only supported when there are no arguments, to avoid dangling pointers.");
-        entry.format_ptr = "{}";
-        entry.arg_count = 1;
-        enqueue_argument(entry.args[0], format);
+        // Non-literal format strings are copied into the string queue so their
+        // lifetime extends until the writer thread consumes the entry.
+        static_assert(std::is_convertible_v<FormatT, std::string_view>,
+                      "Format string type must be a string literal or convertible to std::string_view.");
+        entry.format_ptr = store_string_in_queue(
+            std::string_view{std::forward<FormatT>(format)}).ptr;
+    }
+
+    if constexpr (is_single_format_args_v<Args...>) {
+        // Pre-built std::format_args: unpack values into the entry on the
+        // calling thread (format_args holds non-owning references).
+        enqueue_format_args(entry,
+            std::get<0>(std::forward_as_tuple(std::forward<Args>(args)...)));
+    } else {
+        // Normal path: push individual arguments
+        entry.arg_count = sizeof...(args);
+        size_t arg_idx = 0;
+        static_assert(sizeof...(args) <= SLICK_LOGGER_MAX_ARGS, "Too many log arguments");
+        (enqueue_argument(entry.args[arg_idx++], std::forward<Args>(args)), ...);
     }
 
 
@@ -1602,8 +1603,9 @@ inline StringRef Logger::store_string_in_queue(std::string_view str) {
 
     char* dest = (*string_queue_)[start_index];
     if (length) {
-        // Copy string data
-        std::memcpy(dest, str.data(), len);
+        // Copy only the string payload, then terminate explicitly.
+        std::memcpy(dest, str.data(), length);
+        dest[length] = '\0';
     } 
     else {
         *dest = '\0';

src/logger.hpp

@@ -1439,26 +1439,27 @@ inline void Logger::log_to_sink(int sink_index, LogLevel level, FormatT&& format
     entry.sink_index = sink_index;
     if constexpr (IS_STRING_LITERAL(format)) {
         entry.format_ptr = format;  // String literal - safe to store pointer
-
-        if constexpr (is_single_format_args_v<Args...>) {
-            // Pre-built std::format_args: unpack values into the entry on the
-            // calling thread (format_args holds non-owning references).
-            enqueue_format_args(entry,
-                std::get<0>(std::forward_as_tuple(std::forward<Args>(args)...)));
-        } else {
-            // Normal path: push individual arguments
-            entry.arg_count = sizeof...(args);
-            size_t arg_idx = 0;
-            static_assert(sizeof...(args) <= SLICK_LOGGER_MAX_ARGS, "Too many log arguments");
-            (enqueue_argument(entry.args[arg_idx++], std::forward<Args>(args)), ...);
-        }
     }
     else {
-        // Store dynamic string in string queue
-        static_assert(sizeof...(args) == 0, "Dynamic format strings are only supported when there are no arguments, to avoid dangling pointers.");
-        entry.format_ptr = "{}";
-        entry.arg_count = 1;
-        enqueue_argument(entry.args[0], format);
+        // Non-literal format strings are copied into the string queue so their
+        // lifetime extends until the writer thread consumes the entry.
+        static_assert(std::is_convertible_v<FormatT, std::string_view>,
+                      "Format string type must be a string literal or convertible to std::string_view.");
+        entry.format_ptr = store_string_in_queue(
+            std::string_view{std::forward<FormatT>(format)}).ptr;
+    }
+
+    if constexpr (is_single_format_args_v<Args...>) {
+        // Pre-built std::format_args: unpack values into the entry on the
+        // calling thread (format_args holds non-owning references).
+        enqueue_format_args(entry,
+            std::get<0>(std::forward_as_tuple(std::forward<Args>(args)...)));
+    } else {
+        // Normal path: push individual arguments
+        entry.arg_count = sizeof...(args);
+        size_t arg_idx = 0;
+        static_assert(sizeof...(args) <= SLICK_LOGGER_MAX_ARGS, "Too many log arguments");
+        (enqueue_argument(entry.args[arg_idx++], std::forward<Args>(args)), ...);
     }
 
 
@@ -1600,8 +1601,9 @@ inline StringRef Logger::store_string_in_queue(std::string_view str) {
 
     char* dest = (*string_queue_)[start_index];
     if (length) {
-        // Copy string data
-        std::memcpy(dest, str.data(), len);
+        // Copy only the string payload, then terminate explicitly.
+        std::memcpy(dest, str.data(), length);
+        dest[length] = '\0';
     } 
     else {
         *dest = '\0';

tests/test_logger.cpp

@@ -19,6 +19,7 @@ class SlickLoggerTest : public ::testing::Test {
         std::filesystem::remove("test_single_string.log");
         std::filesystem::remove("test_empty_string.log");
         std::filesystem::remove("test_format_args.log");
+        std::filesystem::remove("test_format_args_const_char.log");
     }
 };
 
@@ -398,9 +399,34 @@ TEST_F(SlickLoggerTest, FormatArgsLogging) {
     }
 
     EXPECT_NE(file_contents.find("int=42 double=3.14 str=hello bool=true"), std::string::npos);
+}
 
-    log_file.close();
-    std::filesystem::remove("test_format_args.log");
+TEST_F(SlickLoggerTest, FormatArgsConstCharBridgeLogging) {
+    std::filesystem::remove("test_format_args_const_char.log");
+
+    slick::logger::Logger::instance().init("test_format_args_const_char.log", 1024);
+
+    auto log_bridge = [](slick::logger::LogLevel level, const char* format_text, std::format_args args) {
+        slick::logger::Logger::instance().log(level, format_text, args);
+    };
+
+    int number = 7;
+    std::string_view text = "bridge";
+    log_bridge(slick::logger::LogLevel::L_INFO, "bridge value={} text={}", std::make_format_args(number, text));
+
+    slick::logger::Logger::instance().shutdown();
+
+    ASSERT_TRUE(std::filesystem::exists("test_format_args_const_char.log"));
+
+    std::ifstream log_file("test_format_args_const_char.log");
+    std::string file_contents;
+    std::string line;
+    std::getline(log_file, line); // first line is the logger's version
+    while (std::getline(log_file, line)) {
+        file_contents += line + "\n";
+    }
+
+    EXPECT_NE(file_contents.find("bridge value=7 text=bridge"), std::string::npos);
 }
 
 int main(int argc, char **argv) {