kernel: add log level/category name getters

Expose btck_log_level_get_name and btck_log_category_get_name to allow
library users to get string representations of log levels and categories.

Use constexpr lookup tables as a single source of truth for mapping
btck types to both BCLog equivalents and string names.

Author: stickies-v

src/kernel/bitcoinkernel.cpp

@@ -37,6 +37,8 @@
 #include <validation.h>
 #include <validationinterface.h>
 
+#include <array>
+#include <cassert>
 #include <cstddef>
 #include <cstring>
 #include <exception>
@@ -47,6 +49,7 @@
 #include <span>
 #include <stdexcept>
 #include <string>
+#include <string_view>
 #include <tuple>
 #include <utility>
 #include <vector>
@@ -146,60 +149,52 @@ struct btck_BlockValidationState : Handle<btck_BlockValidationState, BlockValida
 
 namespace {
 
-BCLog::Level get_bclog_level(btck_LogLevel level)
+
+struct LogLevelMapping {
+    util::log::Level bclog;
+    std::string_view name;
+};
+
+// Single source of truth for log level mappings (indexed by btck_LogLevel)
+constexpr auto LOG_LEVELS = [] {
+    std::array<LogLevelMapping, 3> a{};
+    a[btck_LogLevel_TRACE] = {util::log::Level::Trace, "trace"};
+    a[btck_LogLevel_DEBUG] = {util::log::Level::Debug, "debug"};
+    a[btck_LogLevel_INFO] = {util::log::Level::Info, "info"};
+    return a;
+}();
+
+constexpr util::log::Level get_bclog_level(btck_LogLevel level)
 {
-    switch (level) {
-    case btck_LogLevel_INFO: {
-        return BCLog::Level::Info;
-    }
-    case btck_LogLevel_DEBUG: {
-        return BCLog::Level::Debug;
-    }
-    case btck_LogLevel_TRACE: {
-        return BCLog::Level::Trace;
-    }
-    }
-    assert(false);
+    assert(level < LOG_LEVELS.size());
+    return LOG_LEVELS[level].bclog;
 }
 
-BCLog::LogFlags get_bclog_flag(btck_LogCategory category)
+struct LogCategoryMapping {
+    BCLog::LogFlags bclog;
+    std::string_view name;
+};
+
+// Single source of truth for log category mappings (indexed by btck_LogCategory)
+constexpr auto LOG_CATEGORIES = [] {
+    std::array<LogCategoryMapping, 11> a{};
+    a[btck_LogCategory_ALL] = {BCLog::LogFlags::ALL, "all"};
+    a[btck_LogCategory_BENCH] = {BCLog::LogFlags::BENCH, "bench"};
+    a[btck_LogCategory_BLOCKSTORAGE] = {BCLog::LogFlags::BLOCKSTORAGE, "blockstorage"};
+    a[btck_LogCategory_COINDB] = {BCLog::LogFlags::COINDB, "coindb"};
+    a[btck_LogCategory_LEVELDB] = {BCLog::LogFlags::LEVELDB, "leveldb"};
+    a[btck_LogCategory_MEMPOOL] = {BCLog::LogFlags::MEMPOOL, "mempool"};
+    a[btck_LogCategory_PRUNE] = {BCLog::LogFlags::PRUNE, "prune"};
+    a[btck_LogCategory_RAND] = {BCLog::LogFlags::RAND, "rand"};
+    a[btck_LogCategory_REINDEX] = {BCLog::LogFlags::REINDEX, "reindex"};
+    a[btck_LogCategory_VALIDATION] = {BCLog::LogFlags::VALIDATION, "validation"};
+    a[btck_LogCategory_KERNEL] = {BCLog::LogFlags::KERNEL, "kernel"};
+    return a;
+}();
+
+constexpr BCLog::LogFlags get_bclog_flag(btck_LogCategory category)
 {
-    switch (category) {
-    case btck_LogCategory_BENCH: {
-        return BCLog::LogFlags::BENCH;
-    }
-    case btck_LogCategory_BLOCKSTORAGE: {
-        return BCLog::LogFlags::BLOCKSTORAGE;
-    }
-    case btck_LogCategory_COINDB: {
-        return BCLog::LogFlags::COINDB;
-    }
-    case btck_LogCategory_LEVELDB: {
-        return BCLog::LogFlags::LEVELDB;
-    }
-    case btck_LogCategory_MEMPOOL: {
-        return BCLog::LogFlags::MEMPOOL;
-    }
-    case btck_LogCategory_PRUNE: {
-        return BCLog::LogFlags::PRUNE;
-    }
-    case btck_LogCategory_RAND: {
-        return BCLog::LogFlags::RAND;
-    }
-    case btck_LogCategory_REINDEX: {
-        return BCLog::LogFlags::REINDEX;
-    }
-    case btck_LogCategory_VALIDATION: {
-        return BCLog::LogFlags::VALIDATION;
-    }
-    case btck_LogCategory_KERNEL: {
-        return BCLog::LogFlags::KERNEL;
-    }
-    case btck_LogCategory_ALL: {
-        return BCLog::LogFlags::ALL;
-    }
-    }
-    assert(false);
+    return LOG_CATEGORIES[category].bclog;
 }
 
 btck_SynchronizationState cast_state(SynchronizationState state)
@@ -787,6 +782,20 @@ void btck_logging_connection_destroy(btck_LoggingConnection* connection)
     delete connection;
 }
 
