core: Add integration with hyprutils' cli::logger (#21)

Author: vaxerski

CMakeLists.txt

@@ -28,7 +28,7 @@ pkg_check_modules(
   wayland-client
   wayland-protocols
   egl
-  hyprutils>=0.9.0
+  hyprutils>=0.10.4
   hyprlang>=0.6.0
   pixman-1
   libdrm
@@ -39,7 +39,7 @@ pkg_check_modules(
   pangocairo
   iniparser
   hyprgraphics>=0.3.0
-  aquamarine>=0.9.5)
+  aquamarine>=0.10.0)
 
 configure_file(hyprtoolkit.pc.in hyprtoolkit.pc @ONLY)
 

flake.lock

@@ -2,6 +2,7 @@
 
 #include <hyprutils/memory/SharedPtr.hpp>
 #include <hyprutils/memory/Atomic.hpp>
+#include <hyprutils/cli/Logger.hpp>
 #include <aquamarine/backend/Null.hpp>
 #include <aquamarine/backend/Backend.hpp>
 #include <functional>
@@ -28,12 +29,19 @@ namespace Hyprtoolkit {
 
         using LogFn = std::function<void(eLogLevel, const std::string&)>;
 
+        struct SBackendCreationData {
+            explicit SBackendCreationData();
+
+            Hyprutils::Memory::CSharedPointer<Hyprutils::CLI::CLoggerConnection> pLogConnection;
+        };
+
         /*
             Create a backend.
             There can only be one backend per process: In case of another create(),
             it will fail.
         */
         static Hyprutils::Memory::CSharedPointer<IBackend> create();
+        static Hyprutils::Memory::CSharedPointer<IBackend> createWithData(const SBackendCreationData& data);
 
         /*
             Destroy the backend.

include/hyprtoolkit/core/Backend.hpp

@@ -30,22 +30,15 @@ using namespace Hyprutils::Memory;
 #define SP CSharedPointer
 #define WP CWeakPointer
 
-static void aqLog(Aquamarine::eBackendLogLevel level, std::string msg) {
-    if (Env::envEnabled("HT_QUIET"))
-        return;
-
-    if (g_logger)
-        g_logger->log(HT_LOG_DEBUG, "[AQ] {}", msg);
-    else
-        std::println("{}", msg);
-}
-
 CBackend::CBackend() {
     pipe(m_sLoopState.exitfd);
     pipe(m_sLoopState.wakeupfd);
 
     Aquamarine::SBackendOptions options{};
-    options.logFunction = ::aqLog;
+    g_logger->m_aqLoggerConnection = makeShared<Hyprutils::CLI::CLoggerConnection>(g_logger->m_logger);
+    g_logger->m_aqLoggerConnection->setLogLevel(Hyprutils::CLI::LOG_WARN); // don't print debug logs, unless AQ_TRACE is set, then aq will set it
+    g_logger->m_aqLoggerConnection->setName("aquamarine");
+    options.logConnection = g_logger->m_aqLoggerConnection;
 
     std::vector<Aquamarine::SBackendImplementationOptions> implementations;
     Aquamarine::SBackendImplementationOptions              option;
@@ -65,11 +58,18 @@ CBackend::~CBackend() {
     close(m_sLoopState.wakeupfd[1]);
 }
 
+IBackend::SBackendCreationData::SBackendCreationData() = default;
+
+SP<IBackend> IBackend::createWithData(const IBackend::SBackendCreationData& data) {
+    g_logger->m_loggerConnection = data.pLogConnection;
+    g_logger->updateLogLevel();
+    return IBackend::create();
+}
+
 SP<IBackend> IBackend::create() {
     if (g_backend)
         return nullptr;
     g_backend = SP<CBackend>(new CBackend());
-    g_logger  = SP<CBackendLogger>(new CBackendLogger());
     g_config  = makeShared<CConfigManager>();
     g_config->parse();
     g_palette     = CPalette::palette();
@@ -94,7 +94,7 @@ void CBackend::destroy() {
 }
 
 void CBackend::setLogFn(LogFn&& fn) {
-    m_logFn = std::move(fn);
+    g_logger->m_logFn = std::move(fn);
 }
 
 SP<CPalette> CBackend::getPalette() {

src/core/Backend.cpp

@@ -2,6 +2,7 @@
 
 #include <hyprtoolkit/core/Backend.hpp>
 #include <hyprutils/os/FileDescriptor.hpp>
+#include <hyprutils/cli/Logger.hpp>
 #include <hyprgraphics/resource/AsyncResourceGatherer.hpp>
 
 #include "../helpers/Env.hpp"
@@ -48,8 +49,6 @@ namespace Hyprtoolkit {
 
         Hyprutils::Memory::CSharedPointer<Aquamarine::CBackend> m_aqBackend;
 
-        LogFn                                                   m_logFn;
-
         bool                                                    m_terminate         = false;
         bool                                                    m_needsConfigReload = false;
 

src/core/Backend.hpp

@@ -9,49 +9,3 @@ using namespace Hyprtoolkit;
 
 IBackend::~IBackend() = default;
 IBackend::IBackend()  = default;
-
-void CBackendLogger::log(eLogLevel level, std::string str) {
-    if (Env::envEnabled("HT_QUIET"))
-        return;
-
-    if (g_backend->m_logFn) {
-        g_backend->m_logFn(level, str);
-        return;
-    }
-
-    std::string coloredStr = str;
-    //NOLINTBEGIN
-    switch (level) {
-        case HT_LOG_TRACE:
-            str        = "[HT] TRACE: " + str;
-            coloredStr = str;
-            break;
-        case HT_LOG_DEBUG:
-            str        = "[HT] DEBUG: " + str;
-            coloredStr = "\033[1;33m" + str + "\033[0m"; // yellow
-            break;
-        case HT_LOG_WARNING:
-            str        = "[HT] WARN: " + str;
-            coloredStr = "\033[1;33m" + str + "\033[0m"; // yellow
-            break;
-        case HT_LOG_ERROR:
-            str        = "[HT] ERR: " + str;
-            coloredStr = "\033[1;31m" + str + "\033[0m"; // red
-            break;
-        case HT_LOG_CRITICAL:
-            str        = "[HT] CRIT: " + str;
-            coloredStr = "\033[1;35m" + str + "\033[0m"; // magenta
-            break;
-        default: break;
-    }
-    //NOLINTEND
-
-    static bool LOG_NO_COLOR = Env::envEnabled("HT_NO_COLOR_LOGS");
-
-    if (LOG_NO_COLOR)
-        std::println("{}", coloredStr);
-    else
-        std::println("{}", str);
-
-    std::fflush(stdout);
-}

src/core/InternalBackend.cpp

@@ -6,40 +6,15 @@
 
 #include "Backend.hpp"
 #include "../helpers/Env.hpp"
+#include "Logger.hpp"
 
 namespace Hyprtoolkit {
 
     class CPalette;
     class CConfigManager;
     class CSystemIconFactory;
 
-    class CBackendLogger {
-      public:
-        void log(eLogLevel level, std::string str);
-
-        template <typename... Args>
-        //NOLINTNEXTLINE
-        void log(eLogLevel level, std::format_string<Args...> fmt, Args&&... args) {
-            static bool LOG_DISABLED = Env::envEnabled("HT_NO_LOGS");
-
-            if (LOG_DISABLED)
-                return;
-
-            std::string logMsg = "";
-
-            // no need for try {} catch {} because std::format_string<Args...> ensures that vformat never throw std::format_error
-            // because
-            // 1. any faulty format specifier that sucks will cause a compilation error.
-            // 2. and `std::bad_alloc` is catastrophic, (Almost any operation in stdlib could throw this.)
-            // 3. this is actually what std::format in stdlib does
-            logMsg += std::vformat(fmt.get(), std::make_format_args(args...));
-
-            log(level, logMsg);
-        }
-    };
-
     inline Hyprutils::Memory::CSharedPointer<Hyprtoolkit::CBackend>                g_backend;
-    inline Hyprutils::Memory::CSharedPointer<Hyprtoolkit::CBackendLogger>          g_logger;
     inline Hyprutils::Memory::CSharedPointer<Hyprgraphics::CAsyncResourceGatherer> g_asyncResourceGatherer;
     inline Hyprutils::Memory::CSharedPointer<CPalette>                             g_palette;
     inline Hyprutils::Memory::CSharedPointer<CConfigManager>                       g_config;

src/core/InternalBackend.hpp

@@ -0,0 +1,43 @@
+#include "Logger.hpp"
+
+using namespace Hyprtoolkit;
+
+static Hyprutils::CLI::eLogLevel levelToHU(eLogLevel l) {
+    switch (l) {
+        case Hyprtoolkit::HT_LOG_DEBUG: return Hyprutils::CLI::LOG_DEBUG;
+        case Hyprtoolkit::HT_LOG_ERROR: return Hyprutils::CLI::LOG_ERR;
+        case Hyprtoolkit::HT_LOG_WARNING: return Hyprutils::CLI::LOG_WARN;
+        case Hyprtoolkit::HT_LOG_CRITICAL: return Hyprutils::CLI::LOG_CRIT;
+        case Hyprtoolkit::HT_LOG_TRACE: return Hyprutils::CLI::LOG_TRACE;
+    }
+    return Hyprutils::CLI::LOG_DEBUG;
+}
+
+CLogger::CLogger() {
+    const auto IS_TRACE = Env::isTrace();
+    m_logger.setLogLevel(IS_TRACE ? Hyprutils::CLI::LOG_TRACE : Hyprutils::CLI::LOG_DEBUG);
+}
+
+void CLogger::updateLogLevel() {
+    const auto IS_TRACE = Env::isTrace();
+    if (m_loggerConnection && IS_TRACE)
+        m_loggerConnection->setLogLevel(Hyprutils::CLI::LOG_TRACE);
+}
+
+void CLogger::log(eLogLevel level, const std::string& str) {
+    static const bool IS_QUIET = Env::envEnabled("HT_QUIET");
+    if (IS_QUIET)
+        return;
+
+    if (m_logFn) {
+        m_logFn(level, str);
+        return;
+    }
+
+    if (m_loggerConnection) {
+        m_loggerConnection->log(levelToHU(level), str);
+        return;
+    }
+
+    m_logger.log(levelToHU(level), str);
+}

src/core/Logger.cpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <hyprtoolkit/core/LogTypes.hpp>
+#include <hyprtoolkit/core/Backend.hpp>
+
+#include <hyprutils/cli/Logger.hpp>
+#include <optional>
+
+#include "../helpers/Env.hpp"
+
+namespace Hyprtoolkit {
+    class CLogger {
+      public:
+        CLogger();
+        ~CLogger() = default;
+
+        void log(eLogLevel level, const std::string& str);
+
+        template <typename... Args>
+        //NOLINTNEXTLINE
+        void log(eLogLevel level, std::format_string<Args...> fmt, Args&&... args) {
+            static bool LOG_DISABLED = Env::envEnabled("HT_NO_LOGS");
+
+            if (LOG_DISABLED)
+                return;
+
+            std::string logMsg = "";
+
+            // no need for try {} catch {} because std::format_string<Args...> ensures that vformat never throw std::format_error
+            // because
+            // 1. any faulty format specifier that sucks will cause a compilation error.
+            // 2. and `std::bad_alloc` is catastrophic, (Almost any operation in stdlib could throw this.)
+            // 3. this is actually what std::format in stdlib does
+            logMsg += std::vformat(fmt.get(), std::make_format_args(args...));
+
+            log(level, logMsg);
+        }
+
+        void                                                                 updateLogLevel();
+
+        Hyprutils::CLI::CLogger                                              m_logger;
+        IBackend::LogFn                                                      m_logFn;
+        Hyprutils::Memory::CSharedPointer<Hyprutils::CLI::CLoggerConnection> m_loggerConnection;
+        Hyprutils::Memory::CSharedPointer<Hyprutils::CLI::CLoggerConnection> m_aqLoggerConnection;
+    };
+
+    inline Hyprutils::Memory::CSharedPointer<CLogger> g_logger = Hyprutils::Memory::makeShared<CLogger>();
+};