srslog: Implemented a UDP sink

Author: faluco

apps/gnb/gnb.cpp

@@ -383,7 +383,7 @@ int main(int argc, char** argv)
 
   // Set up the JSON log channel used by metrics.
   srslog::sink& json_sink =
-      srslog::fetch_file_sink(gnb_cfg.metrics_cfg.json_filename, 0, false, srslog::create_json_formatter());
+      srslog::fetch_udp_sink("127.0.0.1", 10000, srslog::create_json_formatter());
   srslog::log_channel& json_channel = srslog::fetch_log_channel("JSON_channel", json_sink, {});
   json_channel.set_enabled(gnb_cfg.metrics_cfg.enable_json_metrics);
 

configs/gnb_ru_ran550_tdd_n78_20mhz.yml

@@ -1,3 +1,4 @@
+
 # This example configuration outlines how to configure the srsRAN Project CU/DU to use an O-RU and split 7.2. This is specifically for use
 # with the Benetel R550 RU. This config will create a single TDD MIMO cell transmitting in band 78, with 20 MHz bandwidth and 30 kHz sub-carrier-spacing.
 # The parameters used to configure the RU are found in the `ru_ofh` sub-section. This configuration makes used of the OFH Lib from SRS to enable split 7.2.

include/srsran/srslog/srslog.h

@@ -191,6 +191,11 @@ sink& fetch_syslog_sink(const std::string&             preamble_  = "",
                         syslog_local_type              log_local_ = syslog_local_type::local0,
                         std::unique_ptr<log_formatter> f          = get_default_log_formatter());
 
+/// Returns an instance of a sink that writes to a UDP socket using the given remote IP address and port.
+sink& fetch_udp_sink(const std::string&             remote_ip,
+                     unsigned                       port,
+                     std::unique_ptr<log_formatter> f = get_default_log_formatter());
+
 /// Installs a custom user defined sink in the framework getting associated to
 /// the specified id. Returns true on success, otherwise false.
 /// WARNING: This function is an advanced feature and users should really know

lib/srslog/sinks/udp_sink.h

@@ -0,0 +1,68 @@
+/*
+ *
+ * Copyright 2021-2023 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#pragma once
+
+#include "srsran/srslog/sink.h"
+#include <arpa/inet.h>
+#include <unistd.h>
+
+namespace srslog {
+
+/// This sink implementation writes to a UDP socket.
+class udp_sink : public sink
+{
+public:
+  udp_sink(std::string remote_ip_, unsigned port_, std::unique_ptr<log_formatter> f) :
+    sink(std::move(f)), remote_ip(std::move(remote_ip_)), port(port_)
+  {
+  }
+
+  ~udp_sink() { ::close(socket_fd); }
+
+  udp_sink(const udp_sink& other)            = delete;
+  udp_sink& operator=(const udp_sink& other) = delete;
+
+  detail::error_string write(detail::memory_buffer buffer) override
+  {
+    if (socket_fd == -1) {
+      socket_fd = ::socket(AF_INET, SOCK_DGRAM, 0);
+      if (socket_fd < 0) {
+        return "Cannot create UDP socket";
+      }
+
+      remote_address            = {};
+      remote_address.sin_family = AF_INET;
+      remote_address.sin_port   = ::htons(port);
+      if (::inet_pton(AF_INET, remote_ip.c_str(), &remote_address.sin_addr) < 1) {
+        return "Invalid IP address format";
+      }
+    }
+
+    ::sendto(socket_fd,
+             buffer.data(),
+             buffer.size(),
+             0,
+             reinterpret_cast<const struct sockaddr*>(&remote_address),
+             sizeof(remote_address));
+
+    return {};
+  }
+
+  detail::error_string flush() override { return {}; }
+
+private:
+  std::string   remote_ip;
+  unsigned      port;
+  int           socket_fd = -1;
+  ::sockaddr_in remote_address;
+};
+
+} // namespace srslog

lib/srslog/srslog.cpp

@@ -12,6 +12,7 @@
 #include "formatters/json_formatter.h"
 #include "sinks/file_sink.h"
 #include "sinks/syslog_sink.h"
+#include "sinks/udp_sink.h"
 #include "srslog_instance.h"
 
 using namespace srslog;
@@ -186,6 +187,21 @@ sink& srslog::fetch_syslog_sink(const std::string&             preamble_,
   return *s;
 }
 
+sink& srslog::fetch_udp_sink(const std::string& remote_ip, unsigned port, std::unique_ptr<log_formatter> f)
+{
+  std::string id = remote_ip + ':' + std::to_string(port);
+  if (auto* s = find_sink(id)) {
+    return *s;
+  }
+
+  auto& s = srslog_instance::get().get_sink_repo().emplace(
+      std::piecewise_construct,
+      std::forward_as_tuple(id),
+      std::forward_as_tuple(new udp_sink(remote_ip, port, std::move(f))));
+
+  return *s;
+}
+
 bool srslog::install_custom_sink(const std::string& id, std::unique_ptr<sink> s)
 {
   assert(!id.empty() && "Empty path string");