V2.x - Attribute support

CMakeLists.txt

@@ -168,6 +168,7 @@ find_package(Threads REQUIRED)
 set(SPDLOG_HEADERS
  "include/spdlog/async.h"
  "include/spdlog/async_logger.h"
+ "include/spdlog/attributes.h"
  "include/spdlog/common.h"
  "include/spdlog/formatter.h"
  "include/spdlog/fwd.h"

include/spdlog/attributes.h

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <spdlog/common.h>
+
+#include <map>
+#include <mutex>
+
+
+namespace spdlog {
+
+class SPDLOG_API log_attributes {
+public:
+ using attr_map_t = std::map<std::string, std::string>;
+ using key_t = attr_map_t::key_type;
+ using value_t = attr_map_t::mapped_type;
+ using const_iter = attr_map_t::const_iterator;
+
+ class SPDLOG_API log_attr_context {
+ public:
+ log_attr_context(log_attributes& parent, attr_map_t const& attrs)
+ : parent_(parent),
+ tmp_attrs_{attrs} {
+ parent_.put(attrs);
+ }
+ explicit log_attr_context(log_attributes& parent)
+ : log_attr_context(parent, {}) {}
+
+ ~log_attr_context() {
+ for (auto&& key_value : tmp_attrs_) parent_.remove(key_value.first);
+ }
+
+ private:
+ log_attributes& parent_;
+ attr_map_t tmp_attrs_;
+ };
+
+ log_attributes() = default;
+ log_attributes(const log_attributes& other) { put(other.get_map()); }
+ log_attributes& operator=(const log_attributes& other) {
+ if (this != &other) {
+ clear();
+ put(other.get_map());
+ }
+ return *this;
+ }
+
+ void put(attr_map_t const& attributes) {
+ auto lck = lock();
+ for (auto const& attribute : attributes) attrs.insert_or_assign(attribute.first, attribute.second);
+ }
+ void put(const key_t& key, const value_t& value) { put({{key, value}}); }
+
+ void remove(const key_t& key) {
+ auto lck = lock();
+ auto value_it = attrs.find(key);
+ if (value_it != attrs.end()) {
+ attrs.erase(key);
+ }
+ }
+
+ void clear() {
+ auto lck = lock();
+ attrs.clear();
+ }
+
+ bool empty() const {
+ auto lck = lock();
+ return attrs.empty();
+ }
+
+ // return {true, iter} if found, {false, end} otherwise
+ std::pair<bool, const_iter> const get(key_t const& key) const {
+ auto lck = lock();
+ auto value_it = attrs.find(key);
+
+ return std::make_pair(value_it != attrs.end(), value_it);
+ }
+
+ // provide a local copy of the attributes to be free of race issues
+ // alternative is to lock the attr_map while the formatter iterates over it
+ attr_map_t get_map() const {
+ auto lck = lock();
+ return attrs;
+ }
+
+ // RAII-wrapper that inserts a couple of attributes and removes them upon destruction
+ log_attr_context scoped_ctx(attr_map_t const& attributes) { return log_attr_context(*this, attributes); }
+ log_attr_context scoped_ctx(key_t key, value_t value) { return log_attr_context(*this, {{key, value}}); }
+
+ bool empty() {
+ auto lck = lock();
+ return attrs.empty();
+ }
+
+private:
+ std::lock_guard<std::mutex> lock() const { return std::lock_guard(attrs_mtx); }
+
+ mutable std::mutex attrs_mtx;
+ attr_map_t attrs;
+};
+
+} // namespace spdlog

include/spdlog/details/log_msg.h

@@ -5,14 +5,23 @@
 
 #include <string>
 
+#include "../attributes.h"
 #include "../common.h"
 
 namespace spdlog {
 namespace details {
 struct SPDLOG_API log_msg {
  log_msg() = default;
+ log_msg(log_clock::time_point log_time,
+ source_loc loc,
+ string_view_t logger_name,
+ level lvl,
+ string_view_t msg,
+ log_attributes attributes);
  log_msg(log_clock::time_point log_time, source_loc loc, string_view_t logger_name, level lvl, string_view_t msg);
  log_msg(source_loc loc, string_view_t logger_name, level lvl, string_view_t msg);
+ log_msg(source_loc loc, string_view_t logger_name, level lvl, string_view_t msg, log_attributes attributes);
+ log_msg(string_view_t logger_name, level lvl, string_view_t msg, log_attributes attributes);
  log_msg(string_view_t logger_name, level lvl, string_view_t msg);
  log_msg(const log_msg &other) = default;
  log_msg &operator=(const log_msg &other) = default;
@@ -28,6 +37,7 @@ struct SPDLOG_API log_msg {
 
  source_loc source;
  string_view_t payload;
+ log_attributes attributes;
 };
 } // namespace details
 } // namespace spdlog

include/spdlog/logger.h

@@ -20,6 +20,7 @@
 #include "./common.h"
 #include "./details/log_msg.h"
 #include "./sinks/sink.h"
+#include "attributes.h"
 
 #ifndef SPDLOG_NO_EXCEPTIONS
  #define SPDLOG_LOGGER_CATCH(location) \
@@ -90,20 +91,20 @@ class SPDLOG_API logger {
  // log with no format string, just string message
  void log(source_loc loc, level lvl, string_view_t msg) {
  if (should_log(lvl)) {
- sink_it_(details::log_msg(loc, name_, lvl, msg));
+ sink_it_(details::log_msg(loc, name_, lvl, msg, attributes));
  }
  }
 
  void log(level lvl, string_view_t msg) {
  if (should_log(lvl)) {
- sink_it_(details::log_msg(source_loc{}, name_, lvl, msg));
+ sink_it_(details::log_msg(source_loc{}, name_, lvl, msg, attributes));
  }
  }
 
  // support for custom time
  void log(log_clock::time_point log_time, source_loc loc, level lvl, string_view_t msg) {
  if (should_log(lvl)) {
- sink_it_(details::log_msg(log_time, loc, name_, lvl, msg));
+ sink_it_(details::log_msg(log_time, loc, name_, lvl, msg, attributes));
  }
  }
 
@@ -229,9 +230,12 @@ class SPDLOG_API logger {
  // create new logger with same sinks and configuration.
  virtual std::shared_ptr<logger> clone(std::string logger_name);
 
+ log_attributes &attrs();
+
 protected:
  std::string name_;
  std::vector<sink_ptr> sinks_;
+ log_attributes attributes;
  spdlog::atomic_level_t level_{level::info};
  spdlog::atomic_level_t flush_level_{level::off};
  err_handler custom_err_handler_{nullptr};
@@ -248,7 +252,7 @@ class SPDLOG_API logger {
 #else // use {fmt} lib
  memory_buf_t buf;
  fmt::vformat_to(std::back_inserter(buf), fmt, fmt::make_format_args(args...));
- sink_it_(details::log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())));
+ sink_it_(details::log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size()), attributes));
 #endif
  }
  SPDLOG_LOGGER_CATCH(loc)

