✨ Use message environment when logging callback matches

Author: elbeno

include/log/env.hpp

@@ -18,13 +18,25 @@ using cib_log_env_t = stdx::env<>;
         return stdx::extend_env_t<cib_log_env_t, __VA_ARGS__>{};               \
     }()) cib_log_env_t
 
+#define CIB_APPEND_LOG_ENV_DECL(E)                                             \
+    [[maybe_unused]] typedef decltype([] {                                     \
+        return stdx::append_env_t<cib_log_env_t, E>{};                         \
+    }()) cib_log_env_t
+
 #define CIB_LOG_ENV(...)                                                       \
     STDX_PRAGMA(diagnostic push)                                               \
     STDX_PRAGMA(diagnostic ignored "-Wshadow")                                 \
     CIB_LOG_ENV_DECL(__VA_ARGS__)                                              \
     CIB_PRAGMA_SEMI                                                            \
     STDX_PRAGMA(diagnostic pop)
 
+#define CIB_APPEND_LOG_ENV(E)                                                  \
+    STDX_PRAGMA(diagnostic push)                                               \
+    STDX_PRAGMA(diagnostic ignored "-Wshadow")                                 \
+    CIB_APPEND_LOG_ENV_DECL(E)                                                 \
+    CIB_PRAGMA_SEMI                                                            \
+    STDX_PRAGMA(diagnostic pop)
+
 #define CIB_WITH_LOG_ENV(...)                                                  \
     STDX_PRAGMA(diagnostic push)                                               \
     STDX_PRAGMA(diagnostic ignored "-Wshadow")                                 \

include/msg/callback.hpp

@@ -29,11 +29,13 @@ struct callback {
 
     template <typename... Args>
     [[nodiscard]] auto handle(auto const &data, Args &&...args) const -> bool {
+        CIB_LOG_ENV(logging::get_level, logging::level::INFO);
         if (msg::call_with_message<Msg>(matcher, data)) {
-            CIB_INFO("Incoming message matched [{}], because [{}], executing "
-                     "callback",
-                     stdx::ct_string_to_type<Name, sc::string_constant>(),
-                     matcher.describe());
+            CIB_APPEND_LOG_ENV(typename Msg::env_t);
+            CIB_LOG("Incoming message matched [{}], because [{}], executing "
+                    "callback",
+                    stdx::ct_string_to_type<Name, sc::string_constant>(),
+                    matcher.describe());
             msg::call_with_message<Msg>(callable, data,
                                         std::forward<Args>(args)...);
             return true;
@@ -42,14 +44,19 @@ struct callback {
     }
 
     auto log_mismatch(auto const &data) const -> void {
-        CIB_INFO("    {} - F:({})",
-                 stdx::ct_string_to_type<Name, sc::string_constant>(),
-                 msg::call_with_message<Msg>(
-                     [&]<typename T>(T &&t) -> decltype(matcher.describe_match(
-                                                std::forward<T>(t))) {
-                         return matcher.describe_match(std::forward<T>(t));
-                     },
-                     data));
+        CIB_LOG_ENV(logging::get_level, logging::level::INFO);
+        {
+            CIB_APPEND_LOG_ENV(typename Msg::env_t);
+            CIB_LOG(
+                "    {} - F:({})",
+                stdx::ct_string_to_type<Name, sc::string_constant>(),
+                msg::call_with_message<Msg>(
+                    [&]<typename T>(T &&t) -> decltype(matcher.describe_match(
+                                               std::forward<T>(t))) {
+                        return matcher.describe_match(std::forward<T>(t));
+                    },
+                    data));
+        }
     }
 
     using msg_t = Msg;

include/msg/detail/indexed_builder_common.hpp

@@ -163,12 +163,13 @@ struct indexed_builder_base {
         }
 
         using msg_t = typename CB::msg_t;
+        CIB_LOG_ENV(logging::get_level, logging::level::INFO);
         if (msg::call_with_message<msg_t>(cb.matcher, data)) {
-            CIB_INFO(
-                "Incoming message matched [{}], because [{}] (collapsed to "
-                "[{}]), executing callback",
-                stdx::ct_string_to_type<cb.name, sc::string_constant>(),
-                orig_cb.matcher.describe(), cb.matcher.describe());
+            CIB_APPEND_LOG_ENV(typename msg_t::env_t);
+            CIB_LOG("Incoming message matched [{}], because [{}] (collapsed to "
+                    "[{}]), executing callback",
+                    stdx::ct_string_to_type<cb.name, sc::string_constant>(),
+                    orig_cb.matcher.describe(), cb.matcher.describe());
             msg::call_with_message<msg_t>(cb.callable, data, args...);
             return true;
         }

test/msg/callback.cpp

@@ -152,7 +152,7 @@ TEST_CASE("callback handles message (typed)", "[callback]") {
     CHECK(dispatched);
 }
 
-TEST_CASE("callback logs match", "[callback]") {
+TEST_CASE("callback logs match as INFO", "[callback]") {
     auto callback = msg::callback<"cb", msg_defn>(
         id_match, [](msg::const_view<msg_defn>) { dispatched = true; });
     auto const msg_match = std::array{0x8000ba11u, 0x0042d00du};
@@ -162,6 +162,22 @@ TEST_CASE("callback logs match", "[callback]") {
     CAPTURE(log_buffer);
     CHECK(log_buffer.find("matched [cb], because [id == 0x80]") !=
           std::string::npos);
+    CHECK(log_buffer.find("INFO") != std::string::npos);
+}
+
+TEST_CASE("callback logs match using message environment", "[callback]") {
+    using trace_msg_defn = msg_defn::with_env<
+        stdx::make_env_t<logging::get_level, logging::level::TRACE>>;
+    auto callback = msg::callback<"cb", trace_msg_defn>(
+        id_match, [](msg::const_view<trace_msg_defn>) { dispatched = true; });
+    auto const msg_match = std::array{0x8000ba11u, 0x0042d00du};
+
+    log_buffer.clear();
+    CHECK(callback.handle(msg_match));
+    CAPTURE(log_buffer);
+    CHECK(log_buffer.find("matched [cb], because [id == 0x80]") !=
+          std::string::npos);
+    CHECK(log_buffer.find("TRACE") != std::string::npos);
 }
 
 TEST_CASE("callback with convenience matcher", "[callback]") {