Skip to content

Commit

Permalink
[Logging] Introducing Provider/Receiver pattern for logging (#1831)
Browse files Browse the repository at this point in the history 
* Split of ecal_log into log provider and receiver.

* New setting in yaml for receive configuration

* Rework of logging config structs and attributes
  • Loading branch information
@Peguen
Peguen authored Dec 9, 2024
1 parent 196033e commit 7ba8e0a
Show file tree
Hide file tree
Showing 28 changed files with 1,052 additions and 716 deletions.
2 changes: 1 addition & 1 deletion app/rec/rec_server_core/src/rec_server_impl.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -60,7 +60,7 @@ namespace eCAL
settings_.ClearHostFilter(); // There is no global host filter

// Initialize eCAL
eCAL::Initialize("", eCAL::Init::Default | eCAL::Init::Monitoring);
eCAL::Initialize("eCALRec-Server", eCAL::Init::Default | eCAL::Init::Monitoring);

// Start FTP Server
ftp_server_->start(5);
Expand Down
4 changes: 2 additions & 2 deletions ecal/core/CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -181,8 +181,8 @@ endif()
######################################
set(ecal_logging_src
src/logging/ecal_log.cpp
src/logging/ecal_log_impl.cpp
src/logging/ecal_log_impl.h
src/logging/ecal_log_provider.cpp
src/logging/ecal_log_receiver.cpp
)

######################################
Expand Down
47 changes: 30 additions & 17 deletions ecal/core/include/ecal/config/logging.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -39,50 +39,63 @@ namespace eCAL
{
namespace Logging
{
namespace Sinks
namespace Provider
{
namespace Console
struct Sink
{
bool enable; //!< Enable sink
eCAL_Logging_Filter filter_log; //!< Log messages logged (all, info, warning, error, fatal, debug1, debug2, debug3, debug4)
};

namespace File
{
struct Configuration
{
bool enable { true }; //!< Enable console logging (Default: true)
eCAL_Logging_Filter filter_log_con { log_level_error | log_level_fatal }; /*!< Log messages logged to console (all, info, warning, error, fatal, debug1, debug2, debug3, debug4)
(Default: info, warning, error, fatal)*/
std::string path { "" }; //!< Path to log file (Default: "")
};
}

namespace File
namespace UDP
{
struct Configuration
{
bool enable { false }; //!< Enable file logging (Default: false)
std::string path { "" }; //!< Path to log file (Default: "")
eCAL_Logging_Filter filter_log_file { log_level_none }; /*!< Log messages logged into file system (all, info, warning, error, fatal, debug1, debug2, debug3, debug4)
(Default: info, warning, error, fatal)*/
unsigned int port { 14001 }; //!< UDP port number (Default: 14001)
};
}

struct Configuration
{
Sink console { true, log_level_error | log_level_fatal}; //!< default: true, log_level_error
Sink file { false, log_level_none }; //!< default: false, log_level_none
Sink udp { true, log_filter_default }; //!< default: true, log_filter_default

File::Configuration file_config;
UDP::Configuration udp_config;

};
}

namespace Receiver
{
namespace UDP
{
struct Configuration
{
bool enable { true }; //!< Enable UDP logging (Default: false)
unsigned int port { 14001 }; //!< UDP port number (Default: 14001)
eCAL_Logging_Filter filter_log_udp { log_filter_default }; //!< Log messages logged via udp network (Default: info, warning, error, fatal)
unsigned int port { 14001 }; //!< UDP port number (Default: 14001)
};
}

struct Configuration
{
Console::Configuration console;
File::Configuration file;
UDP::Configuration udp;
bool enable { false }; //!< Enable UDP receiver (Default: false)
UDP::Configuration udp_config;
};
}

struct Configuration
{
Sinks::Configuration sinks;
Provider::Configuration provider;
Receiver::Configuration receiver;
};
}
}
54 changes: 32 additions & 22 deletions ecal/core/src/config/builder/logging_attribute_builder.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,60 +6,70 @@ namespace eCAL
{
namespace Logging
{
SAttributes BuildLoggingAttributes(const Logging::Configuration& log_config_, const Registration::Configuration& reg_config_, const TransportLayer::Configuration& tl_config_)
SProviderAttributes BuildLoggingProviderAttributes(const Logging::Configuration& log_config_, const Registration::Configuration& reg_config_, const TransportLayer::Configuration& tl_config_)
{
SAttributes attributes;
SProviderAttributes attributes;

attributes.network_enabled = reg_config_.network_enabled;
attributes.host_name = Process::GetHostName();
attributes.process_id = Process::GetProcessID();
attributes.process_name = Process::GetProcessName();
attributes.unit_name = Process::GetUnitName();
attributes.level = log_level_info;

attributes.udp.enabled = log_config_.sinks.udp.enable;
attributes.udp.port = log_config_.sinks.udp.port;
attributes.udp.filter_log = log_config_.sinks.udp.filter_log_udp;
attributes.udp_sink.enabled = log_config_.provider.udp.enable;
attributes.udp_sink.filter_log = log_config_.provider.udp.filter_log;

attributes.file.enabled = log_config_.sinks.file.enable;
attributes.file.filter_log = log_config_.sinks.file.filter_log_file;
attributes.file.path = log_config_.sinks.file.path;
if (attributes.file.path.empty())
attributes.file_sink.enabled = log_config_.provider.file.enable;
attributes.file_sink.filter_log = log_config_.provider.file.filter_log;
attributes.file_config.path = log_config_.provider.file_config.path;
if (attributes.file_config.path.empty())
{
// check ECAL_DATA
// Creates path if not exists
attributes.file.path = Util::GeteCALLogPath();
attributes.file_config.path = Util::GeteCALLogPath();
}

attributes.console.enabled = log_config_.sinks.console.enable;
attributes.console.filter_log = log_config_.sinks.console.filter_log_con;
attributes.console_sink.enabled = log_config_.provider.console.enable;
attributes.console_sink.filter_log = log_config_.provider.console.filter_log;

// UDP related configuration part
attributes.udp_sender.broadcast = !reg_config_.network_enabled;
attributes.udp_sender.loopback = reg_config_.loopback;
attributes.udp_config.broadcast = !reg_config_.network_enabled;
attributes.udp_config.loopback = reg_config_.loopback;

attributes.udp_sender.sndbuf = tl_config_.udp.send_buffer;
attributes.udp_sender.port = tl_config_.udp.port;
attributes.udp_config.sndbuf = tl_config_.udp.send_buffer;
attributes.udp_config.port = log_config_.provider.udp_config.port;

switch (tl_config_.udp.mode)
{
case Types::UDPMode::NETWORK:
attributes.udp_sender.address = tl_config_.udp.network.group;
attributes.udp_sender.ttl = tl_config_.udp.network.ttl;
attributes.udp_config.address = tl_config_.udp.network.group;
attributes.udp_config.ttl = tl_config_.udp.network.ttl;
break;
case Types::UDPMode::LOCAL:
attributes.udp_sender.address = tl_config_.udp.local.group;
attributes.udp_sender.ttl = tl_config_.udp.local.ttl;
attributes.udp_config.address = tl_config_.udp.local.group;
attributes.udp_config.ttl = tl_config_.udp.local.ttl;
break;
default:
break;
}

return attributes;
}

SReceiverAttributes BuildLoggingReceiverAttributes(const Logging::Configuration& log_config_, const Registration::Configuration& reg_config_, const TransportLayer::Configuration& tl_config_)
{
SReceiverAttributes attributes;

attributes.network_enabled = reg_config_.network_enabled;
attributes.host_name = Process::GetHostName();

attributes.receive_enabled = log_config_.receiver.enable;

attributes.udp_receiver.broadcast = !reg_config_.network_enabled;
attributes.udp_receiver.loopback = true;

attributes.udp_receiver.rcvbuf = tl_config_.udp.receive_buffer;
attributes.udp_receiver.port = tl_config_.udp.port;
attributes.udp_receiver.port = log_config_.receiver.udp_config.port;

switch (tl_config_.udp.mode)
{
Expand Down
6 changes: 4 additions & 2 deletions ecal/core/src/config/builder/logging_attribute_builder.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,7 +19,8 @@

#pragma once

#include "logging/config/attributes/logging_attributes.h"
#include "logging/config/attributes/ecal_log_provider_attributes.h"
#include "logging/config/attributes/ecal_log_receiver_attributes.h"
#include "ecal/config/logging.h"
#include "ecal/config/registration.h"
#include "ecal/config/transport_layer.h"
Expand All @@ -28,6 +29,7 @@ namespace eCAL
{
namespace Logging
{
SAttributes BuildLoggingAttributes(const Logging::Configuration& log_config_, const Registration::Configuration& reg_config_, const TransportLayer::Configuration& tl_config_);
SProviderAttributes BuildLoggingProviderAttributes(const Logging::Configuration& log_config_, const Registration::Configuration& reg_config_, const TransportLayer::Configuration& tl_config_);
SReceiverAttributes BuildLoggingReceiverAttributes(const Logging::Configuration& log_config_, const Registration::Configuration& reg_config_, const TransportLayer::Configuration& tl_config_);
}
}
84 changes: 52 additions & 32 deletions ecal/core/src/config/configuration_to_yaml.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -576,91 +576,111 @@ namespace YAML
/____/\___/\_, /\_, /_/_//_/\_, /
/___//___/ /___/
*/
Node convert<eCAL::Logging::Sinks::UDP::Configuration>::encode(const eCAL::Logging::Sinks::UDP::Configuration& config_)

Node convert<eCAL::Logging::Receiver::UDP::Configuration>::encode(const eCAL::Logging::Receiver::UDP::Configuration& config_)
{
Node node;
node["enable"] = config_.enable;
node["port"] = config_.port;
node["level"] = LogLevelToVector(config_.filter_log_udp);
return node;
}

bool convert<eCAL::Logging::Sinks::UDP::Configuration>::decode(const Node& node_, eCAL::Logging::Sinks::UDP::Configuration& config_)
bool convert<eCAL::Logging::Receiver::UDP::Configuration>::decode(const Node& node_, eCAL::Logging::Receiver::UDP::Configuration& config_)
{
AssignValue<bool>(config_.enable, node_, "enable");
AssignValue<unsigned int>(config_.port, node_, "port");
return true;
}

std::vector<std::string> tmp;
AssignValue<std::vector<std::string>>(tmp, node_, "level");
config_.filter_log_udp = ParseLogLevel(tmp);
Node convert<eCAL::Logging::Receiver::Configuration>::encode(const eCAL::Logging::Receiver::Configuration& config_)
{
Node node;
node["enable"] = config_.enable;
node["udp_config"] = config_.udp_config;
return node;
}

bool convert<eCAL::Logging::Receiver::Configuration>::decode(const Node& node_, eCAL::Logging::Receiver::Configuration& config_)
{
AssignValue<bool>(config_.enable, node_, "enable");
AssignValue<eCAL::Logging::Receiver::UDP::Configuration>(config_.udp_config, node_, "udp_config");
return true;
}

Node convert<eCAL::Logging::Sinks::Console::Configuration>::encode(const eCAL::Logging::Sinks::Console::Configuration& config_)
Node convert<eCAL::Logging::Provider::UDP::Configuration>::encode(const eCAL::Logging::Provider::UDP::Configuration& config_)
{
Node node;
node["port"] = config_.port;
return node;
}

bool convert<eCAL::Logging::Provider::UDP::Configuration>::decode(const Node& node_, eCAL::Logging::Provider::UDP::Configuration& config_)
{
AssignValue<unsigned int>(config_.port, node_, "port");
return true;
}

Node convert<eCAL::Logging::Provider::Sink>::encode(const eCAL::Logging::Provider::Sink& config_)
{
Node node;
node["enable"] = config_.enable;
node["level"] = LogLevelToVector(config_.filter_log_con);
node["level"] = LogLevelToVector(config_.filter_log);
return node;
}

bool convert<eCAL::Logging::Sinks::Console::Configuration>::decode(const Node& node_, eCAL::Logging::Sinks::Console::Configuration& config_)
bool convert<eCAL::Logging::Provider::Sink>::decode(const Node& node_, eCAL::Logging::Provider::Sink& config_)
{
AssignValue<bool>(config_.enable, node_, "enable");
std::vector<std::string> tmp;
AssignValue<std::vector<std::string>>(tmp, node_, "level");
config_.filter_log_con = ParseLogLevel(tmp);
config_.filter_log = ParseLogLevel(tmp);
return true;
}

Node convert<eCAL::Logging::Sinks::File::Configuration>::encode(const eCAL::Logging::Sinks::File::Configuration& config_)
Node convert<eCAL::Logging::Provider::File::Configuration>::encode(const eCAL::Logging::Provider::File::Configuration& config_)
{
Node node;
node["enable"] = config_.enable;
node["path"] = config_.path;
node["level"] = LogLevelToVector(config_.filter_log_file);
return node;
}

bool convert<eCAL::Logging::Sinks::File::Configuration>::decode(const Node& node_, eCAL::Logging::Sinks::File::Configuration& config_)
bool convert<eCAL::Logging::Provider::File::Configuration>::decode(const Node& node_, eCAL::Logging::Provider::File::Configuration& config_)
{
AssignValue<bool>(config_.enable, node_, "enable");
AssignValue<std::string>(config_.path, node_, "path");

std::vector<std::string> tmp;
AssignValue<std::vector<std::string>>(tmp, node_, "level");
config_.filter_log_file = ParseLogLevel(tmp);
return true;
}

Node convert<eCAL::Logging::Sinks::Configuration>::encode(const eCAL::Logging::Sinks::Configuration& config_)
Node convert<eCAL::Logging::Provider::Configuration>::encode(const eCAL::Logging::Provider::Configuration& config_)
{
Node node;
node["console"] = config_.console;
node["file"] = config_.file;
node["udp"] = config_.udp;
node["console"] = config_.console;
node["file"] = config_.file;
node["udp"] = config_.udp;
node["file_config"] = config_.file_config;
node["udp_config"] = config_.udp_config;
return node;
}

bool convert<eCAL::Logging::Sinks::Configuration>::decode(const Node& node_, eCAL::Logging::Sinks::Configuration& config_)
bool convert<eCAL::Logging::Provider::Configuration>::decode(const Node& node_, eCAL::Logging::Provider::Configuration& config_)
{
AssignValue<eCAL::Logging::Sinks::Console::Configuration>(config_.console, node_, "console");
AssignValue<eCAL::Logging::Sinks::File::Configuration>(config_.file, node_, "file");
AssignValue<eCAL::Logging::Sinks::UDP::Configuration>(config_.udp, node_, "udp");
AssignValue<eCAL::Logging::Provider::Sink>(config_.console, node_, "console");
AssignValue<eCAL::Logging::Provider::Sink>(config_.file, node_, "file");
AssignValue<eCAL::Logging::Provider::Sink>(config_.udp, node_, "udp");
AssignValue<eCAL::Logging::Provider::UDP::Configuration>(config_.udp_config, node_, "udp_config");
AssignValue<eCAL::Logging::Provider::File::Configuration>(config_.file_config, node_, "file_config");
return true;
}

Node convert<eCAL::Logging::Configuration>::encode(const eCAL::Logging::Configuration& config_)
{
Node node;
node["sinks"] = config_.sinks;
node["provider"] = config_.provider;
node["receiver"] = config_.receiver;
return node;
}

bool convert<eCAL::Logging::Configuration>::decode(const Node& node_, eCAL::Logging::Configuration& config_)
{
AssignValue<eCAL::Logging::Sinks::Configuration>(config_.sinks, node_, "sinks");
AssignValue<eCAL::Logging::Provider::Configuration>(config_.provider, node_, "provider");
AssignValue<eCAL::Logging::Receiver::Configuration>(config_.receiver, node_, "receiver");
return true;
}

Expand Down
Loading

0 comments on commit 7ba8e0a

Please sign in to comment.