src/details/log_msg.cpp

@@ -8,6 +8,25 @@
 namespace spdlog {
 namespace details {
 
+log_msg::log_msg(spdlog::log_clock::time_point log_time,
+ spdlog::source_loc loc,
+ string_view_t a_logger_name,
+ spdlog::level lvl,
+ spdlog::string_view_t msg,
+ spdlog::log_attributes attributes)
+ : logger_name(a_logger_name),
+ log_level(lvl),
+ time(log_time)
+#ifndef SPDLOG_NO_THREAD_ID
+ ,
+ thread_id(os::thread_id())
+#endif
+ ,
+ source(loc),
+ payload(msg),
+ attributes(attributes) {
+}
+
 log_msg::log_msg(spdlog::log_clock::time_point log_time,
  spdlog::source_loc loc,
  string_view_t a_logger_name,
@@ -28,8 +47,18 @@ log_msg::log_msg(spdlog::log_clock::time_point log_time,
 log_msg::log_msg(spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level lvl, spdlog::string_view_t msg)
  : log_msg(os::now(), loc, a_logger_name, lvl, msg) {}
 
+log_msg::log_msg(spdlog::source_loc loc,
+ string_view_t a_logger_name,
+ spdlog::level lvl,
+ spdlog::string_view_t msg,
+ spdlog::log_attributes attributes)
+ : log_msg(os::now(), loc, a_logger_name, lvl, msg, attributes) {}
+
 log_msg::log_msg(string_view_t a_logger_name, spdlog::level lvl, spdlog::string_view_t msg)
  : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {}
 
+log_msg::log_msg(string_view_t a_logger_name, spdlog::level lvl, spdlog::string_view_t msg, spdlog::log_attributes attributes)
+ : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg, attributes) {}
+
 } // namespace details
 } // namespace spdlog

src/logger.cpp

@@ -102,4 +102,7 @@ void logger::err_handler_(const std::string &msg) {
 #endif
  }
 }
