fix(logging): filter Qt logs by app log level

* Adds an application-level log threshold to suppress unwanted Qt messages
  even when categories still emit them
* Syncs CLI/config log-level selection with the global handler for consistent
  verbosity across startup and runtime
* Improves startup environment logging formatting for clearer diagnostics
* Updates default config log level to reduce noisy output by default

Author: saturneric

src/Application.cpp

@@ -36,10 +36,49 @@
 #include "GpgFrontendContext.h"
 #include "Initialize.h"
 
+namespace {
+
+std::atomic<int> g_log_level{static_cast<int>(GpgFrontend::GFLogLevel::kINFO)};
+
+auto ShouldLogMessage(QtMsgType type, GpgFrontend::GFLogLevel level) -> bool {
+  switch (level) {
+    case GpgFrontend::GFLogLevel::kDEBUG:
+      return true;
+
+    case GpgFrontend::GFLogLevel::kINFO:
+      return type != QtDebugMsg;
+
+    case GpgFrontend::GFLogLevel::kWARNING:
+      return type != QtDebugMsg && type != QtInfoMsg;
+
+    case GpgFrontend::GFLogLevel::kCRITICAL:
+      return type == QtCriticalMsg || type == QtFatalMsg;
+
+    case GpgFrontend::GFLogLevel::kFATAL:
+      return type == QtFatalMsg;
+
+    default:
+      return type != QtDebugMsg;
+  }
+}
+
+}  // namespace
+
 namespace GpgFrontend {
 
+void SetGFLogLevel(int level) {
+  g_log_level.store(level, std::memory_order_relaxed);
+}
+
 void GFMessageHandler(QtMsgType type, const QMessageLogContext& context,
                       const QString& msg) {
+  const auto level =
+      static_cast<GFLogLevel>(g_log_level.load(std::memory_order_relaxed));
+
+  if (!ShouldLogMessage(type, level)) {
+    return;
+  }
+
   const QString formatted = qFormatLogMessage(type, context, msg);
 
   GFLogEntry entry;

src/Application.h

@@ -32,6 +32,13 @@
 
 namespace GpgFrontend {
 
+/**
+ * @brief
+ *
+ * @param level
+ */
+void SetGFLogLevel(int level);
+
 /**
  * @brief
  *

src/Command.cpp

@@ -173,15 +173,19 @@ auto ParseLogLevel(const QString& log_level) -> int {
   if (log_level == "none") return 0;
 
   if (log_level == "debug") {
+    SetGFLogLevel(static_cast<int>(GFLogLevel::kDEBUG));
     QLoggingCategory::setFilterRules(
         BuildQtLoggingFilterRules(static_cast<int>(GFLogLevel::kDEBUG)));
   } else if (log_level == "info") {
+    SetGFLogLevel(static_cast<int>(GFLogLevel::kINFO));
     QLoggingCategory::setFilterRules(
         BuildQtLoggingFilterRules(static_cast<int>(GFLogLevel::kINFO)));
   } else if (log_level == "warn") {
+    SetGFLogLevel(static_cast<int>(GFLogLevel::kWARNING));
     QLoggingCategory::setFilterRules(
         BuildQtLoggingFilterRules(static_cast<int>(GFLogLevel::kWARNING)));
   } else if (log_level == "error") {
+    SetGFLogLevel(static_cast<int>(GFLogLevel::kCRITICAL));
     QLoggingCategory::setFilterRules(
         BuildQtLoggingFilterRules(static_cast<int>(GFLogLevel::kCRITICAL)));
   } else {

src/GpgFrontendContext.cpp

@@ -36,6 +36,16 @@
 #include "core/GFLog.h"
 #include "ui/GpgFrontendApplication.h"
 
+namespace {
+auto BoolText(bool value) -> QString {
+  return value ? QStringLiteral("true") : QStringLiteral("false");
+}
+
+auto DisplayPath(const QString& path) -> QString {
+  return path.isEmpty() ? QStringLiteral("<empty>") : path;
+}
+}  // namespace
+
 namespace GpgFrontend {
 
 void GpgFrontendContext::load_env_conf_set_properties() {
@@ -49,31 +59,37 @@ void GpgFrontendContext::load_env_conf_set_properties() {
 
   property("GFSelfCheck", s.value("SelfCheck", false).toBool());
   property("GFSecureLevel", s.value("SecureLevel", 0).toInt());
-  property("GFLogLevel",
-           s.value("LogLevel", static_cast<int>(GFLogLevel::kWARNING)).toInt());
+  property(
+      "GFLogLevel",
+      s.value("LogLevel", static_cast<int>(GFLogLevel::kCRITICAL)).toInt());
   property("GFPortableMode", s.value("PortableMode", false).toBool());
   property("GFGnuPGOfflineMode", s.value("GnuPGOfflineMode", false).toBool());
   property("GFPinentryProgramPath",
            s.value("PinentryProgramPath", "").toString());
   property("GFLogRingBufferCapacity",
            s.value("LogRingBufferCapacity", 1024).toInt());
 
-  qInfo() << "ENV"
-          << "GFSelfCheck" << property("GFSelfCheck").toInt();
-  qInfo() << "ENV"
-          << "GFSecureLevel" << property("GFSecureLevel").toInt();
-  qInfo() << "ENV"
-          << "GFLogLevel" << property("GFLogLevel").toInt();
-  qInfo() << "ENV"
-          << "GFPortableMode" << property("GFPortableMode").toBool();
-  qInfo() << "ENV"
-          << "GFGnuPGOfflineMode" << property("GFGnuPGOfflineMode").toBool();
-  qInfo() << "ENV"
-          << "GFPinentryProgramPath"
-          << property("GFPinentryProgramPath").toString();
-  qInfo() << "ENV"
-          << "GFLogRingBufferCapacity"
-          << property("GFLogRingBufferCapacity").toInt();
+  const auto self_check = property("GFSelfCheck").toInt();
+  const auto secure_level = property("GFSecureLevel").toInt();
+  const auto log_level = property("GFLogLevel").toInt();
+  const auto portable_mode = property("GFPortableMode").toBool();
+  const auto gpg_offline_mode = property("GFGnuPGOfflineMode").toBool();
+  const auto pinentry_program_path =
+      property("GFPinentryProgramPath").toString();
+  const auto ring_buffer_capacity = property("GFLogRingBufferCapacity").toInt();
+
+  qInfo().noquote().nospace()
+      << "\n"
+      << "================ GpgFrontend Startup Environment ================\n"
+      << "Self Check              : " << self_check << "\n"
+      << "Secure Level            : " << secure_level << "\n"
+      << "Log Level               : " << log_level << "\n"
+      << "Portable Mode           : " << BoolText(portable_mode) << "\n"
+      << "GnuPG Offline Mode      : " << BoolText(gpg_offline_mode) << "\n"
+      << "Pinentry Program Path   : " << DisplayPath(pinentry_program_path)
+      << "\n"
+      << "Log Ring Buffer Capacity: " << ring_buffer_capacity << "\n"
+      << "==================================================================";
 }
 
 void GpgFrontendContext::InitApplication() {

src/Initialize.cpp

@@ -88,6 +88,7 @@ void PreInit(const GFCxtWPtr &p_ctx) {
 
   const int log_level = app->property("GFLogLevel").toInt();
   QLoggingCategory::setFilterRules(BuildQtLoggingFilterRules(log_level));
+  SetGFLogLevel(log_level);
 
 #ifdef RELEASE
   qSetMessagePattern(