kernel: implement levels-based logging C API

Because logging is now structured, bitcoinkernel users can implement
their own filtering logic using the btck_LogEntry fields.

Simplify the interface by replacing the category/levels setters with
a single global btck_logging_set_min_level function.

Implements a kernel-specific g_dispatcher with the levels-based
filtering, so kernel's dependency on logging.cpp is now removed
entirely.

Author: stickies-v

contrib/valgrind.supp

@@ -48,6 +48,13 @@
    fun:_Znwm
    fun:_Z11LogInstancev
 }
+{
+   Suppress g_kernel_logger still reachable memory warning
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:_Znwm
+   fun:_ZL15g_kernel_loggerv
+}
 {
    Suppress BCLog::Logger::StartLogging() still reachable memory warning
    Memcheck:Leak

src/kernel/CMakeLists.txt

@@ -30,7 +30,6 @@ add_library(bitcoinkernel
   ../deploymentstatus.cpp
   ../flatfile.cpp
   ../hash.cpp
-  ../logging.cpp
   ../node/blockstorage.cpp
   ../node/chainstate.cpp
   ../node/utxo_snapshot.cpp

src/kernel/bitcoinkernel.cpp

@@ -16,7 +16,6 @@
 #include <kernel/context.h>
 #include <kernel/notifications_interface.h>
 #include <kernel/warning.h>
-#include <logging.h>
 #include <node/blockstorage.h>
 #include <node/chainstate.h>
 #include <primitives/block.h>
@@ -29,6 +28,7 @@
 #include <uint256.h>
 #include <undo.h>
 #include <util/fs.h>
+#include <util/log.h>
 #include <util/result.h>
 #include <util/signalinterrupt.h>
 #include <util/string.h>
@@ -39,6 +39,7 @@
 #include <validationinterface.h>
 
 #include <array>
+#include <atomic>
 #include <cassert>
 #include <cstddef>
 #include <cstring>
@@ -54,6 +55,26 @@
 #include <utility>
 #include <vector>
 
+struct KernelLogger {
+    std::atomic<util::log::Level> min_level{util::log::Level::Info};
+    util::log::Dispatcher dispatcher{[this](util::log::Level level, uint64_t) {
+        return level >= min_level.load(std::memory_order_relaxed);
+    }};
+};
+
+// Kernel logging state. Intentionally leaked to avoid use-after-destroy if logging occurs during
+// static destruction.
+static KernelLogger& g_kernel_logger()
+{
+    static KernelLogger* p{new KernelLogger{}};
+    return *p;
+}
+
+util::log::Dispatcher& util::log::g_dispatcher()
+{
+    return g_kernel_logger().dispatcher;
+}
+
 using kernel::ChainstateRole;
 using util::ImmediateTaskRunner;
 
@@ -203,11 +224,6 @@ constexpr auto LOG_CATEGORIES = [] {
     return a;
 }();
 
-constexpr BCLog::LogFlags get_bclog_flag(btck_LogCategory category)
-{
-    return LOG_CATEGORIES[category].bclog;
-}
-
 btck_LogCategory get_btck_category(BCLog::LogFlags flag)
 {
     for (size_t i = 0; i < LOG_CATEGORIES.size(); ++i) {
@@ -750,24 +766,9 @@ void btck_txid_destroy(btck_Txid* txid)
     delete txid;
 }
 
-void btck_logging_set_level_category(btck_LogCategory category, btck_LogLevel level)
-{
-    LOCK(cs_main);
-    if (category == btck_LogCategory_ALL) {
-        LogInstance().SetLogLevel(get_bclog_level(level));
-    }
-
-    LogInstance().AddCategoryLogLevel(get_bclog_flag(category), get_bclog_level(level));
-}
-
-void btck_logging_enable_category(btck_LogCategory category)
-{
-    LogInstance().EnableCategory(get_bclog_flag(category));
-}
-
-void btck_logging_disable_category(btck_LogCategory category)
+void btck_logging_set_min_level(btck_LogLevel level)
 {
-    LogInstance().DisableCategory(get_bclog_flag(category));
+    g_kernel_logger().min_level.store(get_bclog_level(level));
 }
 
 btck_LoggingConnection* btck_logging_connection_create(btck_LogCallback callback, void* user_data, btck_DestroyCallback user_data_destroy_callback)

src/kernel/bitcoinkernel.h

@@ -764,39 +764,15 @@ BITCOINKERNEL_API void btck_transaction_output_destroy(btck_TransactionOutput* t
 ///@{
 
 /**
- * @brief Set the log level of the global internal logger. This does not
- * enable the selected categories. Use @ref btck_logging_enable_category to
- * start logging from a specific, or all categories. This changes a global
- * setting and will override settings for all existing
- * @ref btck_LoggingConnection instances.
+ * @brief Set the minimum log level. Messages below this level are discarded
+ * before formatting to avoid overhead.
  *
- * @param[in] category If btck_LogCategory_ALL is chosen, sets both the global fallback log level
- *                     used by all categories that don't have a specific level set, and also
- *                     sets the log level for messages logged with the btck_LogCategory_ALL category itself.
- *                     For any other category, sets a category-specific log level that overrides
- *                     the global fallback for that category only.
-
- * @param[in] level    Log level at which the log category is set.
- */
-BITCOINKERNEL_API void btck_logging_set_level_category(btck_LogCategory category, btck_LogLevel level);
-
-/**
- * @brief Enable a specific log category for the global internal logger. This
- * changes a global setting and will override settings for all existing @ref
- * btck_LoggingConnection instances.
- *
- * @param[in] category If btck_LogCategory_ALL is chosen, all categories will be enabled.
- */
-BITCOINKERNEL_API void btck_logging_enable_category(btck_LogCategory category);
-
-/**
- * @brief Disable a specific log category for the global internal logger. This
- * changes a global setting and will override settings for all existing @ref
+ * This changes a global setting and will affect all existing @ref
  * btck_LoggingConnection instances.
  *
- * @param[in] category If btck_LogCategory_ALL is chosen, all categories will be disabled.
+ * @param[in] level Minimum log level. Messages below this level are not logged.
  */
-BITCOINKERNEL_API void btck_logging_disable_category(btck_LogCategory category);
+BITCOINKERNEL_API void btck_logging_set_min_level(btck_LogLevel level);
 
 /**
  * @brief Start logging messages through the provided callback.

src/kernel/bitcoinkernel_wrapper.h

@@ -810,16 +810,6 @@ class Block : public Handle<btck_Block, btck_block_copy, btck_block_destroy>
     }
 };
 
-inline void logging_set_level_category(LogCategory category, LogLevel level)
-{
-    btck_logging_set_level_category(static_cast<btck_LogCategory>(category), static_cast<btck_LogLevel>(level));
-}
-
-inline void logging_enable_category(LogCategory category)
-{
-    btck_logging_enable_category(static_cast<btck_LogCategory>(category));
-}
-
 class LogEntry
 {
 private:
@@ -838,9 +828,9 @@ class LogEntry
     LogCategory Category() const { return static_cast<LogCategory>(m_entry->category); }
 };
 
-inline void logging_disable_category(LogCategory category)
+inline void logging_set_min_level(LogLevel level)
 {
-    btck_logging_disable_category(static_cast<btck_LogCategory>(category));
+    btck_logging_set_min_level(static_cast<btck_LogLevel>(level));
 }
 
 inline std::string_view log_level_get_name(LogLevel level)

src/test/kernel/test_kernel.cpp

@@ -615,15 +615,10 @@ BOOST_AUTO_TEST_CASE(btck_script_verify_tests)
 
 BOOST_AUTO_TEST_CASE(logging_tests)
 {
-    logging_set_level_category(LogCategory::BENCH, LogLevel::TRACE_LEVEL);
-    logging_disable_category(LogCategory::BENCH);
-    logging_enable_category(LogCategory::VALIDATION);
-    logging_disable_category(LogCategory::VALIDATION);
+    logging_set_min_level(LogLevel::TRACE_LEVEL);
 
     // Check that connecting, connecting another, and then disconnecting and connecting a logger again works.
     {
-        logging_set_level_category(LogCategory::KERNEL, LogLevel::TRACE_LEVEL);
-        logging_enable_category(LogCategory::KERNEL);
         Logger logger{std::make_unique<TestLog>()};
         Logger logger_2{std::make_unique<TestLog>()};
     }