Minor fixes for the new logger plus filter option

libbroker/broker/event.hh

@@ -5,6 +5,7 @@
 #include <memory>
 #include <string>
 #include <string_view>
+#include <vector>
 
 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<component_mask>(0);
+
+  static constexpr auto default_component_mask =
+    static_cast<component_mask>(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<uint32_t>(lhs) | static_cast<uint32_t>(rhs);
+  return static_cast<event::component_mask>(res);
+}
+
+constexpr event::component_mask operator|(event::component_mask lhs,
+                                          event::component_type rhs) noexcept {
+  auto res = static_cast<uint32_t>(lhs) | static_cast<uint32_t>(rhs);
+  return static_cast<event::component_mask>(res);
+}
+
+constexpr event::component_mask operator|(event::component_type lhs,
+                                          event::component_mask rhs) noexcept {
+  auto res = static_cast<uint32_t>(lhs) | static_cast<uint32_t>(rhs);
+  return static_cast<event::component_mask>(res);
+}
+
+constexpr bool has_component(event::component_mask mask,
+                             event::component_type component) noexcept {
+  return (static_cast<uint32_t>(mask) & static_cast<uint32_t>(component)) != 0;
+}
+
 /// A smart pointer holding an immutable ::event.
 using event_ptr = std::shared_ptr<const event>;
 

libbroker/broker/logger.cc

@@ -15,40 +15,61 @@ 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;
     case event::severity_level::warning:
       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";
   };
 }
 
 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<console_logger>(severity);
+event_observer_ptr make_console_logger(event::severity_level severity,
+                                       event::component_mask mask) {
+  return std::make_shared<console_logger>(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");
 }

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<Ts>(args)...);
-  lptr->observe(std::make_shared<event>(event::severity_level::debug, component,
-                                        identifier, std::move(msg)));
+  auto ev = std::make_shared<event>(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