+btck_StringView btck_log_level_get_name(btck_LogLevel level)
+{
+    assert(level < LOG_LEVELS.size());
+    const auto& name{LOG_LEVELS[level].name};
+    return {name.data(), name.size()};
+}
+
+btck_StringView btck_log_category_get_name(btck_LogCategory category)
+{
+    assert(category < LOG_CATEGORIES.size());
+    const auto& name{LOG_CATEGORIES[category].name};
+    return {name.data(), name.size()};
+}
+
 btck_ChainParameters* btck_chain_parameters_create(const btck_ChainType chain_type)
 {
     switch (chain_type) {

src/kernel/bitcoinkernel.h

@@ -304,6 +304,14 @@ typedef struct btck_Txid btck_Txid;
  */
 typedef struct btck_BlockHeader btck_BlockHeader;
 
+/**
+ * A non-owning view of a string with explicit length.
+ */
+typedef struct {
+    const char* data; //!< Pointer to string data (not necessarily null-terminated).
+    size_t size;      //!< Size of the string.
+} btck_StringView;
+
 /** Current sync state passed to tip changed callbacks. */
 typedef uint8_t btck_SynchronizationState;
 #define btck_SynchronizationState_INIT_REINDEX ((btck_SynchronizationState)(0))
@@ -830,6 +838,22 @@ BITCOINKERNEL_API btck_LoggingConnection* BITCOINKERNEL_WARN_UNUSED_RESULT btck_
  */
 BITCOINKERNEL_API void btck_logging_connection_destroy(btck_LoggingConnection* logging_connection);
 
+/**
+ * @brief Get the name of a log level.
+ *
+ * @param[in] level  The log level.
+ * @return           String name (e.g., "trace", "debug", "info", "warning", "error").
+ */
+BITCOINKERNEL_API btck_StringView btck_log_level_get_name(btck_LogLevel level);
+
+/**
+ * @brief Get the name of a log category.
+ *
+ * @param[in] category  The log category.
+ * @return              String name (e.g., "all", "bench", "validation").
+ */
+BITCOINKERNEL_API btck_StringView btck_log_category_get_name(btck_LogCategory category);
+
 ///@}
 
 /** @name ChainParameters

src/kernel/bitcoinkernel_wrapper.h

@@ -830,6 +830,18 @@ inline void logging_disable_category(LogCategory category)
     btck_logging_disable_category(static_cast<btck_LogCategory>(category));
 }
 
+inline std::string_view log_level_get_name(LogLevel level)
+{
+    auto name{btck_log_level_get_name(static_cast<btck_LogLevel>(level))};
+    return {name.data, name.size};
+}
+
+inline std::string_view log_category_get_name(LogCategory category)
+{
+    auto name{btck_log_category_get_name(static_cast<btck_LogCategory>(category))};
+    return {name.data, name.size};
+}
+
 template <typename T>
 concept Log = requires(T a, std::string_view message) {
     { a.LogMessage(message) } -> std::same_as<void>;

src/test/kernel/test_kernel.cpp

@@ -635,6 +635,28 @@ BOOST_AUTO_TEST_CASE(logging_tests)
     Logger logger{std::make_unique<TestLog>()};
 }
 
+BOOST_AUTO_TEST_CASE(log_level_name_tests)
+{
+    BOOST_CHECK_EQUAL(log_level_get_name(LogLevel::TRACE_LEVEL), "trace");
+    BOOST_CHECK_EQUAL(log_level_get_name(LogLevel::DEBUG_LEVEL), "debug");
+    BOOST_CHECK_EQUAL(log_level_get_name(LogLevel::INFO_LEVEL), "info");
+}
+
+BOOST_AUTO_TEST_CASE(log_category_name_tests)
+{
+    BOOST_CHECK_EQUAL(log_category_get_name(LogCategory::ALL), "all");
+    BOOST_CHECK_EQUAL(log_category_get_name(LogCategory::BENCH), "bench");
+    BOOST_CHECK_EQUAL(log_category_get_name(LogCategory::BLOCKSTORAGE), "blockstorage");
+    BOOST_CHECK_EQUAL(log_category_get_name(LogCategory::COINDB), "coindb");
+    BOOST_CHECK_EQUAL(log_category_get_name(LogCategory::KERNEL), "kernel");
+    BOOST_CHECK_EQUAL(log_category_get_name(LogCategory::LEVELDB), "leveldb");
+    BOOST_CHECK_EQUAL(log_category_get_name(LogCategory::MEMPOOL), "mempool");
+    BOOST_CHECK_EQUAL(log_category_get_name(LogCategory::PRUNE), "prune");
+    BOOST_CHECK_EQUAL(log_category_get_name(LogCategory::RAND), "rand");
+    BOOST_CHECK_EQUAL(log_category_get_name(LogCategory::REINDEX), "reindex");
+    BOOST_CHECK_EQUAL(log_category_get_name(LogCategory::VALIDATION), "validation");
+}
+
 BOOST_AUTO_TEST_CASE(btck_context_tests)
 {
     { // test default context