feat: integrate logging api to core

3 files changed, 24 insertions, 22 deletions

diff --git a/src/core/function/basic/GpgFunctionObject.cpp b/src/core/function/basic/GpgFunctionObject.cpp
index e31ff2d6..e9e444f1 100644
--- a/src/core/function/basic/GpgFunctionObject.cpp
+++ b/src/core/function/basic/GpgFunctionObject.cpp
@@ -32,8 +32,8 @@
 #include <mutex>
 #include <typeinfo>
 
-#include "function/SecureMemoryAllocator.h"
-#include "function/basic/ChannelObject.h"
+#include "core/function/SecureMemoryAllocator.h"
+#include "core/function/basic/ChannelObject.h"
 
 struct FunctionObjectTypeLockInfo {
   std::map<int, std::mutex> channel_lock_map;
@@ -66,8 +66,8 @@ auto GetGlobalFunctionObjectTypeLock(const std::type_info& type)
  */
 auto GetChannelObjectInstance(const std::type_info& type, int channel)
     -> ChannelObject* {
-  SPDLOG_TRACE("try to get instance of type: {} at channel: {}", type.name(),
-               channel);
+  GF_DEFAULT_LOG_TRACE("try to get instance of type: {} at channel: {}",
+                       type.name(), channel);
 
   // lock this channel
   std::lock_guard<std::mutex> guard(
@@ -75,13 +75,13 @@ auto GetChannelObjectInstance(const std::type_info& type, int channel)
 
   auto* p_storage =
       SingletonStorageCollection::GetInstance(false)->GetSingletonStorage(type);
-  SPDLOG_TRACE("get singleton storage result, p_storage: {}",
-               static_cast<void*>(p_storage));
+  GF_DEFAULT_LOG_TRACE("get singleton storage result, p_storage: {}",
+                       static_cast<void*>(p_storage));
 
   auto* p_pbj =
       static_cast<ChannelObject*>(p_storage->FindObjectInChannel(channel));
-  SPDLOG_TRACE("find channel object result, channel {}, p_pbj: {}", channel,
-               static_cast<void*>(p_pbj));
+  GF_DEFAULT_LOG_TRACE("find channel object result, channel {}, p_pbj: {}",
+                       channel, static_cast<void*>(p_pbj));
 
   return p_pbj;
 }
@@ -95,8 +95,8 @@ auto CreateChannelObjectInstance(const std::type_info& type, int channel,
 
   auto* p_storage =
       SingletonStorageCollection::GetInstance(false)->GetSingletonStorage(type);
-  SPDLOG_TRACE("create channel object, channel {}, type: {}", channel,
-               type.name());
+  GF_DEFAULT_LOG_TRACE("create channel object, channel {}, type: {}", channel,
+                       type.name());
 
   // do create object of this channel
   return p_storage->SetObjectInChannel(channel, std::move(channel_object));
diff --git a/src/core/function/basic/SingletonStorage.cpp b/src/core/function/basic/SingletonStorage.cpp
index f6507567..eab71e0f 100644
--- a/src/core/function/basic/SingletonStorage.cpp
+++ b/src/core/function/basic/SingletonStorage.cpp
@@ -53,7 +53,8 @@ class SingletonStorage::Impl {
       std::shared_lock<std::shared_mutex> lock(instances_mutex_);
       ins_it = instances_map_.find(channel);
       if (ins_it == instances_map_.end()) {
-        SPDLOG_TRACE("cannot find channel object, channel: {}", channel);
+        GF_DEFAULT_LOG_TRACE("cannot find channel object, channel: {}",
+                             channel);
         return nullptr;
       }
       return ins_it->second.get();
@@ -71,14 +72,14 @@ class SingletonStorage::Impl {
 
   auto SetObjectInChannel(int channel, ChannelObjectPtr p_obj)
       -> GpgFrontend::ChannelObject* {
-    SPDLOG_TRACE("set channel object, type: {} in channel: {}, address: {}",
-                 typeid(p_obj.get()).name(), channel,
-                 static_cast<void*>(p_obj.get()));
+    GF_DEFAULT_LOG_TRACE(
+        "set channel object, type: {} in channel: {}, address: {}",
+        typeid(p_obj.get()).name(), channel, static_cast<void*>(p_obj.get()));
 
     assert(p_obj != nullptr);
     if (p_obj == nullptr) {
-      SPDLOG_ERROR("cannot set a nullptr as a channel obejct of channel: {}",
-                   channel);
+      GF_DEFAULT_LOG_ERROR(
+          "cannot set a nullptr as a channel obejct of channel: {}", channel);
       return nullptr;
     }
 
@@ -86,7 +87,7 @@ class SingletonStorage::Impl {
     auto* raw_obj = p_obj.get();
 
     {
-      SPDLOG_TRACE(
+      GF_DEFAULT_LOG_TRACE(
           "register channel object to instances map, "
           "channel: {}, address: {}",
           channel, static_cast<void*>(p_obj.get()));
@@ -94,8 +95,9 @@ class SingletonStorage::Impl {
       instances_map_[channel] = std::move(p_obj);
     }
 
-    SPDLOG_TRACE("set channel: {} success, current channel object address: {}",
-                 channel, static_cast<void*>(raw_obj));
+    GF_DEFAULT_LOG_TRACE(
+        "set channel: {} success, current channel object address: {}", channel,
+        static_cast<void*>(raw_obj));
     return raw_obj;
   }
 
diff --git a/src/core/function/basic/SingletonStorageCollection.cpp b/src/core/function/basic/SingletonStorageCollection.cpp
index 9c0116cb..c22b5242 100644
--- a/src/core/function/basic/SingletonStorageCollection.cpp
+++ b/src/core/function/basic/SingletonStorageCollection.cpp
@@ -49,7 +49,7 @@ class SingletonStorageCollection::Impl {
   static auto GetInstance(bool force_refresh) -> SingletonStorageCollection* {
     if (force_refresh || global_instance == nullptr) {
       global_instance = SecureCreateUniqueObject<SingletonStorageCollection>();
-      SPDLOG_TRACE(
+      GF_DEFAULT_LOG_TRACE(
           "a new global singleton storage collection created, address: {}",
           static_cast<void*>(global_instance.get()));
     }
@@ -80,7 +80,7 @@ class SingletonStorageCollection::Impl {
       }
       if (ins_it == storages_map_.end()) {
         auto storage = SecureCreateUniqueObject<SingletonStorage>();
-        SPDLOG_TRACE(
+        GF_DEFAULT_LOG_TRACE(
             "hash: {} created, singleton storage address: {} type_name: {}",
             hash, static_cast<void*>(storage.get()), type_id.name());
 
@@ -110,7 +110,7 @@ auto GpgFrontend::SingletonStorageCollection::GetInstance(bool force_refresh)
 }
 
 void SingletonStorageCollection::Destroy() {
-  SPDLOG_TRACE(
+  GF_DEFAULT_LOG_TRACE(
       "global singleton storage collection is about to destroy, address: {}",
       static_cast<void*>(global_instance.get()));
   return SingletonStorageCollection::Impl::Destroy();