diff --git a/src/core/cm/alerts/alerts.cpp b/src/core/cm/alerts/alerts.cpp
index 258885590..54fa21cc2 100644
--- a/src/core/cm/alerts/alerts.cpp
+++ b/src/core/cm/alerts/alerts.cpp
@@ -222,12 +222,12 @@ Error Alerts::SendAlerts()
 {
     LockGuard lock {mMutex};
 
-    LOG_DBG() << "Send alerts timer triggered";
-
     if (!mIsRunning || !mIsConnected || mAlerts.IsEmpty()) {
         return ErrorEnum::eNone;
     }
 
+    LOG_DBG() << "Send alerts timer triggered";
+
     if (mSkippedAlerts > 0) {
         LOG_WRN() << "Alerts skipped due to cache is full" << Log::Field("count", mSkippedAlerts);
 
@@ -243,6 +243,8 @@ Error Alerts::SendAlerts()
     while (!mAlerts.IsEmpty()) {
         auto package = CreatePackage();
 
+        LOG_INF() << "Send alerts" << Log::Field("alertsCount", package->mItems.Size());
+
         if (auto err = mSender->SendAlerts(*package); !err.IsNone()) {
             return AOS_ERROR_WRAP(err);
         }
diff --git a/src/core/cm/imagemanager/imagemanager.cpp b/src/core/cm/imagemanager/imagemanager.cpp
index 2ba06a403..81efdbea0 100644
--- a/src/core/cm/imagemanager/imagemanager.cpp
+++ b/src/core/cm/imagemanager/imagemanager.cpp
@@ -104,7 +104,13 @@ Error ImageManager::DownloadUpdateItems(const Array<UpdateItemInfo>& itemsInfo,
     const Array<crypto::CertificateInfo>& certificates, const Array<crypto::CertificateChainInfo>& certificateChains,
     Array<UpdateItemStatus>& statuses)
 {
-    LOG_DBG() << "Download update items" << Log::Field("count", itemsInfo.Size());
+    LOG_INF() << "Download update items" << Log::Field("count", itemsInfo.Size());
+
+    for (const auto& itemInfo : itemsInfo) {
+        LOG_INF() << "Download update item" << Log::Field("itemID", itemInfo.mItemID)
+                  << Log::Field("type", itemInfo.mType) << Log::Field("version", itemInfo.mVersion)
+                  << Log::Field("indexDigest", itemInfo.mIndexDigest);
+    }
 
     if (!StartAction()) {
         return ErrorEnum::eCanceled;
@@ -188,7 +194,12 @@ Error ImageManager::DownloadUpdateItems(const Array<UpdateItemInfo>& itemsInfo,
 
 Error ImageManager::InstallUpdateItems(const Array<UpdateItemInfo>& itemsInfo, Array<UpdateItemStatus>& statuses)
 {
-    LOG_DBG() << "Install update items" << Log::Field("count", itemsInfo.Size());
+    LOG_INF() << "Install update items" << Log::Field("count", itemsInfo.Size());
+
+    for (const auto& itemInfo : itemsInfo) {
+        LOG_INF() << "Install update item" << Log::Field("itemID", itemInfo.mItemID)
+                  << Log::Field("type", itemInfo.mType) << Log::Field("version", itemInfo.mVersion);
+    }
 
     if (!StartAction()) {
         return ErrorEnum::eCanceled;
@@ -1089,7 +1100,7 @@ Error ImageManager::GetBlobInfo(const String& digest, BlobInfo& blobInfo)
                 return AOS_ERROR_WRAP(waitErr);
             }
 
-            LOG_INF() << "Retrying get blobs info" << Log::Field("digest", digest);
+            LOG_DBG() << "Retrying get blobs info" << Log::Field("digest", digest);
 
             continue;
         }
@@ -1242,7 +1253,7 @@ Error ImageManager::PerformDownload(const BlobInfo& blobInfo, const String& down
                 return err;
             }
 
-            LOG_INF() << "Retrying download" << Log::Field("url", blobInfo.mURLs[0])
+            LOG_DBG() << "Retrying download" << Log::Field("url", blobInfo.mURLs[0])
                       << Log::Field("path", downloadPath);
 
             continue;
@@ -1382,6 +1393,12 @@ void ImageManager::NotifyItemsStatusesChanged(const Array<UpdateItemStatus>& sta
 {
     LockGuard lock {mMutex};
 
+    for (const auto& status : statuses) {
+        LOG_DBG() << "Item status changed" << Log::Field("itemID", status.mItemID)
+                  << Log::Field("version", status.mVersion) << Log::Field("state", ItemState(status.mState))
+                  << Log::Field("error", status.mError);
+    }
+
     for (auto* listener : mListeners) {
         listener->OnItemsStatusesChanged(statuses);
     }
diff --git a/src/core/cm/launcher/launcher.cpp b/src/core/cm/launcher/launcher.cpp
index 2186b2244..2e939082f 100644
--- a/src/core/cm/launcher/launcher.cpp
+++ b/src/core/cm/launcher/launcher.cpp
@@ -75,11 +75,11 @@ Error Launcher::Init(const Config& config, nodeinfoprovider::NodeInfoProviderItf
 
 Error Launcher::Start()
 {
-    LOG_DBG() << "Start Launcher";
-
     LockGuard balancingLock {mBalancingMutex};
     LockGuard updateLock {mUpdateMutex};
 
+    LOG_DBG() << "Start Launcher";
+
     mIsRunning = true;
 
     // Start managers.
@@ -139,10 +139,10 @@ Error Launcher::Start()
 
 Error Launcher::Stop()
 {
-    LOG_DBG() << "Stop Launcher";
-
     UniqueLock updateLock {mUpdateMutex};
 
+    LOG_DBG() << "Stop Launcher";
+
     // Finish monitoring thread.
     mIsRunning             = false;
     mDisableProcessUpdates = false;
@@ -187,11 +187,17 @@ Error Launcher::Stop()
 
 Error Launcher::RunInstances(const Array<RunInstanceRequest>& requests, Array<InstanceStatus>& statuses)
 {
-    LOG_DBG() << "Run instances";
-
     UniqueLock balancingLock {mBalancingMutex};
     UniqueLock updateLock {mUpdateMutex};
 
+    LOG_INF() << "Run instances" << Log::Field("numRequests", requests.Size());
+
+    for (const auto& request : requests) {
+        LOG_INF() << "Run instance request" << Log::Field("itemID", request.mItemID)
+                  << Log::Field("type", request.mUpdateItemType) << Log::Field("version", request.mVersion)
+                  << Log::Field("numInstances", request.mNumInstances);
+    }
+
     WaitAllNodesConnected(updateLock);
 
     if (!mIsRunning) {
@@ -310,6 +316,13 @@ void Launcher::UpdateInstanceStatuses()
         return;
     }
 
+    for (const auto& status : mInstanceStatuses) {
+        LOG_INF() << "Instance status changed" << Log::Field("instance", static_cast<const InstanceIdent&>(status))
+                  << Log::Field("version", status.mVersion) << Log::Field("nodeID", status.mNodeID)
+                  << Log::Field("runtimeID", status.mRuntimeID) << Log::Field("manifestDigest", status.mManifestDigest)
+                  << Log::Field("state", status.mState) << Log::Field(status.mError);
+    }
+
     for (auto& listener : mInstanceStatusListeners) {
         listener->OnInstancesStatusesChanged(mInstanceStatuses);
     }
@@ -403,7 +416,7 @@ void Launcher::ProcessUpdate()
                     LOG_ERR() << "Failed to resend instances" << Log::Field(AOS_ERROR_WRAP(err));
                 }
             } else {
-                LOG_INF() << "Rebalancing will be performed, skip resending instances";
+                LOG_DBG() << "Rebalancing will be performed, skip resending instances";
             }
 
             mUpdatedNodes.Clear();
@@ -514,7 +527,10 @@ void Launcher::CreateRequestedInstances(
 
 Error Launcher::OnInstanceStatusReceived(const InstanceStatus& status)
 {
-    LOG_INF() << "Instance status received" << Log::Field("instance", static_cast<const InstanceIdent&>(status));
+    LOG_INF() << "Instance status received" << Log::Field("instance", static_cast<const InstanceIdent&>(status))
+              << Log::Field("version", status.mVersion) << Log::Field("nodeID", status.mNodeID)
+              << Log::Field("runtimeID", status.mRuntimeID) << Log::Field("manifestDigest", status.mManifestDigest)
+              << Log::Field("state", status.mState) << Log::Field(status.mError);
 
     LockGuard updateLock {mUpdateMutex};
 
@@ -529,7 +545,13 @@ Error Launcher::OnInstanceStatusReceived(const InstanceStatus& status)
 
 Error Launcher::OnNodeInstancesStatusesReceived(const String& nodeID, const Array<InstanceStatus>& statuses)
 {
-    LOG_INF() << "Node instances statuses received" << Log::Field("nodeID", nodeID);
+    for (const auto& status : statuses) {
+        LOG_INF() << "Node instance status received"
+                  << Log::Field("instance", static_cast<const InstanceIdent&>(status))
+                  << Log::Field("version", status.mVersion) << Log::Field("nodeID", status.mNodeID)
+                  << Log::Field("runtimeID", status.mRuntimeID) << Log::Field("manifestDigest", status.mManifestDigest)
+                  << Log::Field("state", status.mState) << Log::Field(status.mError);
+    }
 
     LockGuard updateLock {mUpdateMutex};
 
diff --git a/src/core/cm/launcher/node.cpp b/src/core/cm/launcher/node.cpp
index 7bb893683..4966df835 100644
--- a/src/core/cm/launcher/node.cpp
+++ b/src/core/cm/launcher/node.cpp
@@ -331,10 +331,20 @@ Error Node::SendScheduledInstances(
         }
     }
 
-    LOG_INF() << "Send scheduled instances" << Log::Field("nodeID", mInfo.mNodeID)
+    LOG_INF() << "Update node instances" << Log::Field("nodeID", mInfo.mNodeID)
               << Log::Field("stopInstances", stopInstances->Size())
               << Log::Field("startInstances", startInstances->Size());
 
+    for (const auto& instance : *stopInstances) {
+        LOG_INF() << "Update node stop instance" << Log::Field("instance", static_cast<const InstanceIdent&>(instance))
+                  << Log::Field("version", instance.mVersion) << Log::Field("runtimeID", instance.mRuntimeID);
+    }
+
+    for (const auto& instance : *startInstances) {
+        LOG_INF() << "Update node start instance" << Log::Field("instance", static_cast<const InstanceIdent&>(instance))
+                  << Log::Field("version", instance.mVersion) << Log::Field("runtimeID", instance.mRuntimeID);
+    }
+
     if (auto err = mInstanceRunner->UpdateInstances(mInfo.mNodeID, *stopInstances, *startInstances); !err.IsNone()) {
         return AOS_ERROR_WRAP(err);
     }
@@ -382,6 +392,16 @@ RetWithError<bool> Node::ResendInstances(
               << Log::Field("stopInstances", stopInstances->Size())
               << Log::Field("startInstances", startInstances->Size());
 
+    for (const auto& instance : *stopInstances) {
+        LOG_INF() << "Update node stop instance" << Log::Field("instance", static_cast<const InstanceIdent&>(instance))
+                  << Log::Field("version", instance.mVersion) << Log::Field("runtimeID", instance.mRuntimeID);
+    }
+
+    for (const auto& instance : *startInstances) {
+        LOG_INF() << "Update node start instance" << Log::Field("instance", static_cast<const InstanceIdent&>(instance))
+                  << Log::Field("version", instance.mVersion) << Log::Field("runtimeID", instance.mRuntimeID);
+    }
+
     if (auto err = mInstanceRunner->UpdateInstances(mInfo.mNodeID, *stopInstances, *startInstances); !err.IsNone()) {
         return {false, AOS_ERROR_WRAP(err)};
     }
diff --git a/src/core/cm/launcher/tests/launcher.cpp b/src/core/cm/launcher/tests/launcher.cpp
index ddf059078..e90d0ecbd 100644
--- a/src/core/cm/launcher/tests/launcher.cpp
+++ b/src/core/cm/launcher/tests/launcher.cpp
@@ -124,7 +124,7 @@ class CMLauncherTest : public testing::Test {
     {
         tests::utils::InitLog();
 
-        LOG_INF() << "Launcher size: size=" << sizeof(Launcher);
+        LOG_INF() << "Launcher size" << Log::Field("size", sizeof(Launcher));
 
         ASSERT_TRUE(mIdentProvider.SetSubjects({cSubject1}).IsNone());
     }
diff --git a/src/core/cm/monitoring/monitoring.cpp b/src/core/cm/monitoring/monitoring.cpp
index a69f6a307..ae7c9198d 100644
--- a/src/core/cm/monitoring/monitoring.cpp
+++ b/src/core/cm/monitoring/monitoring.cpp
@@ -277,6 +277,9 @@ Error Monitoring::SendMonitoringData()
         return ErrorEnum::eNone;
     }
 
+    LOG_INF() << "Send monitoring data" << Log::Field("nodesCount", mMonitoring.mNodes.Size())
+              << Log::Field("instancesCount", mMonitoring.mInstances.Size());
+
     if (auto err = mSender->SendMonitoring(mMonitoring); !err.IsNone()) {
         return AOS_ERROR_WRAP(err);
     }
diff --git a/src/core/cm/nodeinfoprovider/nodeinfoprovider.cpp b/src/core/cm/nodeinfoprovider/nodeinfoprovider.cpp
index 05024975e..e29e2cd6d 100644
--- a/src/core/cm/nodeinfoprovider/nodeinfoprovider.cpp
+++ b/src/core/cm/nodeinfoprovider/nodeinfoprovider.cpp
@@ -216,7 +216,7 @@ void NodeInfoProvider::OnNodeInfoChanged(const NodeInfo& info)
 {
     LockGuard lock {mMutex};
 
-    LOG_DBG() << "Node info changed" << Log::Field("nodeID", info.mNodeID) << Log::Field("state", info.mState)
+    LOG_DBG() << "IAM node info changed" << Log::Field("nodeID", info.mNodeID) << Log::Field("state", info.mState)
               << Log::Field("isConnected", info.mIsConnected) << Log::Field(info.mError);
 
     auto it = AddOrGetCacheItem(info.mNodeID);
@@ -253,8 +253,9 @@ void NodeInfoProvider::NotifyListeners(const NodeInfoCache& info)
 
     info.GetUnitNodeInfo(*unitNodeInfo);
 
-    LOG_DBG() << "Send node info changed" << Log::Field("nodeID", unitNodeInfo->mNodeID)
-              << Log::Field("state", unitNodeInfo->mState) << Log::Field("isConnected", unitNodeInfo->mIsConnected);
+    LOG_INF() << "Node info changed" << Log::Field("nodeID", unitNodeInfo->mNodeID)
+              << Log::Field("state", unitNodeInfo->mState) << Log::Field("isConnected", unitNodeInfo->mIsConnected)
+              << Log::Field(unitNodeInfo->mError);
 
     for (auto* listener : mListeners) {
         listener->OnNodeInfoChanged(*unitNodeInfo);
diff --git a/src/core/cm/storagestate/storagestate.cpp b/src/core/cm/storagestate/storagestate.cpp
index de9dde03a..4357f97b8 100644
--- a/src/core/cm/storagestate/storagestate.cpp
+++ b/src/core/cm/storagestate/storagestate.cpp
@@ -87,7 +87,7 @@ Error StorageState::Start()
 {
     LockGuard lock {mMutex};
 
-    LOG_INF() << "Start storage state";
+    LOG_DBG() << "Start storage state";
 
     if (auto err = InitStateWatching(); !err.IsNone()) {
         return AOS_ERROR_WRAP(err);
@@ -100,7 +100,7 @@ Error StorageState::Stop()
 {
     LockGuard lock {mMutex};
 
-    LOG_INF() << "Stop storage state";
+    LOG_DBG() << "Stop storage state";
 
     while (!mStates.IsEmpty()) {
         if (auto err = StopStateWatching(mStates.Front().mInstanceIdent);
@@ -531,7 +531,7 @@ Error StorageState::StopStateWatching(const InstanceIdent& instanceIdent)
 
     auto it = mStates.FindIf([&instanceIdent](const auto& item) { return item.mInstanceIdent == instanceIdent; });
     if (it == mStates.end()) {
-        return ErrorEnum::eNotFound;
+        return ErrorEnum::eNone;
     }
 
     auto err = mFSWatcher->Unsubscribe(it->mFilePath.CStr(), *this);
diff --git a/src/core/cm/storagestate/tests/storagestate.cpp b/src/core/cm/storagestate/tests/storagestate.cpp
index 2b106cd03..9398b5fe8 100644
--- a/src/core/cm/storagestate/tests/storagestate.cpp
+++ b/src/core/cm/storagestate/tests/storagestate.cpp
@@ -535,7 +535,7 @@ TEST_F(StorageStateTests, Cleanup)
     EXPECT_TRUE(err.IsNone());
 
     err = mStorageState.Cleanup(cInstanceIdent);
-    EXPECT_TRUE(err.Is(ErrorEnum::eNotFound));
+    EXPECT_TRUE(err.IsNone());
 
     InstanceInfo storageData;
 
diff --git a/src/core/cm/unitconfig/unitconfig.cpp b/src/core/cm/unitconfig/unitconfig.cpp
index f5713bba0..6b8a07f65 100644
--- a/src/core/cm/unitconfig/unitconfig.cpp
+++ b/src/core/cm/unitconfig/unitconfig.cpp
@@ -53,7 +53,7 @@ Error UnitConfig::CheckUnitConfig(const aos::UnitConfig& config)
 {
     LockGuard lock {mMutex};
 
-    LOG_DBG() << "Check unit config" << Log::Field("version", config.mVersion);
+    LOG_INF() << "Check unit config" << Log::Field("version", config.mVersion);
 
     if (mUnitConfigState != UnitConfigStateEnum::eInstalled) {
         LOG_WRN() << "Skip unit config version check due to state" << Log::Field("state", mUnitConfigState)
@@ -104,7 +104,7 @@ Error UnitConfig::UpdateUnitConfig(const aos::UnitConfig& unitConfig)
 {
     LockGuard lock {mMutex};
 
-    LOG_DBG() << "Update unit config" << Log::Field("version", unitConfig.mVersion);
+    LOG_INF() << "Update unit config" << Log::Field("version", unitConfig.mVersion);
 
     if (mUnitConfigState != UnitConfigStateEnum::eInstalled && mUnitConfigState != UnitConfigStateEnum::eAbsent) {
         LOG_WRN() << "Skip unit config version check due to state" << Log::Field("state", mUnitConfigState)
diff --git a/src/core/cm/updatemanager/desiredstatushandler.cpp b/src/core/cm/updatemanager/desiredstatushandler.cpp
index 0eae81379..6286a2b45 100644
--- a/src/core/cm/updatemanager/desiredstatushandler.cpp
+++ b/src/core/cm/updatemanager/desiredstatushandler.cpp
@@ -261,25 +261,27 @@ void DesiredStatusHandler::Run()
 void DesiredStatusHandler::LogDesiredStatus(const DesiredStatus& desiredStatus)
 {
     for (const auto& node : desiredStatus.mNodes) {
-        LOG_DBG() << "Node" << Log::Field("id", node.mNodeID) << Log::Field("state", node.mState);
+        LOG_INF() << "Desired status node" << Log::Field("id", node.mNodeID) << Log::Field("state", node.mState);
     }
 
     if (desiredStatus.mUnitConfig.HasValue()) {
-        LOG_DBG() << "Unit config update" << Log::Field("version", desiredStatus.mUnitConfig->mVersion);
+        LOG_INF() << "Desired status unit config update" << Log::Field("version", desiredStatus.mUnitConfig->mVersion);
     }
 
     for (const auto& item : desiredStatus.mUpdateItems) {
-        LOG_DBG() << "Update item" << Log::Field("id", item.mItemID) << Log::Field("version", item.mVersion);
+        LOG_INF() << "Desired status update item" << Log::Field("id", item.mItemID)
+                  << Log::Field("version", item.mVersion);
     }
 
     for (const auto& instance : desiredStatus.mInstances) {
-        LOG_DBG() << "Instance" << Log::Field("itemID", instance.mItemID)
+        LOG_INF() << "Desired status instance" << Log::Field("itemID", instance.mItemID)
                   << Log::Field("subjectID", instance.mSubjectID) << Log::Field("numInstances", instance.mNumInstances)
                   << Log::Field("priority", instance.mPriority);
     }
 
     for (const auto& subject : desiredStatus.mSubjects) {
-        LOG_DBG() << "Subject" << Log::Field("id", subject.mSubjectID) << Log::Field("type", subject.mSubjectType);
+        LOG_INF() << "Desired status subject" << Log::Field("id", subject.mSubjectID)
+                  << Log::Field("type", subject.mSubjectType);
     }
 }
 
@@ -289,7 +291,7 @@ void DesiredStatusHandler::SetState(UpdateState state)
         return;
     }
 
-    LOG_DBG() << "Update state changed" << Log::Field("state", state);
+    LOG_INF() << "Update state changed" << Log::Field("state", state);
 
     if (auto err = mStorage->StoreUpdateState(state); !err.IsNone()) {
         LOG_ERR() << "Failed to store update state" << Log::Field(err);
@@ -327,13 +329,19 @@ Error DesiredStatusHandler::InstallDesiredStatus()
     for (const auto& node : mCurrentDesiredStatus.mNodes) {
         LOG_DBG() << "Set node state" << Log::Field("id", node.mNodeID) << Log::Field("state", node.mState);
 
+        Error updateErr;
+
         if (node.mState == DesiredNodeStateEnum::ePaused) {
-            if (auto err = mNodeHandler->PauseNode(node.mNodeID); !err.IsNone()) {
-                LOG_ERR() << "Failed to set node state" << Log::Field("id", node.mNodeID) << Log::Field(err);
-            }
+            updateErr = mNodeHandler->PauseNode(node.mNodeID);
         } else {
-            if (auto err = mNodeHandler->ResumeNode(node.mNodeID); !err.IsNone()) {
-                LOG_ERR() << "Failed to set node state" << Log::Field("id", node.mNodeID) << Log::Field(err);
+            updateErr = mNodeHandler->ResumeNode(node.mNodeID);
+        }
+
+        if (!updateErr.IsNone()) {
+            LOG_ERR() << "Failed to set node state" << Log::Field("id", node.mNodeID) << Log::Field(updateErr);
+
+            if (auto err = mUnitStatusHandler->SetUpdateNodeStatus(node.mNodeID, updateErr); !err.IsNone()) {
+                LOG_ERR() << "Failed to set update node status" << Log::Field("id", node.mNodeID) << Log::Field(err);
             }
         }
     }
@@ -341,14 +349,21 @@ Error DesiredStatusHandler::InstallDesiredStatus()
     if (mCurrentDesiredStatus.mUnitConfig.HasValue()) {
         LOG_DBG() << "Update unit config" << Log::Field("version", mCurrentDesiredStatus.mUnitConfig->mVersion);
 
-        auto err = mUnitConfig->CheckUnitConfig(mCurrentDesiredStatus.mUnitConfig.GetValue());
+        auto updateErr = mUnitConfig->CheckUnitConfig(mCurrentDesiredStatus.mUnitConfig.GetValue());
+
+        if (updateErr.IsNone()) {
+            updateErr = mUnitConfig->UpdateUnitConfig(mCurrentDesiredStatus.mUnitConfig.GetValue());
+        }
 
-        if (err.IsNone()) {
-            err = mUnitConfig->UpdateUnitConfig(mCurrentDesiredStatus.mUnitConfig.GetValue());
+        if (!updateErr.IsNone()) {
+            LOG_ERR() << "Failed to update unit config" << Log::Field(updateErr);
         }
 
-        if (!err.IsNone()) {
-            LOG_ERR() << "Failed to update unit config" << Log::Field(err);
+        if (auto err = mUnitStatusHandler->SetUpdateUnitConfigStatus(
+                UnitConfigStatus {mCurrentDesiredStatus.mUnitConfig->mVersion,
+                    updateErr.IsNone() ? UnitConfigStateEnum::eInstalled : UnitConfigStateEnum::eFailed, updateErr});
+            !err.IsNone()) {
+            LOG_ERR() << "Failed to set unit config status" << Log::Field(err);
         }
     }
 
diff --git a/src/core/cm/updatemanager/tests/updatemanager.cpp b/src/core/cm/updatemanager/tests/updatemanager.cpp
index 4ed72545f..464e91799 100644
--- a/src/core/cm/updatemanager/tests/updatemanager.cpp
+++ b/src/core/cm/updatemanager/tests/updatemanager.cpp
@@ -42,12 +42,13 @@ const auto                cCVTimeout             = std::chrono::seconds(5);
  **********************************************************************************************************************/
 
 void SetNodeInfo(UnitNodeInfo& nodeInfo, const String& nodeID, const String& nodeType,
-    const NodeState& state = NodeStateEnum::eProvisioned, bool isConnected = true)
+    const NodeState& state = NodeStateEnum::eProvisioned, bool isConnected = true, Error error = ErrorEnum::eNone)
 {
     nodeInfo.mNodeID      = nodeID;
     nodeInfo.mNodeType    = nodeType;
     nodeInfo.mState       = state;
     nodeInfo.mIsConnected = isConnected;
+    nodeInfo.mError       = error;
 
     ResourceInfo resourceInfo1;
 
@@ -81,7 +82,7 @@ void SetNodeInfo(UnitNodeInfo& nodeInfo, const String& nodeID, const String& nod
 }
 
 void CreateNodeInfo(UnitStatus& unitStatus, const String& nodeID, const String& nodeType,
-    const NodeState& state = NodeStateEnum::eProvisioned, bool isConnected = true)
+    const NodeState& state = NodeStateEnum::eProvisioned, bool isConnected = true, Error error = ErrorEnum::eNone)
 {
     if (!unitStatus.mNodes.HasValue()) {
         unitStatus.mNodes.EmplaceValue();
@@ -89,16 +90,16 @@ void CreateNodeInfo(UnitStatus& unitStatus, const String& nodeID, const String&
 
     unitStatus.mNodes->EmplaceBack();
 
-    SetNodeInfo(unitStatus.mNodes->Back(), nodeID, nodeType, state, isConnected);
+    SetNodeInfo(unitStatus.mNodes->Back(), nodeID, nodeType, state, isConnected, error);
 }
 
 void ChangeNodeInfo(UnitStatus& unitStatus, const String& nodeID, const String& nodeType,
-    const NodeState& state = NodeStateEnum::eProvisioned, bool isConnected = true)
+    const NodeState& state = NodeStateEnum::eProvisioned, bool isConnected = true, Error error = ErrorEnum::eNone)
 {
     auto it = unitStatus.mNodes->FindIf([&nodeID](const UnitNodeInfo& nodeInfo) { return nodeInfo.mNodeID == nodeID; });
     EXPECT_NE(it, unitStatus.mNodes->end());
 
-    SetNodeInfo(*it, nodeID, nodeType, state, isConnected);
+    SetNodeInfo(*it, nodeID, nodeType, state, isConnected, error);
 }
 
 void CreateUpdateItemStatus(UnitStatus& unitStatus, const String& itemID, const String& version,
@@ -694,7 +695,7 @@ TEST_F(UpdateManagerTest, ProcessFullDesiredStatus)
 
     // Set desired unit config
 
-    desiredStatus->mUnitConfig.EmplaceValue(UnitConfig {"2.0.0", "1.0.0", {}});
+    desiredStatus->mUnitConfig.EmplaceValue(UnitConfig {"1.0.0", "2.0.0", {}});
 
     // Set desired update items
 
@@ -727,8 +728,6 @@ TEST_F(UpdateManagerTest, ProcessFullDesiredStatus)
 
     // Set expected unit config status
 
-    expectedUnitStatus->mUnitConfig.EmplaceValue();
-
     CreateUnitConfigStatus(*expectedUnitStatus, "2.0.0");
 
     // Set expected update items status
@@ -982,4 +981,93 @@ TEST_F(UpdateManagerTest, ResumeUpdateAfterRestart)
     EXPECT_EQ(mSenderStub.WaitSendUnitStatus(), *expectedUnitStatus);
 }
 
+TEST_F(UpdateManagerTest, SetUpdateStatuses)
+{
+    auto expectedUnitStatus = std::make_unique<UnitStatus>();
+    auto desiredStatus      = std::make_unique<DesiredStatus>();
+
+    EmptyUnitStatus(*expectedUnitStatus);
+
+    // Notify cloud connection established
+
+    mConnectionListener->OnConnect();
+    EXPECT_EQ(mSenderStub.WaitSendUnitStatus(), *expectedUnitStatus);
+
+    // Set desired node states
+
+    desiredStatus->mNodes.EmplaceBack(DesiredNodeStateInfo {"node1", DesiredNodeStateEnum::ePaused});
+
+    // Set desired unit config
+
+    desiredStatus->mUnitConfig.EmplaceValue(UnitConfig {"1.0.0", "2.0.0", {}});
+
+    // Set expected node infos
+
+    CreateNodeInfo(*expectedUnitStatus, "node1", "type1", NodeStateEnum::eProvisioned, true, ErrorEnum::eFailed);
+
+    // Set expected unit config status
+
+    expectedUnitStatus->mUnitConfig.EmplaceValue();
+    expectedUnitStatus->mUnitConfig->EmplaceBack(
+        UnitConfigStatus {"1.0.0", UnitConfigStateEnum::eInstalled, ErrorEnum::eNone});
+    expectedUnitStatus->mUnitConfig->EmplaceBack(
+        UnitConfigStatus {"2.0.0", UnitConfigStateEnum::eFailed, ErrorEnum::eFailed});
+
+    // Expect calls
+
+    EXPECT_CALL(mNodeHandlerMock, PauseNode(String("node1"))).WillOnce(Return(ErrorEnum::eFailed));
+    EXPECT_CALL(mUnitConfigMock, CheckUnitConfig(desiredStatus->mUnitConfig.GetValue())).Times(1);
+    EXPECT_CALL(mUnitConfigMock, UpdateUnitConfig(desiredStatus->mUnitConfig.GetValue()))
+        .WillOnce(Return(ErrorEnum::eFailed));
+    EXPECT_CALL(mNodeInfoProviderMock, GetAllNodeIDs(_)).WillOnce(Invoke([&](Array<StaticString<cIDLen>>& nodeIDs) {
+        nodeIDs.EmplaceBack("node1");
+
+        return ErrorEnum::eNone;
+    }));
+    EXPECT_CALL(mNodeInfoProviderMock, GetNodeInfo(String("node1"), _))
+        .WillOnce(DoAll(SetArgReferee<1>(expectedUnitStatus->mNodes.GetValue()[0]), Return(ErrorEnum::eNone)));
+    EXPECT_CALL(mUnitConfigMock, GetUnitConfigStatus(_))
+        .WillOnce(DoAll(SetArgReferee<0>(expectedUnitStatus->mUnitConfig.GetValue()[0]), Return(ErrorEnum::eNone)));
+
+    // Send desired status to set statuses
+
+    auto err = mUpdateManager.ProcessDesiredStatus(*desiredStatus);
+    EXPECT_TRUE(err.IsNone()) << "Failed to process desired status: " << tests::utils::ErrorToStr(err);
+
+    EXPECT_EQ(mSenderStub.WaitSendUnitStatus(), *expectedUnitStatus);
+
+    EmptyUnitStatus(*expectedUnitStatus);
+
+    // Set expected node infos
+
+    CreateNodeInfo(*expectedUnitStatus, "node1", "type1", NodeStateEnum::ePaused);
+
+    // Set expected unit config status
+
+    CreateUnitConfigStatus(*expectedUnitStatus, "2.0.0");
+
+    // Expect calls
+
+    EXPECT_CALL(mNodeHandlerMock, PauseNode(String("node1"))).WillOnce(Return(ErrorEnum::eNone));
+    EXPECT_CALL(mUnitConfigMock, CheckUnitConfig(desiredStatus->mUnitConfig.GetValue())).Times(1);
+    EXPECT_CALL(mUnitConfigMock, UpdateUnitConfig(desiredStatus->mUnitConfig.GetValue()))
+        .WillOnce(Return(ErrorEnum::eNone));
+    EXPECT_CALL(mNodeInfoProviderMock, GetAllNodeIDs(_)).WillOnce(Invoke([&](Array<StaticString<cIDLen>>& nodeIDs) {
+        nodeIDs.EmplaceBack("node1");
+
+        return ErrorEnum::eNone;
+    }));
+    EXPECT_CALL(mNodeInfoProviderMock, GetNodeInfo(String("node1"), _))
+        .WillOnce(DoAll(SetArgReferee<1>(expectedUnitStatus->mNodes.GetValue()[0]), Return(ErrorEnum::eNone)));
+    EXPECT_CALL(mUnitConfigMock, GetUnitConfigStatus(_))
+        .WillOnce(DoAll(SetArgReferee<0>(expectedUnitStatus->mUnitConfig.GetValue()[0]), Return(ErrorEnum::eNone)));
+
+    // Send desired status again to update statuses
+
+    err = mUpdateManager.ProcessDesiredStatus(*desiredStatus);
+    EXPECT_TRUE(err.IsNone()) << "Failed to process desired status: " << tests::utils::ErrorToStr(err);
+
+    EXPECT_EQ(mSenderStub.WaitSendUnitStatus(), *expectedUnitStatus);
+}
+
 } // namespace aos::cm::updatemanager
diff --git a/src/core/cm/updatemanager/unitstatushandler.cpp b/src/core/cm/updatemanager/unitstatushandler.cpp
index 6a012cc9a..fc7abdde7 100644
--- a/src/core/cm/updatemanager/unitstatushandler.cpp
+++ b/src/core/cm/updatemanager/unitstatushandler.cpp
@@ -131,12 +131,52 @@ Error UnitStatusHandler::SendFullUnitStatus()
     }
 
     ClearUnitStatus();
+    ClearUpdateStatuses();
 
     mTimer.Stop();
 
     return ErrorEnum::eNone;
 }
 
+Error UnitStatusHandler::SetUpdateUnitConfigStatus(const UnitConfigStatus& status)
+{
+    LockGuard lock {mMutex};
+
+    LOG_INF() << "Unit config status changed" << Log::Field("version", status.mVersion)
+              << Log::Field("state", status.mState) << Log::Field(status.mError);
+
+    mUpdateUnitConfigStatus = status;
+
+    if (!mCloudConnected) {
+        return ErrorEnum::eNone;
+    }
+
+    if (!mUnitStatus.mUnitConfig.HasValue()) {
+        mUnitStatus.mUnitConfig.EmplaceValue();
+    } else {
+        mUnitStatus.mUnitConfig->Clear();
+    }
+
+    if (auto err = mUnitStatus.mUnitConfig->EmplaceBack(status); !err.IsNone()) {
+        return AOS_ERROR_WRAP(err);
+    }
+
+    return ErrorEnum::eNone;
+}
+
+Error UnitStatusHandler::SetUpdateNodeStatus(const String& nodeID, const Error& updateErr)
+{
+    LockGuard lock {mMutex};
+
+    LOG_INF() << "Node update status changed" << Log::Field("nodeID", nodeID) << Log::Field(updateErr);
+
+    if (auto err = mUpdateNodeStatuses.Set(nodeID, updateErr); !err.IsNone()) {
+        return AOS_ERROR_WRAP(err);
+    }
+
+    return ErrorEnum::eNone;
+}
+
 /***********************************************************************************************************************
  * Private
  **********************************************************************************************************************/
@@ -145,9 +185,18 @@ void UnitStatusHandler::OnNodeInfoChanged(const UnitNodeInfo& info)
 {
     LockGuard lock {mMutex};
 
-    LOG_INF() << "Node info changed" << Log::Field("id", info.mNodeID) << Log::Field("type", info.mNodeType)
+    auto nodeError = info.mError;
+
+    if (nodeError.IsNone()) {
+        auto updateNodeStatusIt = mUpdateNodeStatuses.Find(info.mNodeID);
+        if (updateNodeStatusIt != mUpdateNodeStatuses.end()) {
+            nodeError = updateNodeStatusIt->mSecond;
+        }
+    }
+
+    LOG_DBG() << "Node info changed" << Log::Field("id", info.mNodeID) << Log::Field("type", info.mNodeType)
               << Log::Field("state", info.mState) << Log::Field("isConnected", info.mIsConnected)
-              << Log::Field(info.mError);
+              << Log::Field(nodeError);
 
     if (!mCloudConnected) {
         return;
@@ -176,7 +225,7 @@ void UnitStatusHandler::OnItemsStatusesChanged(const Array<UpdateItemStatus>& st
     LockGuard lock {mMutex};
 
     for (const auto& status : statuses) {
-        LOG_INF() << "Item status changed" << Log::Field("itemID", status.mItemID)
+        LOG_DBG() << "Item status changed" << Log::Field("itemID", status.mItemID)
                   << Log::Field("version", status.mVersion) << Log::Field("state", status.mState)
                   << Log::Field(status.mError);
     }
@@ -216,7 +265,7 @@ void UnitStatusHandler::OnInstancesStatusesChanged(const Array<InstanceStatus>&
     LockGuard lock {mMutex};
 
     for (const auto& status : statuses) {
-        LOG_INF() << "Instance status changed" << Log::Field("instance", static_cast<const InstanceIdent&>(status))
+        LOG_DBG() << "Instance status changed" << Log::Field("instance", static_cast<const InstanceIdent&>(status))
                   << Log::Field("version", status.mVersion) << Log::Field("nodeID", status.mNodeID)
                   << Log::Field("runtimeID", status.mRuntimeID) << Log::Field("manifestDigest", status.mManifestDigest)
                   << Log::Field("state", status.mState) << Log::Field(status.mError);
@@ -323,10 +372,18 @@ Error UnitStatusHandler::SetUnitConfigStatus()
     mUnitStatus.mUnitConfig.EmplaceValue();
     mUnitStatus.mUnitConfig->EmplaceBack();
 
-    if (auto err = mUnitConfig->GetUnitConfigStatus(mUnitStatus.mUnitConfig.GetValue()[0]); !err.IsNone()) {
+    auto& unitConfigStatus = mUnitStatus.mUnitConfig->Back();
+
+    if (auto err = mUnitConfig->GetUnitConfigStatus(unitConfigStatus); !err.IsNone()) {
         return AOS_ERROR_WRAP(err);
     }
 
+    if (mUpdateUnitConfigStatus.HasValue() && mUpdateUnitConfigStatus->mVersion != unitConfigStatus.mVersion) {
+        if (auto err = mUnitStatus.mUnitConfig->EmplaceBack(mUpdateUnitConfigStatus.GetValue()); !err.IsNone()) {
+            return AOS_ERROR_WRAP(err);
+        }
+    }
+
     return ErrorEnum::eNone;
 }
 
@@ -347,6 +404,13 @@ Error UnitStatusHandler::SetNodesInfo()
         if (auto err = mNodeInfoProvider->GetNodeInfo(nodeIDs[i], nodeInfo); !err.IsNone()) {
             return AOS_ERROR_WRAP(err);
         }
+
+        if (nodeInfo.mError.IsNone()) {
+            auto updateNodeStatusIt = mUpdateNodeStatuses.Find(nodeInfo.mNodeID);
+            if (updateNodeStatusIt != mUpdateNodeStatuses.end()) {
+                nodeInfo.mError = updateNodeStatusIt->mSecond;
+            }
+        }
     }
 
     return ErrorEnum::eNone;
@@ -410,22 +474,22 @@ void UnitStatusHandler::LogUnitStatus()
 {
     if (mUnitStatus.mUnitConfig.HasValue()) {
         for (const auto& unitConfigStatus : mUnitStatus.mUnitConfig.GetValue()) {
-            LOG_DBG() << "Unit config status" << Log::Field("version", unitConfigStatus.mVersion)
+            LOG_INF() << "Unit status unit config" << Log::Field("version", unitConfigStatus.mVersion)
                       << Log::Field("state", unitConfigStatus.mState) << Log::Field(unitConfigStatus.mError);
         }
     }
 
     if (mUnitStatus.mNodes.HasValue()) {
         for (const auto& nodeInfo : mUnitStatus.mNodes.GetValue()) {
-            LOG_DBG() << "Node info" << Log::Field("id", nodeInfo.mNodeID) << Log::Field("type", nodeInfo.mNodeType)
-                      << Log::Field("isConnected", nodeInfo.mIsConnected) << Log::Field("state", nodeInfo.mState)
-                      << Log::Field(nodeInfo.mError);
+            LOG_INF() << "Unit status node info" << Log::Field("id", nodeInfo.mNodeID)
+                      << Log::Field("type", nodeInfo.mNodeType) << Log::Field("isConnected", nodeInfo.mIsConnected)
+                      << Log::Field("state", nodeInfo.mState) << Log::Field(nodeInfo.mError);
         }
     }
 
     if (mUnitStatus.mUpdateItems.HasValue()) {
         for (const auto& itemStatus : *mUnitStatus.mUpdateItems) {
-            LOG_DBG() << "Update item status" << Log::Field("id", itemStatus.mItemID)
+            LOG_INF() << "Unit status update item" << Log::Field("id", itemStatus.mItemID)
                       << Log::Field("version", itemStatus.mVersion) << Log::Field("state", itemStatus.mState)
                       << Log::Field(itemStatus.mError);
         }
@@ -433,12 +497,12 @@ void UnitStatusHandler::LogUnitStatus()
 
     if (mUnitStatus.mInstances.HasValue()) {
         for (const auto& instanceStatuses : *mUnitStatus.mInstances) {
-            LOG_DBG() << "Instances statuses" << Log::Field("itemID", instanceStatuses.mItemID)
+            LOG_INF() << "Unit status instances" << Log::Field("itemID", instanceStatuses.mItemID)
                       << Log::Field("subjectID", instanceStatuses.mSubjectID)
                       << Log::Field("version", instanceStatuses.mVersion);
 
             for (const auto& instanceStatus : instanceStatuses.mInstances) {
-                LOG_DBG() << "Instance status" << Log::Field("instance", instanceStatus.mInstance)
+                LOG_INF() << "Unit status instance" << Log::Field("instance", instanceStatus.mInstance)
                           << Log::Field("manifestDigest", instanceStatus.mManifestDigest)
                           << Log::Field("nodeID", instanceStatus.mNodeID)
                           << Log::Field("runtimeID", instanceStatus.mRuntimeID)
@@ -449,7 +513,7 @@ void UnitStatusHandler::LogUnitStatus()
 
     if (mUnitStatus.mUnitSubjects.HasValue()) {
         for (const auto& subjectID : *mUnitStatus.mUnitSubjects) {
-            LOG_DBG() << "Unit subject" << Log::Field("id", subjectID);
+            LOG_INF() << "Unit status unit subject" << Log::Field("id", subjectID);
         }
     }
 };
@@ -464,6 +528,12 @@ void UnitStatusHandler::ClearUnitStatus()
     mUnitStatus.mUnitSubjects.Reset();
 };
 
+void UnitStatusHandler::ClearUpdateStatuses()
+{
+    mUpdateUnitConfigStatus.Reset();
+    mUpdateNodeStatuses.Clear();
+}
+
 void UnitStatusHandler::StartTimer()
 {
     if (mTimerStarted) {
@@ -479,7 +549,7 @@ void UnitStatusHandler::StartTimer()
 
         mUnitStatus.mIsDeltaInfo = true;
 
-        LOG_DBG() << "Send delta unit status";
+        LOG_INF() << "Send delta unit status";
 
         LogUnitStatus();
 
diff --git a/src/core/cm/updatemanager/unitstatushandler.hpp b/src/core/cm/updatemanager/unitstatushandler.hpp
index abcd286e6..565ef4591 100644
--- a/src/core/cm/updatemanager/unitstatushandler.hpp
+++ b/src/core/cm/updatemanager/unitstatushandler.hpp
@@ -13,6 +13,8 @@
 #include <core/common/cloudconnection/itf/cloudconnection.hpp>
 #include <core/common/iamclient/itf/identprovider.hpp>
 #include <core/common/instancestatusprovider/itf/instancestatusprovider.hpp>
+#include <core/common/tools/map.hpp>
+#include <core/common/tools/optional.hpp>
 #include <core/common/tools/timer.hpp>
 
 #include "config.hpp"
@@ -73,6 +75,21 @@ class UnitStatusHandler : private nodeinfoprovider::NodeInfoListenerItf,
      */
     Error SendFullUnitStatus();
 
+    /**
+     * Sets update unit config status.
+     *
+     * @param status unit config status.
+     */
+    Error SetUpdateUnitConfigStatus(const UnitConfigStatus& status);
+
+    /**
+     * Sets update node status.
+     *
+     * @param nodeID node ID.
+     * @param updateErr update error.
+     */
+    Error SetUpdateNodeStatus(const String& nodeID, const Error& updateErr);
+
 private:
     static constexpr auto cAllocatorSize = sizeof(StaticArray<InstanceStatus, cMaxNumInstances>);
 
@@ -94,6 +111,7 @@ class UnitStatusHandler : private nodeinfoprovider::NodeInfoListenerItf,
     void OnDisconnect() override;
 
     void ClearUnitStatus();
+    void ClearUpdateStatuses();
     void StartTimer();
 
     Error SetUnitConfigStatus();
@@ -119,6 +137,9 @@ class UnitStatusHandler : private nodeinfoprovider::NodeInfoListenerItf,
     Timer    mTimer;
     bool     mTimerStarted {};
     Duration mUnitStatusSendTimeout {};
+
+    Optional<UnitConfigStatus>             mUpdateUnitConfigStatus;
+    StaticMap<String, Error, cMaxNumNodes> mUpdateNodeStatuses;
 };
 
 /** @}*/
diff --git a/src/core/common/tools/config.hpp b/src/core/common/tools/config.hpp
index 08ff7b86f..2fe8ab49a 100644
--- a/src/core/common/tools/config.hpp
+++ b/src/core/common/tools/config.hpp
@@ -31,7 +31,7 @@
  *
  */
 #ifndef AOS_CONFIG_LOG_LINE_LEN
-#define AOS_CONFIG_LOG_LINE_LEN 256
+#define AOS_CONFIG_LOG_LINE_LEN 512
 #endif
 
 /**
diff --git a/src/core/common/types/unitconfig.hpp b/src/core/common/types/unitconfig.hpp
index 16355be70..83763d96e 100644
--- a/src/core/common/types/unitconfig.hpp
+++ b/src/core/common/types/unitconfig.hpp
@@ -49,8 +49,8 @@ struct NodeConfig {
  * Unit config.
  */
 struct UnitConfig {
-    StaticString<cVersionLen>             mVersion;
     StaticString<cVersionLen>             mFormatVersion;
+    StaticString<cVersionLen>             mVersion;
     StaticArray<NodeConfig, cMaxNumNodes> mNodes;
 
     /**
@@ -61,7 +61,7 @@ struct UnitConfig {
      */
     bool operator==(const UnitConfig& rhs) const
     {
-        return mVersion == rhs.mVersion && mFormatVersion == rhs.mFormatVersion && mNodes == rhs.mNodes;
+        return mFormatVersion == rhs.mFormatVersion && mVersion == rhs.mVersion && mNodes == rhs.mNodes;
     }
 
     /**
diff --git a/src/core/iam/certhandler/certhandler.cpp b/src/core/iam/certhandler/certhandler.cpp
index 4566fa719..69800dc39 100644
--- a/src/core/iam/certhandler/certhandler.cpp
+++ b/src/core/iam/certhandler/certhandler.cpp
@@ -49,7 +49,7 @@ Error CertHandler::SetOwner(const String& certType, const String& password)
 {
     LockGuard lock {mMutex};
 
-    LOG_DBG() << "Set owner: type=" << certType;
+    LOG_INF() << "Set owner" << Log::Field("type", certType);
 
     auto* module = FindModule(certType);
     if (module == nullptr) {
@@ -68,7 +68,7 @@ Error CertHandler::Clear(const String& certType)
 {
     LockGuard lock {mMutex};
 
-    LOG_DBG() << "Clear all certificates: type=" << certType;
+    LOG_INF() << "Clear" << Log::Field("type", certType);
 
     auto* module = FindModule(certType);
     if (module == nullptr) {
@@ -88,7 +88,7 @@ Error CertHandler::CreateKey(
 {
     LockGuard lock {mMutex};
 
-    LOG_DBG() << "Create key: type=" << certType << ", subject=" << subjectCommonName;
+    LOG_INF() << "Create key" << Log::Field("type", certType) << Log::Field("subject", subjectCommonName);
 
     auto* module = FindModule(certType);
     if (module == nullptr) {
@@ -112,7 +112,7 @@ Error CertHandler::ApplyCertificate(const String& certType, const String& pemCer
 {
     LockGuard lock {mMutex};
 
-    LOG_DBG() << "Apply cert: type=" << certType;
+    LOG_INF() << "Apply cert" << Log::Field("type", certType);
 
     auto* module = FindModule(certType);
     if (module == nullptr) {
@@ -139,7 +139,7 @@ Error CertHandler::GetCert(
         return AOS_ERROR_WRAP(err);
     }
 
-    LOG_DBG() << "Get certificate: type=" << certType << ", serial=" << serialInHex;
+    LOG_DBG() << "Get certificate" << Log::Field("type", certType) << Log::Field("serial", serialInHex);
 
     auto* module = FindModule(certType);
     if (module == nullptr) {
@@ -158,7 +158,7 @@ Error CertHandler::SubscribeListener(const String& certType, iamclient::CertList
 {
     LockGuard lock {mMutex};
 
-    LOG_DBG() << "Subscribe certificate listener: type=" << certType;
+    LOG_DBG() << "Subscribe certificate listener" << Log::Field("type", certType);
 
     auto* module = FindModule(certType);
     if (module == nullptr) {
@@ -198,7 +198,7 @@ Error CertHandler::CreateSelfSignedCert(const String& certType, const String& pa
 {
     LockGuard lock {mMutex};
 
-    LOG_DBG() << "Create self signed cert: type=" << certType;
+    LOG_INF() << "Create self signed cert" << Log::Field("type", certType);
 
     auto* module = FindModule(certType);
     if (module == nullptr) {
@@ -256,6 +256,8 @@ Error CertHandler::UpdateCerts(CertModule& certModule)
         }
 
         if (subscription.mCertInfo != certInfo) {
+            LOG_INF() << "Cert changed" << Log::Field("type", subscription.mCertType);
+
             subscription.mCertListener->OnCertChanged(certInfo);
             subscription.mCertInfo = certInfo;
         }
diff --git a/src/core/iam/nodemanager/nodemanager.cpp b/src/core/iam/nodemanager/nodemanager.cpp
index c798062c3..b5a52a47f 100644
--- a/src/core/iam/nodemanager/nodemanager.cpp
+++ b/src/core/iam/nodemanager/nodemanager.cpp
@@ -259,6 +259,9 @@ RetWithError<NodeInfo*> NodeManager::AddNodeInfoToCache(const NodeInfo& info)
 
 void NodeManager::NotifyNodeInfoChange(const NodeInfo& nodeInfo)
 {
+    LOG_INF() << "Node info changed" << Log::Field("nodeID", nodeInfo.mNodeID) << Log::Field("state", nodeInfo.mState)
+              << Log::Field("connected", nodeInfo.mIsConnected) << Log::Field(nodeInfo.mError);
+
     for (auto& listener : mListeners) {
         listener->OnNodeInfoChanged(nodeInfo);
     }
diff --git a/src/core/iam/provisionmanager/provisionmanager.cpp b/src/core/iam/provisionmanager/provisionmanager.cpp
index 99506f312..b2e4f10e9 100644
--- a/src/core/iam/provisionmanager/provisionmanager.cpp
+++ b/src/core/iam/provisionmanager/provisionmanager.cpp
@@ -27,7 +27,7 @@ Error ProvisionManager::Init(ProvisionManagerCallbackItf& callback, certhandler:
 
 Error ProvisionManager::StartProvisioning(const String& password)
 {
-    LOG_DBG() << "Start provisioning";
+    LOG_INF() << "Start provisioning";
 
     auto err = mCallback->OnStartProvisioning(password);
     if (!err.IsNone()) {
@@ -41,7 +41,7 @@ Error ProvisionManager::StartProvisioning(const String& password)
     }
 
     for (const auto& certType : certTypes) {
-        LOG_DBG() << "Clear cert storage: type=" << certType;
+        LOG_DBG() << "Clear cert storage" << Log::Field("type", certType);
 
         if (err = mCertHandler->Clear(certType); !err.IsNone()) {
             return AOS_ERROR_WRAP(err);
@@ -49,7 +49,7 @@ Error ProvisionManager::StartProvisioning(const String& password)
     }
 
     for (const auto& certType : certTypes) {
-        LOG_DBG() << "Set owner: type=" << certType;
+        LOG_DBG() << "Set owner" << Log::Field("type", certType);
 
         if (err = mCertHandler->SetOwner(certType, password); !err.IsNone()) {
             return AOS_ERROR_WRAP(err);
@@ -61,7 +61,7 @@ Error ProvisionManager::StartProvisioning(const String& password)
         }
 
         if (certModuleConfig.mValue.mIsSelfSigned) {
-            LOG_DBG() << "Create self signed cert: type=" << certType;
+            LOG_DBG() << "Create self signed cert" << Log::Field("type", certType);
 
             if (err = mCertHandler->CreateSelfSignedCert(certType, password); !err.IsNone()) {
                 return AOS_ERROR_WRAP(err);
@@ -78,14 +78,14 @@ Error ProvisionManager::StartProvisioning(const String& password)
 
 Error ProvisionManager::FinishProvisioning(const String& password)
 {
-    LOG_DBG() << "Finish provisioning";
+    LOG_INF() << "Finish provisioning";
 
     return AOS_ERROR_WRAP(mCallback->OnFinishProvisioning(password));
 }
 
 Error ProvisionManager::Deprovision(const String& password)
 {
-    LOG_DBG() << "Deprovision";
+    LOG_INF() << "Deprovision";
 
     return AOS_ERROR_WRAP(mCallback->OnDeprovision(password));
 }
@@ -121,14 +121,14 @@ RetWithError<CertTypes> ProvisionManager::GetCertTypes() const
 
 Error ProvisionManager::CreateKey(const String& certType, const String& subject, const String& password, String& csr)
 {
-    LOG_DBG() << "Create key: type=" << certType;
+    LOG_DBG() << "Create key" << Log::Field("type", certType) << Log::Field("subject", subject);
 
     return AOS_ERROR_WRAP(mCertHandler->CreateKey(certType, subject, password, csr));
 }
 
 Error ProvisionManager::ApplyCert(const String& certType, const String& pemCert, CertInfo& certInfo)
 {
-    LOG_DBG() << "Apply cert: type=" << certType;
+    LOG_DBG() << "Apply cert" << Log::Field("type", certType);
 
     return AOS_ERROR_WRAP(mCertHandler->ApplyCertificate(certType, pemCert, certInfo));
 }
diff --git a/src/core/sm/imagemanager/imagemanager.cpp b/src/core/sm/imagemanager/imagemanager.cpp
index 76d1d4d73..110e50977 100644
--- a/src/core/sm/imagemanager/imagemanager.cpp
+++ b/src/core/sm/imagemanager/imagemanager.cpp
@@ -259,7 +259,7 @@ Error ImageManager::RemoveUpdateItem(const String& itemID, const String& version
 {
     LockGuard lock {mMutex};
 
-    LOG_INF() << "Remove item" << Log::Field("itemID", itemID) << Log::Field("version", version);
+    LOG_INF() << "Remove update item" << Log::Field("itemID", itemID) << Log::Field("version", version);
 
     StaticArray<UpdateItemData, cMaxNumItemVersions> itemData;
 
@@ -846,8 +846,8 @@ Error ImageManager::StoreUpdateItem(const UpdateItemInfo& itemInfo)
 
 Error ImageManager::RemoveUpdateItem(const UpdateItemData& itemData)
 {
-    LOG_INF() << "Remove update item" << Log::Field("itemID", itemData.mID) << Log::Field("version", itemData.mVersion)
-              << Log::Field("state", itemData.mState);
+    LOG_INF() << "Remove update item from storage" << Log::Field("itemID", itemData.mID)
+              << Log::Field("version", itemData.mVersion) << Log::Field("state", itemData.mState);
 
     if (auto err = mStorage->RemoveUpdateItem(itemData.mID, itemData.mVersion); !err.IsNone()) {
         return AOS_ERROR_WRAP(err);
diff --git a/src/core/sm/launcher/launcher.cpp b/src/core/sm/launcher/launcher.cpp
index 280a176b5..377c52eb5 100644
--- a/src/core/sm/launcher/launcher.cpp
+++ b/src/core/sm/launcher/launcher.cpp
@@ -34,7 +34,7 @@ Error Launcher::Init(const Array<RuntimeItf*>& runtimes, imagemanager::ImageMana
 
 Error Launcher::Start()
 {
-    LOG_INF() << "Start launcher";
+    LOG_DBG() << "Start launcher";
 
     for (auto& it : mRuntimes) {
         if (auto err = it.mFirst->Start(); !err.IsNone()) {
@@ -85,7 +85,7 @@ Error Launcher::Stop()
     {
         UniqueLock lock {mMutex};
 
-        LOG_INF() << "Stop launcher";
+        LOG_DBG() << "Stop launcher";
 
         mCondVar.Wait(lock, [this]() { return !mLaunchInProgress; });
 
@@ -147,7 +147,7 @@ Error Launcher::OnInstancesStatusesReceived(const Array<InstanceStatus>& statuse
         LOG_DBG() << "Instances statuses received" << Log::Field("count", statuses.Size());
 
         for (const auto& status : statuses) {
-            LOG_DBG() << "Instance status received" << Log::Field("ident", static_cast<const InstanceIdent&>(status))
+            LOG_INF() << "Instance status received" << Log::Field("ident", static_cast<const InstanceIdent&>(status))
                       << Log::Field("runtimeID", status.mRuntimeID) << Log::Field("state", status.mState)
                       << Log::Field("error", status.mError);
 
@@ -379,7 +379,13 @@ void Launcher::UpdateInstancesImpl(Array<InstanceIdent>& stopInstances, const Ar
 
     auto sendStatus = DeferRelease(statuses.Get(), [this](const InstanceStatusArray* statuses) {
         if (!mFirstStart) {
-            LOG_DBG() << "Send node instances statuses" << Log::Field("count", statuses->Size());
+            LOG_INF() << "Send node instances statuses" << Log::Field("count", statuses->Size());
+
+            for (const auto& status : *statuses) {
+                LOG_INF() << "Node instance status" << Log::Field("ident", static_cast<const InstanceIdent&>(status))
+                          << Log::Field("runtimeID", status.mRuntimeID) << Log::Field("state", status.mState)
+                          << Log::Field("error", status.mError);
+            }
 
             if (auto err = mSender->SendNodeInstancesStatuses(*statuses); !err.IsNone()) {
                 LOG_ERR() << "Failed to send node instances statuses" << Log::Field(err);
@@ -399,7 +405,7 @@ void Launcher::UpdateInstancesImpl(Array<InstanceIdent>& stopInstances, const Ar
         return;
     }
 
-    if (auto err = ApppendInstancesWithModifiedParams(startInstances, stopInstances); !err.IsNone()) {
+    if (auto err = AppendInstancesWithModifiedParams(startInstances, stopInstances); !err.IsNone()) {
         LOG_ERR() << "Failed to append instances with modified params to stop list" << Log::Field(AOS_ERROR_WRAP(err));
     }
 
@@ -476,7 +482,7 @@ void Launcher::StopInstance(const InstanceIdent& instanceIdent, InstanceStatus&
     }
 
     if (auto errAddTask = mLaunchPool.AddTask([this, runtime, &instanceIdent, status = &status](void*) {
-            LOG_DBG() << "Stop instance" << Log::Field("ident", instanceIdent);
+            LOG_INF() << "Stop instance" << Log::Field("ident", instanceIdent);
 
             if (auto err = runtime->StopInstance(instanceIdent, *status); !err.IsNone()) {
                 LOG_ERR() << "Failed to stop instance" << Log::Field("ident", instanceIdent)
@@ -557,7 +563,9 @@ void Launcher::StartInstances(const Array<InstanceInfo>& startInstances)
 
 void Launcher::StartInstance(RuntimeItf& runtime, InstanceData& instance)
 {
-    LOG_DBG() << "Start instance" << Log::Field("instance", static_cast<const InstanceIdent&>(instance.mInfo));
+    LOG_INF() << "Start instance" << Log::Field("instance", static_cast<const InstanceIdent&>(instance.mInfo))
+              << Log::Field("version", instance.mInfo.mVersion) << Log::Field("runtimeID", instance.mInfo.mRuntimeID)
+              << Log::Field("manifestDigest", instance.mInfo.mManifestDigest);
 
     instance.mStatus.mState = InstanceStateEnum::eActivating;
 
@@ -584,7 +592,7 @@ void Launcher::StartInstance(RuntimeItf& runtime, InstanceData& instance)
     }
 }
 
-Error Launcher::ApppendInstancesWithModifiedParams(
+Error Launcher::AppendInstancesWithModifiedParams(
     const Array<InstanceInfo>& startInstances, Array<InstanceIdent>& stopInstances)
 {
     for (const auto& startInstance : startInstances) {
diff --git a/src/core/sm/launcher/launcher.hpp b/src/core/sm/launcher/launcher.hpp
index d8bab165d..1ae3bfc31 100644
--- a/src/core/sm/launcher/launcher.hpp
+++ b/src/core/sm/launcher/launcher.hpp
@@ -167,7 +167,7 @@ class Launcher : public LauncherItf,
     void  StopAllInstances();
     void  StartInstances(const Array<InstanceInfo>& startInstances);
     void  StartInstance(RuntimeItf& runtime, InstanceData& instance);
-    Error ApppendInstancesWithModifiedParams(
+    Error AppendInstancesWithModifiedParams(
         const Array<InstanceInfo>& startInstances, Array<InstanceIdent>& stopInstances);
     void  PopulateInstancesStatuses(Array<InstanceStatus>& statuses) const;
     void  ClearCachedInstances();