Extra attributes for log_msg

.gitignore

@@ -87,6 +87,9 @@ cmake-build-*/
 *.user
 *.sln
 
+# vscode
+.vscode
+
 # macos
 *.DS_store
 *.xcodeproj/

CMakeLists.txt

@@ -25,7 +25,7 @@ endif()
 # ---------------------------------------------------------------------------------------
 # Compiler config
 # ---------------------------------------------------------------------------------------
-if(SPDLOG_USE_STD_FORMAT)
+if(SPDLOG_USE_STD_FORMAT OR SPDLOG_USE_STD_STRING_VIEW)
     set(CMAKE_CXX_STANDARD 20)
     set(CMAKE_CXX_STANDARD_REQUIRED ON)
 elseif(NOT CMAKE_CXX_STANDARD)
@@ -88,6 +88,7 @@ option(SPDLOG_BUILD_WARNINGS "Enable compiler warnings" OFF)
 option(SPDLOG_SYSTEM_INCLUDES "Include as system headers (skip for clang-tidy)." OFF)
 option(SPDLOG_INSTALL "Generate the install target" ${SPDLOG_MASTER_PROJECT})
 option(SPDLOG_USE_STD_FORMAT "Use std::format instead of fmt library." OFF)
+option(SPDLOG_USE_STD_STRING_VIEW "Use std::string_view instead of the fmt implementation of string_view." OFF)
 option(SPDLOG_FMT_EXTERNAL "Use external fmt library instead of bundled" OFF)
 option(SPDLOG_FMT_EXTERNAL_HO "Use external fmt header-only library instead of bundled" OFF)
 option(SPDLOG_NO_EXCEPTIONS "Compile with -fno-exceptions. Call abort() on any spdlog exceptions" OFF)
@@ -104,6 +105,11 @@ if(SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL)
     message(FATAL_ERROR "SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL are mutually exclusive")
 endif()
 
+if(SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_USE_STD_STRING_VIEW)
+    # message(FATAL_ERROR "SPDLOG_USE_STD_FORMAT requires SPDLOG_USE_STD_STRING_VIEW")
+    set(SPDLOG_USE_STD_STRING_VIEW ON CACHE BOOL "" FORCE) # automatically set SPDLOG_USE_STD_STRING_VIEW instead of error
+endif()
+
 # misc tweakme options
 if(WIN32)
     option(SPDLOG_WCHAR_SUPPORT "Support wchar api" OFF)
@@ -248,6 +254,7 @@ foreach(
     SPDLOG_NO_TLS
     SPDLOG_NO_ATOMIC_LEVELS
     SPDLOG_DISABLE_DEFAULT_LOGGER
+    SPDLOG_USE_STD_STRING_VIEW
     SPDLOG_USE_STD_FORMAT)
     if(${SPDLOG_OPTION})
         target_compile_definitions(spdlog PUBLIC ${SPDLOG_OPTION})

example/example.cpp

@@ -27,6 +27,8 @@ void custom_flags_example();
 void file_events_example();
 void replace_default_logger_example();
 
+void attribute_example();
+
 #include "spdlog/spdlog.h"
 #include "spdlog/cfg/env.h"  // support for loading levels from the environment variable
 #include "spdlog/fmt/ostr.h" // support for user defined types
@@ -86,6 +88,7 @@ int main(int, char *[])
         custom_flags_example();
         file_events_example();
         replace_default_logger_example();
+        attribute_example();
 
         // Flush all *registered* loggers using a worker thread every 3 seconds.
         // note: registered loggers *must* be thread safe for this to work correctly!
@@ -279,7 +282,7 @@ struct fmt::formatter<my_type> : fmt::formatter<std::string>
 {
     auto format(my_type my, format_context &ctx) -> decltype(ctx.out())
     {
-        return format_to(ctx.out(), "[my_type i={}]", my.i);
+        return fmt::format_to(ctx.out(), "[my_type i={}]", my.i);
     }
 };
 
@@ -389,3 +392,33 @@ void replace_default_logger_example()
 
     spdlog::set_default_logger(old_logger);
 }
