srslog: move prefix rendering to backend

Introduce an optional "log_label" metadata that allows for
passing custom labels (prefixes) that shall be prepended to
each log message upon rendering in the backend.

Author: robertfalkenberg

include/srsran/srslog/detail/log_entry_metadata.h

@@ -34,6 +34,7 @@ struct log_entry_metadata {
   fmt::dynamic_format_arg_store<fmt::format_context>* store;
   std::string                                         log_name;
   char                                                log_tag;
+  std::string                                         log_label;
   std::vector<uint8_t>                                hex_dump;
 };
 

include/srsran/srslog/log_channel.h

@@ -44,6 +44,13 @@ struct log_channel_config {
   bool should_print_context = false;
 };
 
+/// Strong type to wrap a constant log label that is prepended to each log message.
+struct log_label_t {
+  /// Optional log label. If set, will get printed in front of each log message.
+  /// Disabled by default.
+  std::string log_label;
+};
+
 /// A log channel is the entity used for logging messages.
 ///
 /// It can deliver a log entry to one or more different sinks, for example a
@@ -136,6 +143,38 @@ class log_channel
     backend.push(std::move(entry));
   }
 
+  /// Builds the provided log entry and passes it to the backend. When the
+  /// channel is disabled the log entry will be discarded.
+  template <typename... Args>
+  void operator()(const log_label_t& label, const char* fmtstr, Args&&... args)
+  {
+    if (!enabled()) {
+      return;
+    }
+
+    // Populate the store with all incoming arguments.
+    auto* store = backend.alloc_arg_store();
+    if (!store) {
+      return;
+    }
+    (void)std::initializer_list<int>{(push_back(store, std::forward<Args>(args)), 0)...};
+
+    // Send the log entry to the backend.
+    log_formatter&    formatter = log_sink.get_formatter();
+    detail::log_entry entry     = {&log_sink,
+                                   [&formatter](detail::log_entry_metadata&& metadata, fmt::memory_buffer& buffer) {
+                                 formatter.format(std::move(metadata), buffer);
+                               },
+                                   {std::chrono::high_resolution_clock::now(),
+                                    {ctx_value64, should_print_context},
+                                    fmtstr,
+                                    store,
+                                    log_name,
+                                    log_tag,
+                                    label.log_label}};
+    backend.push(std::move(entry));
+  }
+
   /// Builds the provided log entry and passes it to the backend. When the
   /// channel is disabled the log entry will be discarded.
   template <typename... Args>
@@ -200,6 +239,45 @@ class log_channel
                                     store,
                                     log_name,
                                     log_tag,
+                                    {},
+                                    std::vector<uint8_t>(buffer, buffer + len)}};
+    backend.push(std::move(entry));
+  }
+
+  /// Builds the provided log entry and passes it to the backend. When the
+  /// channel is disabled the log entry will be discarded.
+  template <typename... Args>
+  void operator()(const log_label_t& label, const uint8_t* buffer, size_t len, const char* fmtstr, Args&&... args)
+  {
+    if (!enabled()) {
+      return;
+    }
+
+    // Populate the store with all incoming arguments.
+    auto* store = backend.alloc_arg_store();
+    if (!store) {
+      return;
+    }
+    (void)std::initializer_list<int>{(push_back(store, std::forward<Args>(args)), 0)...};
+
+    // Calculate the length to capture in the buffer.
+    if (hex_max_size >= 0) {
+      len = std::min<size_t>(len, hex_max_size);
+    }
+
+    // Send the log entry to the backend.
+    log_formatter&    formatter = log_sink.get_formatter();
+    detail::log_entry entry     = {&log_sink,
+                                   [&formatter](detail::log_entry_metadata&& metadata, fmt::memory_buffer& buffer_) {
+                                 formatter.format(std::move(metadata), buffer_);
+                               },
+                                   {std::chrono::high_resolution_clock::now(),
+                                    {ctx_value64, should_print_context},
+                                    fmtstr,
+                                    store,
+                                    log_name,
+                                    log_tag,
+                                    label.log_label,
                                     std::vector<uint8_t>(buffer, buffer + len)}};
     backend.push(std::move(entry));
   }
@@ -237,6 +315,7 @@ class log_channel
                                     store,
                                     log_name,
                                     log_tag,
+                                    {},
                                     std::vector<uint8_t>(buffer, buffer + len)}};
     backend.push(std::move(entry));
   }
@@ -274,6 +353,45 @@ class log_channel
                                     store,
                                     log_name,
                                     log_tag,
