🎨 Move log flavor into logging environment

CMakeLists.txt

@@ -135,6 +135,7 @@ target_sources(
               include
               FILES
               include/log/env.hpp
+              include/log/flavor.hpp
               include/log/level.hpp
               include/log/log.hpp
               include/log/module.hpp)

docs/logging.adoc

@@ -86,18 +86,16 @@ implementation is a matter of defining this structure appropriately.
 ----
 struct my_logger_config {
   struct {
-    template <logging::level L, typename ModuleId,
-              typename File, typename Line, typename Msg>
+    template <typename Env, typename File, typename Line, typename Msg>
     auto log(File, Line, Msg const &msg) -> void {
       // log according to my mechanism
     }
   } logger;
 };
 ----
 
-Notice that the first two template parameters to log are the
-xref:logging.adoc#_log_levels[level] and the xref:logging.adoc#_modules[module
-ID]. The `ModuleId` type is a xref:sc.adoc#_string_constants[compile-time string].
+Notice that the first template parameters to log is the
+xref:logging.adoc#_logging_environments[environment].
 
 The first two runtime parameters receive preprocessor `\_​_FILE_​\_` and `__LINE_​_` values
 respectively. The `msg` argument is a structure containing a
@@ -109,8 +107,7 @@ way to implement `log` is:
 ----
 struct my_logger_config {
   struct {
-    template <logging::level L, typename ModuleId,
-              typename File, typename Line, typename Msg>
+    template <typename Env, typename File, typename Line, typename Msg>
     auto log(File, Line, Msg const &msg) -> void {
       msg.apply([] <typename Str> (Str, auto const&... args) {
         std::print(Str::value, args...);
@@ -236,3 +233,47 @@ The easiest way to flavor the version logging is to define a macro in terms of
 ----
 #define LOG_SECURE_VERSION(...) CIB_LOG_V(secure_tag)
 ----
+
+=== Logging environments
+
+The logging environment is a compile-time map from types to values that allows a
+logger to look up various parameters, including the module ID, the log level,
+and the flavor. It can also be used to provide user-defined values to be
+interpreted by a logging backend.
+
+The macros that implement logging with various levels, modules, and flavors
+are implemented as environment declarations, for example:
+[source,cpp]
+----
+CIB_LOG_ENV(logging::get_level, logging::level::TRACE);
+CIB_LOG("Hello");  // logs with TRACE level
+----
+or:
+[source,cpp]
+----
+CIB_LOG_ENV(logging::get_flavor, secure_tag);
+CIB_TRACE("Hello");  // logs with secure back end
+----
+A temporary override of values can be done with `CIB_WITH_LOG_ENV`:
+[source,cpp]
+----
+CIB_WITH LOG_ENV(logging::get_level, logging::level::TRACE,
+                 logging::get_flavor, secure_tag) {
+  CIB_LOG("Hello");  // logs a TRACE with secure back end
+}
+----
+
+To interrogate the environment from a custom logger, use the appropriate query
+on the environment.
+[source,cpp]
+----
+struct my_logger_config {
+  struct {
+    template <typename Env, typename File, typename Line, typename Msg>
+    auto log(File, Line, Msg const &msg) -> void {
+      constexpr auto level = get_level(Env{}).value;
+      // ...
+    }
+  } logger;
+};
+----

include/flow/impl.hpp

@@ -3,11 +3,13 @@
 #include <flow/common.hpp>
 #include <flow/log.hpp>
 #include <log/env.hpp>
+#include <log/flavor.hpp>
 #include <log/level.hpp>
 #include <log/log.hpp>
 
 #include <stdx/ct_string.hpp>
 #include <stdx/span.hpp>
+#include <stdx/type_traits.hpp>
 
 #include <algorithm>
 #include <array>
@@ -22,9 +24,11 @@ constexpr auto run_func() -> void {
         if constexpr (not FlowName.empty()) {
             using log_spec_t =
                 decltype(get_log_spec<CTNode, log_spec_id_t<FlowName>>());
-            CIB_LOG_ENV(logging::get_level, log_spec_t::level);
-            CIB_LOG(typename log_spec_t::flavor, "flow.{}({})",
-                    typename CTNode::type_t{}, typename CTNode::name_t{});
+            CIB_LOG_ENV(logging::get_level, log_spec_t::level,
+                        logging::get_flavor,
+                        stdx::type_identity<typename log_spec_t::flavor>{});
+            CIB_LOG("flow.{}({})", typename CTNode::type_t{},
+                    typename CTNode::name_t{});
         }
         typename CTNode::func_t{}();
     }
@@ -62,16 +66,20 @@ template <stdx::ct_string Name, auto... FuncPtrs> struct inlined_func_list {
 
         if constexpr (loggingEnabled) {
             using log_spec_t = decltype(get_log_spec<inlined_func_list>());
-            CIB_LOG_ENV(logging::get_level, log_spec_t::level);
-            CIB_LOG(typename log_spec_t::flavor, "flow.start({})", name);
+            CIB_LOG_ENV(logging::get_level, log_spec_t::level,
+                        logging::get_flavor,
+                        stdx::type_identity<typename log_spec_t::flavor>{});
+            CIB_LOG("flow.start({})", name);
         }
 
         (FuncPtrs(), ...);
 
         if constexpr (loggingEnabled) {
             using log_spec_t = decltype(get_log_spec<inlined_func_list>());
-            CIB_LOG_ENV(logging::get_level, log_spec_t::level);
-            CIB_LOG(typename log_spec_t::flavor, "flow.end({})", name);
+            CIB_LOG_ENV(logging::get_level, log_spec_t::level,
+                        logging::get_flavor,
+                        stdx::type_identity<typename log_spec_t::flavor>{});
+            CIB_LOG("flow.end({})", name);
         }
     }
 };

include/log/env.hpp

@@ -77,8 +77,11 @@ constexpr auto make_env = []<detail::autowrap... Args> {
     return boost::mp11::mp_append<new_env_t, Env>{};
 };
 
+template <typename Env, detail::autowrap... Args>
+using extend_env_t = decltype(make_env<Env>.template operator()<Args...>());
+
 template <detail::autowrap... Args>
-using make_env_t = decltype(make_env<>.template operator()<Args...>());
+using make_env_t = extend_env_t<env<>, Args...>;
 } // namespace logging
 
 using cib_log_env_t = logging::env<>;
@@ -92,13 +95,9 @@ using cib_log_env_t = logging::env<>;
 #endif
 
 #define CIB_LOG_ENV_DECL(...)                                                  \
-    [[maybe_unused]] typedef decltype([]<logging::detail::                     \
-                                             autowrap... _env_args> {          \
-        using new_env_t =                                                      \
-            typename logging::detail::for_each_pair<std::make_index_sequence<  \
-                sizeof...(_env_args) / 2>>::template type<_env_args...>;       \
-        return boost::mp11::mp_append<new_env_t, cib_log_env_t>{};             \
-    }.template operator()<__VA_ARGS__>()) cib_log_env_t
+    [[maybe_unused]] typedef decltype([] {                                     \
+        return logging::extend_env_t<cib_log_env_t, __VA_ARGS__>{};            \
+    }()) cib_log_env_t
 
 #define CIB_LOG_ENV(...)                                                       \
     STDX_PRAGMA(diagnostic push)                                               \

include/log/flavor.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <stdx/compiler.hpp>
+#include <stdx/utility.hpp>
+
+#include <utility>
+
+namespace logging {
+struct default_flavor_t;
+
+[[maybe_unused]] constexpr inline struct get_flavor_t {
+    template <typename T>
+        requires true
+    CONSTEVAL auto operator()(T &&t) const noexcept(
+        noexcept(std::forward<T>(t).query(std::declval<get_flavor_t>())))
+        -> decltype(std::forward<T>(t).query(*this)) {
+        return std::forward<T>(t).query(*this);
+    }
+
+    CONSTEVAL auto operator()(auto &&) const {
+        return stdx::ct<stdx::type_identity<default_flavor_t>{}>();
+    }
+} get_flavor;
+} // namespace logging

include/log/level.hpp

@@ -2,6 +2,7 @@
 
 #include <log/env.hpp>
 
+#include <stdx/compiler.hpp>
 #include <stdx/type_traits.hpp>
 
 #include <array>

include/log/log.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <log/env.hpp>
+#include <log/flavor.hpp>
 #include <log/level.hpp>
 #include <log/module.hpp>
 #include <sc/format.hpp>
@@ -9,6 +10,8 @@
 #include <stdx/compiler.hpp>
 #include <stdx/ct_string.hpp>
 #include <stdx/panic.hpp>
+#include <stdx/type_traits.hpp>
+#include <stdx/utility.hpp>
 
 #include <cstdint>
 #include <utility>
@@ -35,35 +38,33 @@ struct config {
 
 template <typename...> inline auto config = null::config{};
 
-struct default_flavor_t;
-
-template <typename Flavor, typename... Ts>
+template <typename Env, typename... Ts>
 ALWAYS_INLINE constexpr static auto get_config() -> auto & {
-    if constexpr (std::same_as<Flavor, default_flavor_t>) {
+    using flavor_t = typename decltype(get_flavor(Env{}).value)::type;
+    if constexpr (std::same_as<flavor_t, default_flavor_t>) {
         return config<Ts...>;
     } else {
-        return config<Flavor, Ts...>;
+        return config<flavor_t, Ts...>;
     }
 }
 
-template <typename Flavor, typename Env, typename... Ts, typename... TArgs>
+template <typename Env, typename... Ts, typename... TArgs>
 ALWAYS_INLINE static auto log(TArgs &&...args) -> void {
-    auto &cfg = get_config<Flavor, Ts...>();
+    auto &cfg = get_config<Env, Ts...>();
     cfg.logger.template log<Env>(std::forward<TArgs>(args)...);
 }
 } // namespace logging
 
 // NOLINTBEGIN(cppcoreguidelines-macro-usage)
 
-#define CIB_LOG(FLAVOR, MSG, ...)                                              \
-    logging::log<FLAVOR, cib_log_env_t>(                                       \
+#define CIB_LOG(MSG, ...)                                                      \
+    logging::log<cib_log_env_t>(                                               \
         __FILE__, __LINE__, sc::format(MSG##_sc __VA_OPT__(, ) __VA_ARGS__))
 
-#define CIB_LOG_WITH_LEVEL(LEVEL, ...)                                         \
-    do {                                                                       \
-        CIB_LOG_ENV(logging::get_level, LEVEL);                                \
-        CIB_LOG(logging::default_flavor_t __VA_OPT__(, ) __VA_ARGS__);         \
-    } while (false)
+#define CIB_LOG_WITH_LEVEL(LEVEL, MSG, ...)                                    \
+    logging::log<                                                              \
+        logging::extend_env_t<cib_log_env_t, logging::get_level, LEVEL>>(      \
+        __FILE__, __LINE__, sc::format(MSG##_sc __VA_OPT__(, ) __VA_ARGS__))
 
 #define CIB_TRACE(...)                                                         \
     CIB_LOG_WITH_LEVEL(logging::level::TRACE __VA_OPT__(, ) __VA_ARGS__)
@@ -77,8 +78,7 @@ ALWAYS_INLINE static auto log(TArgs &&...args) -> void {
 #define CIB_FATAL(MSG, ...)                                                    \
     [](auto &&str) {                                                           \
         CIB_LOG_ENV(logging::get_level, logging::level::FATAL);                \
-        logging::log<logging::default_flavor_t, cib_log_env_t>(__FILE__,       \
-                                                               __LINE__, str); \
+        logging::log<cib_log_env_t>(__FILE__, __LINE__, str);                  \
         FWD(str).apply([]<typename S, typename... Args>(S s, Args... args) {   \
             constexpr auto cts = stdx::ct_string_from_type(s);                 \
             stdx::panic<cts>(args...);                                         \
@@ -89,9 +89,9 @@ ALWAYS_INLINE static auto log(TArgs &&...args) -> void {
     ((expr) ? void(0) : CIB_FATAL("Assertion failure: " #expr))
 
 namespace logging {
-template <typename Flavor, typename... Ts>
+template <typename Env, typename... Ts>
 ALWAYS_INLINE static auto log_version() -> void {
-    auto &l_cfg = get_config<Flavor, Ts...>();
+    auto &l_cfg = get_config<Env, Ts...>();
     auto &v_cfg = ::version::config<Ts...>;
     if constexpr (requires {
                       l_cfg.logger.template log_build<v_cfg.build_id,
@@ -109,7 +109,9 @@ ALWAYS_INLINE static auto log_version() -> void {
 }
 } // namespace logging
 
-#define CIB_LOG_V(FLAVOR) logging::log_version<FLAVOR>()
+#define CIB_LOG_V(FLAVOR)                                                      \
+    logging::log_version<logging::extend_env_t<                                \
+        cib_log_env_t, logging::get_flavor, stdx::type_identity<FLAVOR>{}>>()
 #define CIB_LOG_VERSION() CIB_LOG_V(logging::default_flavor_t)
 
 // NOLINTEND(cppcoreguidelines-macro-usage)

test/log/fmt_logger.cpp

@@ -1,6 +1,7 @@
 #include <log/fmt/logger.hpp>
 
 #include <stdx/ct_string.hpp>
+#include <stdx/type_traits.hpp>
 #include <stdx/utility.hpp>
 
 #include <catch2/catch_test_macros.hpp>
@@ -161,17 +162,24 @@ template <>
 inline auto logging::config<secure_t> =
     logging::fmt::config{std::back_inserter(secure_buffer)};
 
+#define SECURE_TRACE(MSG, ...)                                                 \
+    logging::log<logging::extend_env_t<                                        \
+        cib_log_env_t, logging::get_level, logging::level::TRACE,              \
+        logging::get_flavor, stdx::type_identity<secure_t>{}>>(                \
+        __FILE__, __LINE__, sc::format(MSG##_sc __VA_OPT__(, ) __VA_ARGS__))
+
 TEST_CASE("logging can be flavored", "[fmt_logger]") {
-    CIB_LOG_ENV(logging::get_level, logging::level::TRACE);
     buffer.clear();
     secure_buffer.clear();
-    CIB_LOG(secure_t, "Hello");
+    SECURE_TRACE("Hello");
     CAPTURE(secure_buffer);
     CHECK(secure_buffer.substr(secure_buffer.size() - std::size("Hello")) ==
           "Hello\n");
     CHECK(buffer.empty());
 }
 
+#undef SECURE_TRACE
+
 TEST_CASE("log version can be flavored", "[fmt_logger]") {
     buffer.clear();
     secure_buffer.clear();

test/log/level.cpp

@@ -39,7 +39,7 @@ struct fmt::formatter<std::integral_constant<custom_level, L>> {
 TEST_CASE("fmt logger works with custom level", "[level]") {
     CIB_LOG_ENV(logging::get_level, custom_level::THE_ONE_LEVEL);
     buffer.clear();
-    CIB_LOG(logging::default_flavor_t, "Hello");
+    CIB_LOG("Hello");
     CAPTURE(buffer);
     CHECK(buffer.find("THE_ONE_LEVEL [default]:") != std::string::npos);
 }