+
+void attribute_example() {
+    spdlog::push_context(spdlog::attribute_list{{"attribute_key", "attribute value"}});
+    spdlog::warn("EXPERIMENTAL: log with attributes");
+    spdlog::clear_context();
+
+    // structured logging using attributes
+
+    // auto s_logger = spdlog::basic_logger_mt("structured logger", "logs/mylog.txt");
+    auto s_logger = spdlog::stdout_color_mt("structured logger");
+
+    #if 0
+    std::string json_pattern = "{\"time\":\"%Y-%m-%dT%H:%M:%S.%e%z\",\"name\":\"%n\",\"level\":\"%l\",\"message\":\"%v\"%(,\"%K\":\"%V\"%)}";
+    s_logger->set_pattern(std::move(json_pattern));
+    #endif
+    #if 1
+    std::string logfmt_pattern = "time=%Y-%m-%dT%H:%M:%S.%f%z name=\"%n\" level=%^%l%$ process=%P thread=%t message=\"%v\"%( %K=\"%V\"%)";
+    s_logger->set_pattern(std::move(logfmt_pattern));
+    #endif
+
+    s_logger->push_context(spdlog::attribute_list{{"key\n1", "value\n1"}});
+    s_logger->info("structured logging: test 1");
+    s_logger->push_context(spdlog::attribute_list{{"key\n2", "value\n2"}});
+    s_logger->info("structured logging: test 2");
+    s_logger->pop_context();
+    s_logger->info("structured logging: test 3");
+    s_logger->pop_context();
+    s_logger->info("structured logging: test 4");
+    s_logger->clear_context();
+}

include/spdlog/common.h

@@ -132,10 +132,15 @@ using log_clock = std::chrono::system_clock;
 using sink_ptr = std::shared_ptr<sinks::sink>;
 using sinks_init_list = std::initializer_list<sink_ptr>;
 using err_handler = std::function<void(const std::string &err_msg)>;
+#ifdef SPDLOG_USE_STD_STRING_VIEW
+using string_view_t = std::string_view;
+#else
+using string_view_t = fmt::basic_string_view<char>;
+#endif 
+
 #ifdef SPDLOG_USE_STD_FORMAT
 namespace fmt_lib = std;
 
-using string_view_t = std::string_view;
 using memory_buf_t = std::string;
 
 template<typename... Args>
@@ -164,7 +169,6 @@ using wformat_string_t = std::wstring_view;
 #else // use fmt lib instead of std::format
 namespace fmt_lib = fmt;
 
-using string_view_t = fmt::basic_string_view<char>;
 using memory_buf_t = fmt::basic_memory_buffer<char, 250>;
 
 template<typename... Args>
@@ -360,7 +364,7 @@ SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view
 }
 #endif
 