+                                    {},
+                                    std::vector<uint8_t>(it_begin, it_end)}};
+    backend.push(std::move(entry));
+  }
+
+  /// Builds the provided log entry and passes it to the backend. When the
+  /// channel is disabled the log entry will be discarded.
+  template <typename It, typename... Args, typename std::enable_if<detail::is_byte_iterable<It>::value, int>::type = 0>
+  void operator()(const log_label_t& label, It it_begin, It it_end, const char* fmtstr, Args&&... args)
+  {
+    if (!enabled()) {
+      return;
+    }
+
+    // Populate the store with all incoming arguments.
+    auto* store = backend.alloc_arg_store();
+    if (!store) {
+      return;
+    }
+    (void)std::initializer_list<int>{(push_back(store, std::forward<Args>(args)), 0)...};
+
+    // Calculate the length to capture in the buffer.
+    if (hex_max_size >= 0 && hex_max_size < std::distance(it_begin, it_end)) {
+      it_end = it_begin + hex_max_size;
+    }
+
+    // Send the log entry to the backend.
+    log_formatter&    formatter = log_sink.get_formatter();
+    detail::log_entry entry     = {&log_sink,
+                                   [&formatter](detail::log_entry_metadata&& metadata, fmt::memory_buffer& buffer) {
+                                 formatter.format(std::move(metadata), buffer);
+                               },
+                                   {std::chrono::high_resolution_clock::now(),
+                                    {ctx_value64, should_print_context},
+                                    fmtstr,
+                                    store,
+                                    log_name,
+                                    log_tag,
+                                    label.log_label,
                                     std::vector<uint8_t>(it_begin, it_end)}};
     backend.push(std::move(entry));
   }

include/srsran/support/prefixed_logger.h

@@ -25,13 +25,18 @@ template <typename Prefix>
 class prefixed_logger
 {
 public:
-  prefixed_logger(const std::string& log_name, Prefix prefix_, const char* prefix_separator_ = "") :
-    logger(srslog::fetch_basic_logger(log_name, false)), prefix(prefix_), prefix_separator(prefix_separator_)
+  prefixed_logger(const std::string& log_name, Prefix prefix, const char* prefix_separator = "") :
+    logger(srslog::fetch_basic_logger(log_name, false))
   {
+    set_prefix(prefix, prefix_separator);
   }
 
-  void   set_prefix(Prefix prefix_) { prefix = prefix_; }
-  Prefix get_prefix() const { return prefix; }
+  void set_prefix(Prefix prefix, const char* prefix_separator = "")
+  {
+    fmt::memory_buffer buffer;
+    fmt::format_to(buffer, "{}{}", prefix, prefix_separator);
+    log_label.log_label = fmt::to_string(buffer);
+  }
 
   template <typename... Args>
   void log_debug(const char* fmt, Args&&... args) const
@@ -195,18 +200,15 @@ class prefixed_logger
 
 private:
   srslog::basic_logger& logger;
-  Prefix                prefix;
-  const char*           prefix_separator;
+  srslog::log_label_t   log_label;
 
   template <typename... Args>
   void log_helper(srslog::log_channel& channel, const char* fmt, Args&&... args) const
   {
     if (!channel.enabled()) {
       return;
     }
-    fmt::memory_buffer buffer;
-    fmt::format_to(buffer, fmt, std::forward<Args>(args)...);
-    channel("{}{}{}", prefix, prefix_separator, to_c_str(buffer));
+    channel(log_label, fmt, std::forward<Args>(args)...);
   }
 
   template <typename It, typename... Args>
@@ -215,9 +217,7 @@ class prefixed_logger
     if (!channel.enabled()) {
       return;
     }
-    fmt::memory_buffer buffer;
-    fmt::format_to(buffer, fmt, std::forward<Args>(args)...);
-    channel(it_begin, it_end, "{}{}{}", prefix, prefix_separator, to_c_str(buffer));
+    channel(log_label, it_begin, it_end, fmt, std::forward<Args>(args)...);
   }
 
   template <typename... Args>
@@ -226,9 +226,7 @@ class prefixed_logger
     if (!channel.enabled()) {
       return;
     }
-    fmt::memory_buffer buffer;
-    fmt::format_to(buffer, fmt, std::forward<Args>(args)...);
-    channel(msg, len, "{}{}{}", prefix, prefix_separator, to_c_str(buffer));
+    channel(log_label, msg, len, fmt, std::forward<Args>(args)...);
   }
 };
 

lib/srslog/formatters/text_formatter.cpp

@@ -61,6 +61,9 @@ static void format_metadata(const detail::log_entry_metadata& metadata, fmt::mem
     ctx_buffer.push_back('\0');
     fmt::format_to(buffer, "[{: >8}] ", ctx_buffer.data());
   }
+  if (!metadata.log_label.empty()) {
+    fmt::format_to(buffer, "{}", metadata.log_label);
+  }
 }
 
 void text_formatter::format(detail::log_entry_metadata&& metadata, fmt::memory_buffer& buffer)