+
+log_attributes &logger::attrs() { return attributes; }
+
 } // namespace spdlog

src/pattern_formatter.cpp

@@ -780,6 +780,41 @@ class mdc_formatter final : public flag_formatter {
  }
 };
 
+template <typename ScopedPadder>
+class attribute_formatter final : public flag_formatter {
+public:
+ explicit attribute_formatter(padding_info padinfo)
+ : flag_formatter(padinfo) {}
+
+ void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {
+ if (msg.attributes.empty()) {
+ ScopedPadder p(0, padinfo_, dest);
+ return;
+ } else {
+ const auto &attributes = msg.attributes.get_map();
+ format_attributes(attributes, dest);
+ }
+ }
+
+ void format_attributes(const spdlog::log_attributes::attr_map_t &attributes, memory_buf_t &dest) {
+ for (auto it = attributes.begin(); it != attributes.end(); ++it) {
+ bool last_item = std::next(it) == attributes.end();
+ auto &attribute = *it;
+ const auto &key = attribute.first;
+ const auto &value = attribute.second;
+ size_t content_size = key.size() + value.size() + 1; // 1 for ':'
+
+ if (!last_item) content_size++; // 1 for ' '
+
+ ScopedPadder p(content_size, padinfo_, dest);
+ fmt_helper::append_string_view(key, dest);
+ fmt_helper::append_string_view(":", dest);
+ fmt_helper::append_string_view(value, dest);
+ if (!last_item) fmt_helper::append_string_view(" ", dest);
+ }
+ }
+};
+
 // Full info formatter
 // pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] [%s:%#] %v
 class full_formatter final : public flag_formatter {
@@ -854,6 +889,15 @@ class full_formatter final : public flag_formatter {
  dest.push_back(' ');
  }
 
+ // add attributes if present
+ if (!msg.attributes.empty()) {
+ dest.push_back('[');
+ const auto &attributes = msg.attributes.get_map();
+ attribute_formatter_.format_attributes(attributes, dest);
+ dest.push_back(']');
+ dest.push_back(' ');
+ }
+
  // add mdc if present
  auto &mdc_map = mdc::get_context();
  if (!mdc_map.empty()) {
@@ -862,12 +906,14 @@ class full_formatter final : public flag_formatter {
  dest.push_back(']');
  dest.push_back(' ');
  }
+
  fmt_helper::append_string_view(msg.payload, dest);
  }
 
 private:
  std::chrono::seconds cache_timestamp_{0};
  memory_buf_t cached_datetime_;
+ attribute_formatter<null_scoped_padder> attribute_formatter_{padding_info{}};
  mdc_formatter<null_scoped_padder> mdc_formatter_{padding_info{}};
 };
 } // namespace details
@@ -1150,6 +1196,10 @@ void pattern_formatter::handle_flag_(char flag, details::padding_info padding) {
  formatters_.push_back(std::make_unique<details::mdc_formatter<Padder>>(padding));
  break;
 
+ case ('*'):
+ formatters_.push_back(std::make_unique<details::attribute_formatter<Padder>>(padding));
+ break;
+
  default: // Unknown flag appears as is
  auto unknown_flag = std::make_unique<details::aggregate_formatter>();
 

tests/CMakeLists.txt

@@ -51,7 +51,8 @@ set(SPDLOG_UTESTS_SOURCES
  test_ringbuffer_sink.cpp
  test_source_location.cpp
  test_log_level.cpp
- test_include_sinks.cpp)
+ test_include_sinks.cpp
+ test_attributes.cpp)
 
 if(WIN32)
  list(APPEND SPDLOG_UTESTS_SOURCES test_eventlog.cpp)