feat: integrate logging api to core

6 files changed, 128 insertions, 32 deletions

diff --git a/src/core/utils/AsyncUtils.cpp b/src/core/utils/AsyncUtils.cpp
index d414ac99..385a8d56 100644
--- a/src/core/utils/AsyncUtils.cpp
+++ b/src/core/utils/AsyncUtils.cpp
@@ -41,10 +41,10 @@ void RunGpgOperaAsync(GpgOperaRunnable runnable, GpgOperationCallback callback,
                       const std::string& minial_version) {
   const auto gnupg_version = Module::RetrieveRTValueTypedOrDefault<>(
       "core", "gpgme.ctx.gnupg_version", minial_version);
-  SPDLOG_DEBUG("got gnupg version from rt: {}", gnupg_version);
+  GF_CORE_LOG_DEBUG("got gnupg version from rt: {}", gnupg_version);
 
   if (CompareSoftwareVersion(gnupg_version, "2.0.15") < 0) {
-    SPDLOG_ERROR("operator not support");
+    GF_CORE_LOG_ERROR("operator not support");
     callback(GPG_ERR_NOT_SUPPORTED, TransferParams());
     return;
   }
diff --git a/src/core/utils/GpgUtils.cpp b/src/core/utils/GpgUtils.cpp
index 98e4c749..d6dd6e04 100644
--- a/src/core/utils/GpgUtils.cpp
+++ b/src/core/utils/GpgUtils.cpp
@@ -69,7 +69,7 @@ auto GetGpgmeErrorString(gpgme_error_t err) -> std::string {
 auto CheckGpgError(GpgError err) -> GpgError {
   auto err_code = gpg_err_code(err);
   if (err_code != GPG_ERR_NO_ERROR) {
-    SPDLOG_ERROR(
+    GF_CORE_LOG_ERROR(
         "gpg operation failed [error code: {}], source: {} description: {}",
         err_code, gpgme_strsource(err), GetGpgmeErrorString(err));
   }
@@ -80,13 +80,13 @@ auto CheckGpgError2ErrCode(GpgError err, GpgError predict) -> GpgErrorCode {
   auto err_code = gpg_err_code(err);
   if (err_code != gpg_err_code(predict)) {
     if (err_code == GPG_ERR_NO_ERROR) {
-      SPDLOG_WARN("[Warning {}] Source: {} description: {} predict: {}",
-                  gpg_err_code(err), gpgme_strsource(err),
-                  GetGpgmeErrorString(err), GetGpgmeErrorString(predict));
+      GF_CORE_LOG_WARN("[Warning {}] Source: {} description: {} predict: {}",
+                       gpg_err_code(err), gpgme_strsource(err),
+                       GetGpgmeErrorString(err), GetGpgmeErrorString(predict));
     } else {
-      SPDLOG_ERROR("[Error {}] Source: {} description: {} predict: {}",
-                   gpg_err_code(err), gpgme_strsource(err),
-                   GetGpgmeErrorString(err), GetGpgmeErrorString(predict));
+      GF_CORE_LOG_ERROR("[Error {}] Source: {} description: {} predict: {}",
+                        gpg_err_code(err), gpgme_strsource(err),
+                        GetGpgmeErrorString(err), GetGpgmeErrorString(predict));
     }
   }
   return err_code;
@@ -98,8 +98,8 @@ auto DescribeGpgErrCode(GpgError err) -> GpgErrorDesc {
 
 auto CheckGpgError(GpgError err, const std::string& /*comment*/) -> GpgError {
   if (gpg_err_code(err) != GPG_ERR_NO_ERROR) {
-    SPDLOG_WARN("[Error {}] Source: {} description: {}", gpg_err_code(err),
-                gpgme_strsource(err), GetGpgmeErrorString(err));
+    GF_CORE_LOG_WARN("[Error {}] Source: {} description: {}", gpg_err_code(err),
+                     gpgme_strsource(err), GetGpgmeErrorString(err));
   }
   return err;
 }
diff --git a/src/core/utils/IOUtils.cpp b/src/core/utils/IOUtils.cpp
index a11baf92..0a67a69b 100644
--- a/src/core/utils/IOUtils.cpp
+++ b/src/core/utils/IOUtils.cpp
@@ -40,7 +40,7 @@ namespace GpgFrontend {
 auto ReadFile(const QString& file_name, QByteArray& data) -> bool {
   QFile file(file_name);
   if (!file.open(QIODevice::ReadOnly)) {
-    SPDLOG_ERROR("failed to open file: {}", file_name.toStdString());
+    GF_CORE_LOG_ERROR("failed to open file: {}", file_name.toStdString());
     return false;
   }
   data = file.readAll();
@@ -51,7 +51,7 @@ auto ReadFile(const QString& file_name, QByteArray& data) -> bool {
 auto WriteFile(const QString& file_name, const QByteArray& data) -> bool {
   QFile file(file_name);
   if (!file.open(QIODevice::WriteOnly)) {
-    SPDLOG_ERROR("failed to open file: {}", file_name.toStdString());
+    GF_CORE_LOG_ERROR("failed to open file: {}", file_name.toStdString());
     return false;
   }
   file.write(data);
@@ -122,7 +122,7 @@ auto CalculateHash(const std::filesystem::path& file_path) -> std::string {
       auto hash_md5 = QCryptographicHash(QCryptographicHash::Md5);
       hash_md5.addData(buffer);
       auto md5 = hash_md5.result().toHex().toStdString();
-      SPDLOG_DEBUG("md5 {}", md5);
+      GF_CORE_LOG_DEBUG("md5 {}", md5);
       ss << "    "
          << "md5" << _(": ") << md5 << std::endl;
 
@@ -130,7 +130,7 @@ auto CalculateHash(const std::filesystem::path& file_path) -> std::string {
       auto hash_sha1 = QCryptographicHash(QCryptographicHash::Sha1);
       hash_sha1.addData(buffer);
       auto sha1 = hash_sha1.result().toHex().toStdString();
-      SPDLOG_DEBUG("sha1 {}", sha1);
+      GF_CORE_LOG_DEBUG("sha1 {}", sha1);
       ss << "    "
          << "sha1" << _(": ") << sha1 << std::endl;
 
@@ -138,7 +138,7 @@ auto CalculateHash(const std::filesystem::path& file_path) -> std::string {
       auto hash_sha256 = QCryptographicHash(QCryptographicHash::Sha256);
       hash_sha256.addData(buffer);
       auto sha256 = hash_sha256.result().toHex().toStdString();
-      SPDLOG_DEBUG("sha256 {}", sha256);
+      GF_CORE_LOG_DEBUG("sha256 {}", sha256);
       ss << "    "
          << "sha256" << _(": ") << sha256 << std::endl;
 
diff --git a/src/core/utils/LogUtils.cpp b/src/core/utils/LogUtils.cpp
index d7d13579..f95ade9a 100644
--- a/src/core/utils/LogUtils.cpp
+++ b/src/core/utils/LogUtils.cpp
@@ -28,6 +28,34 @@
 
 #include "LogUtils.h"
 
+#include "core/function/LoggerManager.h"
+
+namespace GpgFrontend {
+
+auto GetDefaultLogger() -> std::shared_ptr<spdlog::logger> {
+  return LoggerManager::GetDefaultLogger();
+}
+
 auto GetCoreLogger() -> std::shared_ptr<spdlog::logger> {
-  return spdlog::get("core");
-}
\ No newline at end of file
+  return LoggerManager::GetInstance().GetLogger("core");
+}
+
+auto GetLogger(const std::string& id) -> std::shared_ptr<spdlog::logger> {
+  return LoggerManager::GetInstance().GetLogger(id);
+}
+
+void SetDefaultLogLevel(spdlog::level::level_enum level) {
+  return LoggerManager::SetDefaultLogLevel(level);
+}
+
+void RegisterAsyncLogger(const std::string& id,
+                         spdlog::level::level_enum level) {
+  LoggerManager::GetInstance().RegisterAsyncLogger(id, level);
+}
+
+void RegisterSyncLogger(const std::string& id,
+                        spdlog::level::level_enum level) {
+  LoggerManager::GetInstance().RegisterSyncLogger(id, level);
+}
+
+}  // namespace GpgFrontend
\ No newline at end of file
diff --git a/src/core/utils/LogUtils.h b/src/core/utils/LogUtils.h
index a4d29dd8..0ed618f9 100644
--- a/src/core/utils/LogUtils.h
+++ b/src/core/utils/LogUtils.h
@@ -28,4 +28,85 @@
 
 #pragma once
 
-auto GPGFRONTEND_CORE_EXPORT GetCoreLogger() -> std::shared_ptr<spdlog::logger>;
\ No newline at end of file
+namespace GpgFrontend {
+
+/**
+ * @brief
+ *
+ * @return std::shared_ptr<spdlog::logger>
+ */
+auto GPGFRONTEND_CORE_EXPORT GetDefaultLogger()
+    -> std::shared_ptr<spdlog::logger>;
+
+/**
+ * @brief
+ *
+ * @return std::shared_ptr<spdlog::logger>
+ */
+auto GPGFRONTEND_CORE_EXPORT GetCoreLogger() -> std::shared_ptr<spdlog::logger>;
+
+/**
+ * @brief
+ *
+ * @return std::shared_ptr<spdlog::logger>
+ */
+auto GPGFRONTEND_CORE_EXPORT GetLogger(const std::string &)
+    -> std::shared_ptr<spdlog::logger>;
+
+/**
+ * @brief Set the Default Log Level object
+ *
+ * @return auto
+ */
+void GPGFRONTEND_CORE_EXPORT SetDefaultLogLevel(spdlog::level::level_enum);
+
+/**
+ * @brief
+ *
+ * @return auto
+ */
+void GPGFRONTEND_CORE_EXPORT RegisterAsyncLogger(const std::string &,
+                                                 spdlog::level::level_enum);
+
+/**
+ * @brief
+ *
+ * @return auto
+ */
+void GPGFRONTEND_CORE_EXPORT RegisterSyncLogger(const std::string &,
+                                                spdlog::level::level_enum);
+
+}  // namespace GpgFrontend
+
+#define GF_DEFAULT_LOG_TRACE(...) \
+  SPDLOG_LOGGER_TRACE(GpgFrontend::GetDefaultLogger(), __VA_ARGS__)
+#define GF_DEFAULT_LOG_DEBUG(...) \
+  SPDLOG_LOGGER_DEBUG(GpgFrontend::GetDefaultLogger(), __VA_ARGS__)
+#define GF_DEFAULT_LOG_INFO(...) \
+  SPDLOG_LOGGER_INFO(GpgFrontend::GetDefaultLogger(), __VA_ARGS__)
+#define GF_DEFAULT_LOG_WARN(...) \
+  SPDLOG_LOGGER_WARN(GpgFrontend::GetDefaultLogger(), __VA_ARGS__)
+#define GF_DEFAULT_LOG_ERROR(...) \
+  SPDLOG_LOGGER_ERROR(GpgFrontend::GetDefaultLogger(), __VA_ARGS__)
+
+#define GF_CORE_LOG_TRACE(...) \
+  SPDLOG_LOGGER_TRACE(GpgFrontend::GetCoreLogger(), __VA_ARGS__)
+#define GF_CORE_LOG_DEBUG(...) \
+  SPDLOG_LOGGER_DEBUG(GpgFrontend::GetCoreLogger(), __VA_ARGS__)
+#define GF_CORE_LOG_INFO(...) \
+  SPDLOG_LOGGER_INFO(GpgFrontend::GetCoreLogger(), __VA_ARGS__)
+#define GF_CORE_LOG_WARN(...) \
+  SPDLOG_LOGGER_WARN(GpgFrontend::GetCoreLogger(), __VA_ARGS__)
+#define GF_CORE_LOG_ERROR(...) \
+  SPDLOG_LOGGER_ERROR(GpgFrontend::GetCoreLogger(), __VA_ARGS__)
+
+#define GF_LOG_TRACE(ID, ...) \
+  SPDLOG_LOGGER_TRACE(GpgFrontend::GetLogger(ID), __VA_ARGS__)
+#define GF_LOG_DEBUG(ID, ...) \
+  SPDLOG_LOGGER_DEBUG(GpgFrontend::GetLogger(ID), __VA_ARGS__)
+#define GF_LOG_INFO(ID, ...) \
+  SPDLOG_LOGGER_INFO(GpgFrontend::GetLogger(ID), __VA_ARGS__)
+#define GF_LOG_WARN(ID, ...) \
+  SPDLOG_LOGGER_WARN(GpgFrontend::GetLogger(ID), __VA_ARGS__)
+#define GF_LOG_ERROR(ID, ...) \
+  SPDLOG_LOGGER_ERROR(GpgFrontend::GetLogger(ID), __VA_ARGS__)
\ No newline at end of file
diff --git a/src/core/utils/MemoryUtils.h b/src/core/utils/MemoryUtils.h
index 5f4283b2..800f2163 100644
--- a/src/core/utils/MemoryUtils.h
+++ b/src/core/utils/MemoryUtils.h
@@ -112,9 +112,6 @@ static auto SecureCreateObject(Args &&...args) -> T * {
   void *mem = SecureMemoryAllocator::Allocate(sizeof(T));
   if (!mem) return nullptr;
 
-  SPDLOG_TRACE("alloc secure memnory success, type: {}, size: {}, addr: {}",
-               typeid(T).name(), sizeof(T), mem);
-
   try {
     return new (mem) T(std::forward<Args>(args)...);
   } catch (...) {
@@ -136,11 +133,6 @@ static auto SecureCreateUniqueObject(Args &&...args)
   void *mem = SecureMemoryAllocator::Allocate(sizeof(T));
   if (!mem) throw std::bad_alloc();
 
-  SPDLOG_TRACE(
-      "alloc secure memnory success, unique ptr, "
-      "type: {}, size: {}, addr: {}",
-      typeid(T).name(), sizeof(T), mem);
-
   try {
     return std::unique_ptr<T, SecureObjectDeleter<T>>(
         new (mem) T(std::forward<Args>(args)...));
@@ -155,11 +147,6 @@ auto SecureCreateSharedObject(Args &&...args) -> std::shared_ptr<T> {
   void *mem = SecureMemoryAllocator::Allocate(sizeof(T));
   if (!mem) throw std::bad_alloc();
 
-  SPDLOG_TRACE(
-      "alloc secure memnory success, shared ptr, "
-      "type: {}, size: {}, addr: {}",
-      typeid(T).name(), sizeof(T), mem);
-
   try {
     T *obj = new (mem) T(std::forward<Args>(args)...);
     return std::shared_ptr<T>(obj, [](T *ptr) {