From 3ddf595c162d21ab2817bd1dda8113bba2f2a429 Mon Sep 17 00:00:00 2001 From: Dominik Charousset Date: Wed, 5 Jun 2024 09:41:02 +0200 Subject: [PATCH] Minor fixes for the new logger plus filter option --- libbroker/broker/event.hh | 43 ++++++++++++++++++++++---- libbroker/broker/logger.cc | 63 ++++++++++++++++++++++++++------------ libbroker/broker/logger.hh | 27 +++++++++++----- 3 files changed, 100 insertions(+), 33 deletions(-) diff --git a/libbroker/broker/event.hh b/libbroker/broker/event.hh index a0aee05f..8b945144 100644 --- a/libbroker/broker/event.hh +++ b/libbroker/broker/event.hh @@ -5,6 +5,7 @@ #include #include #include +#include namespace broker { @@ -36,19 +37,26 @@ public: }; /// Encodes the component that has emitted the event. - enum class component_type { + enum class component_type : uint32_t { /// The Broker core has emitted the event. - core, + core = 0b000'0001, /// The Broker endpoint has emitted the event. - endpoint, + endpoint = 0b000'0010, /// A Broker data store has emitted the event. - store, + store = 0b000'0100, /// The Broker network layer has emitted the event. - network, + network = 0b000'1000, /// A user-defined component has emitted the event. - app, + app = 0b001'0000, }; + enum class component_mask : uint32_t {}; + + static constexpr auto nil_component_mask = static_cast(0); + + static constexpr auto default_component_mask = + static_cast(0xFFFFFFFF); + /// The time when the event has been emitted. broker::timestamp timestamp; @@ -73,6 +81,29 @@ public: description(std::move(description)) {} }; +constexpr event::component_mask operator|(event::component_type lhs, + event::component_type rhs) noexcept { + auto res = static_cast(lhs) | static_cast(rhs); + return static_cast(res); +} + +constexpr event::component_mask operator|(event::component_mask lhs, + event::component_type rhs) noexcept { + auto res = static_cast(lhs) | static_cast(rhs); + return static_cast(res); +} + +constexpr event::component_mask operator|(event::component_type lhs, + event::component_mask rhs) noexcept { + auto res = static_cast(lhs) | static_cast(rhs); + return static_cast(res); +} + +constexpr bool has_component(event::component_mask mask, + event::component_type component) noexcept { + return (static_cast(mask) & static_cast(component)) != 0; +} + /// A smart pointer holding an immutable ::event. using event_ptr = std::shared_ptr; diff --git a/libbroker/broker/logger.cc b/libbroker/broker/logger.cc index e345ddb1..8aa35c2a 100644 --- a/libbroker/broker/logger.cc +++ b/libbroker/broker/logger.cc @@ -15,7 +15,7 @@ namespace { event_observer_ptr global_observer; -constexpr auto severity_color(event::severity_level level) { +constexpr caf::term severity_color(event::severity_level level) { switch (level) { default: // critical and error return caf::term::red; @@ -23,23 +23,44 @@ constexpr auto severity_color(event::severity_level level) { return caf::term::yellow; case event::severity_level::info: return caf::term::green; - case event::severity_level::debug: + case event::severity_level::verbose: return caf::term::blue; + case event::severity_level::debug: + return caf::term::cyan; + }; +} + +constexpr const char* component_tag(event::component_type component) { + switch (component) { + default: + return "[???]"; + case event::component_type::core: + return "[core]"; + case event::component_type::endpoint: + return "[endpoint]"; + case event::component_type::store: + return "[store]"; + case event::component_type::network: + return "[network]"; + case event::component_type::app: + return "[app]"; }; } -constexpr auto severity_name(event::severity_level level) { +constexpr const char* severity_name(event::severity_level level) { switch (level) { default: return "?????"; case event::severity_level::critical: - return "CRIT "; + return "CRITICAL"; case event::severity_level::error: return "ERROR"; case event::severity_level::warning: - return "WARN "; + return "WARNING"; case event::severity_level::info: - return "INFO "; + return "INFO"; + case event::severity_level::verbose: + return "VERBOSE"; case event::severity_level::debug: return "DEBUG"; }; @@ -47,8 +68,8 @@ constexpr auto severity_name(event::severity_level level) { class console_logger : public event_observer { public: - explicit console_logger(event::severity_level severity) - : severity_(severity) { + console_logger(event::severity_level severity, event::component_mask mask) + : severity_(severity), mask_(mask) { // nop } @@ -70,17 +91,19 @@ class console_logger : public event_observer { std::cout << severity_color(what->severity) << std::put_time(std::localtime(&secs), "%F %T") << '.' << msecs_str << ' ' << severity_name(what->severity) << ' ' - << what->description << caf::term::reset << std::endl; + << component_tag(what->component) << ' ' << what->description + << caf::term::reset << std::endl; } bool accepts(event::severity_level severity, - event::component_type) const override { - return severity >= severity_; + event::component_type component) const override { + return severity <= severity_ && has_component(mask_, component); } private: std::mutex mtx_; event::severity_level severity_; + event::component_mask mask_; }; } // namespace @@ -93,25 +116,27 @@ void logger(event_observer_ptr ptr) noexcept { global_observer = std::move(ptr); } -event_observer_ptr make_console_logger(event::severity_level severity) { - return std::make_shared(severity); +event_observer_ptr make_console_logger(event::severity_level severity, + event::component_mask mask) { + return std::make_shared(severity, mask); } -event_observer_ptr make_console_logger(std::string_view severity) { +event_observer_ptr make_console_logger(std::string_view severity, + event::component_mask mask) { if (severity == "critical") { - return make_console_logger(event::severity_level::critical); + return make_console_logger(event::severity_level::critical, mask); } if (severity == "error") { - return make_console_logger(event::severity_level::error); + return make_console_logger(event::severity_level::error, mask); } if (severity == "warning") { - return make_console_logger(event::severity_level::warning); + return make_console_logger(event::severity_level::warning, mask); } if (severity == "info") { - return make_console_logger(event::severity_level::info); + return make_console_logger(event::severity_level::info, mask); } if (severity == "debug") { - return make_console_logger(event::severity_level::debug); + return make_console_logger(event::severity_level::debug, mask); } throw std::invalid_argument("invalid severity level"); } diff --git a/libbroker/broker/logger.hh b/libbroker/broker/logger.hh index 5a74e0ec..7df2f9ec 100644 --- a/libbroker/broker/logger.hh +++ b/libbroker/broker/logger.hh @@ -17,22 +17,30 @@ event_observer* logger() noexcept; void logger(event_observer_ptr ptr) noexcept; /// Creates a new logger that prints to the console. -event_observer_ptr make_console_logger(event::severity_level severity); +event_observer_ptr +make_console_logger(event::severity_level severity, + event::component_mask mask = event::default_component_mask); /// Creates a new logger that prints to the console. /// @param severity The minimum severity level to log as string. One of: /// "critical", "error", "warning", "info", or "debug". /// @throws std::invalid_argument if `severity` is not a valid severity level. -event_observer_ptr make_console_logger(std::string_view severity); +event_observer_ptr +make_console_logger(std::string_view severity, + event::component_mask mask = event::default_component_mask); /// Convenience function for setting a console logger. -inline void set_console_logger(event::severity_level severity) { - logger(make_console_logger(severity)); +inline void +set_console_logger(event::severity_level severity, + event::component_mask mask = event::default_component_mask) { + logger(make_console_logger(severity, mask)); } /// Convenience function for setting a console logger. -inline void set_console_logger(std::string_view severity) { - logger(make_console_logger(severity)); +inline void +set_console_logger(std::string_view severity, + event::component_mask mask = event::default_component_mask) { + logger(make_console_logger(severity,mask)); } } // namespace broker @@ -128,8 +136,9 @@ void do_log(event::severity_level level, event::component_type component, auto msg = std::string{}; msg.reserve(fmt_str.size() + sizeof...(Ts) * 8); fmt_to(std::back_inserter(msg), fmt_str, std::forward(args)...); - lptr->observe(std::make_shared(event::severity_level::debug, component, - identifier, std::move(msg))); + auto ev = std::make_shared(level, component, identifier, + std::move(msg)); + lptr->observe(std::move(ev)); } } // namespace broker::detail @@ -184,4 +193,6 @@ BROKER_DECLARE_LOG_COMPONENT(store) BROKER_DECLARE_LOG_COMPONENT(network) +BROKER_DECLARE_LOG_COMPONENT(app) + #undef BROKER_DECLARE_LOG_COMPONENT