-#ifndef SPDLOG_USE_STD_FORMAT
+#if !defined(SPDLOG_USE_STD_STRING_VIEW) && !defined(SPDLOG_USE_STD_FORMAT)
 template<typename T, typename... Args>
 inline fmt::basic_string_view<T> to_string_view(fmt::basic_format_string<T, Args...> fmt)
 {
@@ -372,6 +376,13 @@ SPDLOG_CONSTEXPR_FUNC std::basic_string_view<T> to_string_view(std::basic_format
 {
     return fmt.get();
 }
+#elif defined(SPDLOG_USE_STD_STRING_VIEW) && !defined(SPDLOG_USE_STD_FORMAT)
+template<typename T, typename... Args>
+SPDLOG_CONSTEXPR_FUNC std::basic_string_view<T> to_string_view(fmt::basic_format_string<T, Args...> fmt) SPDLOG_NOEXCEPT
+{
+    auto tmp = fmt::basic_string_view<T>{fmt};
+    return std::string_view{tmp.data(), tmp.size()};
+}
 #endif
 
 // make_unique support for pre c++14

include/spdlog/details/attr_composer.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <string>
+#include <spdlog/common.h>
+
+namespace spdlog {
+namespace details {
+
+inline void scramble(std::string& dst, string_view_t s)
+{
+    if (s.size() == 0)
+        return;
+
+    auto start = s.data();
+    auto const end = s.data() + s.size();
+    auto cursor = start;
+
+    dst.reserve(dst.size() + s.size());
+
+    auto replace = [&](string_view_t with) {
+        dst.append(start, size_t(cursor - start));
+        ++cursor;
+        start = cursor;
+        // dst.append(with);
+        dst.append(with.data(), with.size());
+    };
+
+    while (cursor != end) {
+        auto c = static_cast<unsigned char>(*cursor);
+
+        switch (c) {
+        case '\b':
+            replace("\\b");
+            break;
+        case '\f':
+            replace("\\f");
+            break;
+        case '\n':
+            replace("\\n");
+            break;
+        case '\r':
+            replace("\\r");
+            break;
+        case '\t':
+            replace("\\t");
+            break;
+        case '\\':
+            replace("\\\\");
+            break;
+        case '"':
+            replace("\\\"");
+            break;
+        default:
+            if (c <= '\x0f') {
+                char buf[] = "\\u0000";
+                buf[5] = (char)(buf[5] + c);
+                if (c >= '\x0a')
+                    buf[5] = (char)(buf[5] + ('a' - ':'));
+                replace(buf);
+            }
+            else if (c <= '\x1f' || c == 0x7f) {
+                char buf[] = "\\u0010";
+                buf[5] = (char)(buf[5] + (c - 16));
+                if (c >= '\x1a')
+                    buf[5] = (char)(buf[5] + ('a' - ':'));
+                replace(buf);
+            }
+            else
+                ++cursor;
+        }
+    }
+    if (cursor != start)
+        dst.append({start, size_t(cursor - start)});
+}
+
+}
+}

include/spdlog/details/log_attr.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include "attr_composer.h"
+#include <spdlog/common.h>
+
+namespace spdlog {
+namespace details {
+
+//template<typename T>
+//concept composable = std::same_as<T, bool> || std::integral<T> || std::floating_point<T> || std::convertible_to<T, std::string_view>;
+
+struct attr
+{
+    std::string key;
+    std::string value;
+
+public:
+    attr(std::initializer_list<string_view_t> l) {
+        if (l.size() != 2) return; // throw exception if not kv pair?
+
+        scramble(key, *l.begin());
+        scramble(value, *(l.begin()+1));
+    }
+
+    attr(string_view_t k, bool v) 
+        : value{v ? "true" : "false"}
+    {
+        key = std::string{k.data(), k.size()};
+    }
+
+    attr(string_view_t k, string_view_t v)
+    {
+        key = std::string{k.data(), k.size()};
+        value = std::string{v.data(), v.size()};
+    }
+
+    attr(std::string k, std::string v) : key{k}, value{v} {}
+
+    template <typename T>
+    attr(string_view_t k, T const &v)
+        : value{std::to_string(v)}
+    {
+        key = std::string{k.data(), k.size()};
+    }
+};
+
+} // namespace details
+
+using attribute_list = std::vector<details::attr>;
+
+} // namespace spdlog

include/spdlog/details/log_msg.h

@@ -5,6 +5,7 @@
 
 #include <spdlog/common.h>
 #include <string>
+#include "log_attr.h"
 
 namespace spdlog {
 namespace details {
@@ -28,6 +29,7 @@ struct SPDLOG_API log_msg
 
     source_loc source;
     string_view_t payload;
+    attribute_list attributes;
 };
 } // namespace details
 } // namespace spdlog

include/spdlog/details/log_msg_buffer-inl.h

@@ -13,20 +13,21 @@ namespace details {
 SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg)
     : log_msg{orig_msg}
 {
-    buffer.append(logger_name.begin(), logger_name.end());
-    buffer.append(payload.begin(), payload.end());
+    buffer.append(logger_name.data(), logger_name.data() + logger_name.size());
+    buffer.append(payload.data(), payload.data() + payload.size());
     update_string_views();
 }
 
 SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other)
     : log_msg{other}
 {
-    buffer.append(logger_name.begin(), logger_name.end());
-    buffer.append(payload.begin(), payload.end());
+    buffer.append(logger_name.data(), logger_name.data() + logger_name.size());
+    buffer.append(payload.data(), payload.data() + payload.size());
     update_string_views();
 }
 
-SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT : log_msg{other}, buffer{std::move(other.buffer)}
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT 
+    : log_msg{other}, buffer{std::move(other.buffer)} 
 {
     update_string_views();
 }