diff --git a/frameworks/native/backup_ext/include/ext_extension.h b/frameworks/native/backup_ext/include/ext_extension.h
index b8b18735c4b701ec0492f59d704ee1af36dff17f..6f7f66cdac014eed6426210ffffb65cd1f5e28b8 100644
--- a/frameworks/native/backup_ext/include/ext_extension.h
+++ b/frameworks/native/backup_ext/include/ext_extension.h
@@ -259,6 +259,8 @@ private:
     void SyncCallJsOnProcessTask(wptr<BackupExtExtension> obj, BackupRestoreScenario scenario);
     void StartOnProcessTimeOutTimer(wptr<BackupExtExtension> obj, BackupRestoreScenario scenario);
     void CloseOnProcessTimeOutTimer();
+    void UpdateOnStartTime();
+    int32_t GetOnStartTimeCost();
 
 private:
     std::shared_mutex lock_;
@@ -286,6 +288,8 @@ private:
     std::condition_variable execOnProcessCon_;
     std::mutex onProcessLock_;
     std::atomic<bool> onProcessTimeout_ {false};
+    std::chrono::time_point<std::chrono::system_clock> g_onStart;
+    std::mutex onStartTimeLock_;
 };
 } // namespace OHOS::FileManagement::Backup
 
diff --git a/frameworks/native/backup_ext/src/ext_extension.cpp b/frameworks/native/backup_ext/src/ext_extension.cpp
index 6c7589d3b7b68b600c2615c3119cf9b289681ead..c1531e32274fda167af819306314cff036b2f5c8 100644
--- a/frameworks/native/backup_ext/src/ext_extension.cpp
+++ b/frameworks/native/backup_ext/src/ext_extension.cpp
@@ -47,6 +47,7 @@
 #include "b_json/b_json_cached_entity.h"
 #include "b_jsonutil/b_jsonutil.h"
 #include "b_ohos/startup/backup_para.h"
+#include "b_radar/b_radar.h"
 #include "b_tarball/b_tarball_factory.h"
 #include "filemgmt_libhilog.h"
 #include "hitrace_meter.h"
@@ -128,10 +129,18 @@ void BackupExtExtension::VerifyCaller()
     uint32_t tokenCaller = IPCSkeleton::GetCallingTokenID();
     int tokenType = Security::AccessToken::AccessTokenKit::GetTokenType(tokenCaller);
     if (tokenType != Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE) {
+        AppRadar::Info info(bundleName_, "", "{\"reason\":\"Calling tokenType error\"}");
+        AppRadar::GetInstance().RecordDefaultFuncRes(
+            info, "BackupExtExtension::VerifyCaller", AppRadar::GetInstance().GetUserId(),
+            BizStageBackup::BIZ_STAGE_PERMISSION_CHECK_FAIL, BError(BError::Codes::OK).GetCode());
         throw BError(BError::Codes::EXT_BROKEN_IPC,
                      string("Calling tokenType is error, token type is ").append(to_string(tokenType)));
     }
     if (IPCSkeleton::GetCallingUid() != BConstants::BACKUP_UID) {
+        AppRadar::Info info(bundleName_, "", "{\"reason\":\"Calling uid invalid\"}");
+        AppRadar::GetInstance().RecordDefaultFuncRes(
+            info, "BackupExtExtension::VerifyCaller", AppRadar::GetInstance().GetUserId(),
+            BizStageBackup::BIZ_STAGE_PERMISSION_CHECK_FAIL, BError(BError::Codes::OK).GetCode());
         throw BError(BError::Codes::EXT_BROKEN_IPC,
                      string("Calling uid is invalid, calling uid is ").append(to_string(IPCSkeleton::GetCallingUid())));
     }
@@ -828,7 +837,13 @@ void BackupExtExtension::AsyncTaskBackup(const string config)
             HILOGI("Do backup, start fwk timer end.");
             BJsonCachedEntity<BJsonEntityExtensionConfig> cachedEntity(config);
             auto cache = cachedEntity.Structuralize();
+            auto start = std::chrono::system_clock::now();
             auto ret = ptr->DoBackup(cache);
+            auto end = std::chrono::system_clock::now();
+            auto cost = to_string(std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count());
+            AppRadar::Info info(ptr->bundleName_, "", string("{\"spend_time\":").append(cost).append(string("ms\"}")));
+            AppRadar::GetInstance().RecordBackupFuncRes(info, "BackupExtExtension::AsyncTaskBackup",
+                AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_DO_BACKUP, static_cast<int32_t>(ret));
             // REM: 处理返回结果 ret
             ptr->AppDone(ret);
             HILOGI("backup app done %{public}d", ret);
@@ -1152,6 +1167,16 @@ void BackupExtExtension::HandleSpecialVersionRestore()
     }
 }
 
+void RecordDoRestoreRes(const std::string &bundleName, const std::string &func, int32_t ms)
+{
+    std::stringstream ss;
+    ss << "\"spend_time\": \"" << ms << "ms\"";
+    int32_t err = static_cast<int32_t>(BError::Codes::OK);
+    AppRadar::Info info (bundleName, "", ss.str());
+    AppRadar::GetInstance().RecordRestoreFuncRes(info, func, AppRadar::GetInstance().GetUserId(),
+                                                 BizStageRestore::BIZ_STAGE_DO_RESTORE, err);
+}
+
 void BackupExtExtension::AsyncTaskRestore(std::set<std::string> fileSet,
     const std::vector<ExtManageInfo> extManageInfo)
 {
@@ -1166,6 +1191,7 @@ void BackupExtExtension::AsyncTaskRestore(std::set<std::string> fileSet,
                 return;
             }
             // 解压
+            auto startTime = std::chrono::system_clock::now();
             for (auto item : fileSet) { // 处理要解压的tar文件
                 off_t tarFileSize = 0;
                 if (ExtractFileExt(item) == "tar" && !IsUserTar(item, extManageInfo, tarFileSize)) {
@@ -1178,6 +1204,10 @@ void BackupExtExtension::AsyncTaskRestore(std::set<std::string> fileSet,
                 ptr->extension_->UseFullBackupOnly() && !ptr->extension_->SpecialVersionForCloneAndCloud();
             ptr->RestoreBigFiles(appendTargetPath);
             ptr->DeleteBackupTars();
+            auto endTime = std::chrono::system_clock::now();
+            auto spendTime = std::chrono::duration_cast<std::chrono::milliseconds>(endTime-startTime).count();
+            RecordDoRestoreRes(ptr->bundleName_, "BackupExtExtension::AsyncTaskRestore",
+                static_cast<int32_t>(spendTime));
             if (ret == ERR_OK) {
                 ptr->AsyncTaskRestoreForUpgrade();
             } else {
@@ -1216,6 +1246,7 @@ void BackupExtExtension::AsyncTaskIncrementalRestore()
             if (ptr != nullptr && ptr->isDebug_) {
                 ptr->CheckTmpDirFileInfos();
             }
+            auto startTime = std::chrono::system_clock::now();
             // 解压
             int ret = ptr->DoIncrementalRestore();
             // 恢复用户tar包以及大文件
@@ -1229,6 +1260,10 @@ void BackupExtExtension::AsyncTaskIncrementalRestore()
             if (ptr != nullptr && ptr->isDebug_) {
                 ptr->CheckRestoreFileInfos();
             }
+            auto endTime = std::chrono::system_clock::now();
+            auto spendTime = std::chrono::duration_cast<std::chrono::milliseconds>(endTime-startTime).count();
+            RecordDoRestoreRes(ptr->bundleName_, "BackupExtExtension::AsyncTaskIncrementalRestore",
+                static_cast<int32_t>(spendTime));
             if (ret == ERR_OK) {
                 HILOGI("after extra, do incremental restore.");
                 ptr->AsyncTaskIncrementalRestoreForUpgrade();
@@ -1319,6 +1354,7 @@ void BackupExtExtension::AsyncTaskRestoreForUpgrade()
             ptr->StartOnProcessTaskThread(obj, BackupRestoreScenario::FULL_RESTORE);
             auto callBackup = ptr->OnRestoreCallback(obj);
             auto callBackupEx = ptr->OnRestoreExCallback(obj);
+            ptr->UpdateOnStartTime();
             ErrCode err = ptr->extension_->OnRestore(callBackup, callBackupEx);
             if (err != ERR_OK) {
                 ptr->AppDone(BError::GetCodeByErrno(err));
@@ -1369,6 +1405,7 @@ void BackupExtExtension::AsyncTaskIncrementalRestoreForUpgrade()
             ptr->StartOnProcessTaskThread(obj, BackupRestoreScenario::INCREMENTAL_RESTORE);
             auto callBackup = ptr->IncreOnRestoreCallback(obj);
             auto callBackupEx = ptr->IncreOnRestoreExCallback(obj);
+            ptr->UpdateOnStartTime();
             ErrCode err = ptr->extension_->OnRestore(callBackup, callBackupEx);
             if (err != ERR_OK) {
                 HILOGE("OnRestore done, err = %{pubilc}d", err);
@@ -1498,6 +1535,12 @@ void BackupExtExtension::StartFwkTimer(bool &isFwkStart)
     }
 }
 
+void BackupExtExtension::UpdateOnStartTime()
+{
+    std::lock_guard<std::mutex> lock(onStartTimeLock_);
+    g_onStart = std::chrono::system_clock::now();
+}
+
 void BackupExtExtension::AsyncTaskOnBackup()
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
@@ -1509,6 +1552,7 @@ void BackupExtExtension::AsyncTaskOnBackup()
             ptr->StartOnProcessTaskThread(obj, BackupRestoreScenario::FULL_BACKUP);
             auto callBackup = ptr->OnBackupCallback(obj);
             auto callBackupEx = ptr->OnBackupExCallback(obj);
+            ptr->UpdateOnStartTime();
             ErrCode err = ptr->extension_->OnBackup(callBackup, callBackupEx);
             if (err != ERR_OK) {
                 HILOGE("OnBackup done, err = %{pubilc}d", err);
@@ -1894,6 +1938,7 @@ void BackupExtExtension::AsyncTaskOnIncrementalBackup()
             ptr->StartOnProcessTaskThread(obj, BackupRestoreScenario::INCREMENTAL_BACKUP);
             auto callBackup = ptr->IncOnBackupCallback(obj);
             auto callBackupEx = ptr->IncOnBackupExCallback(obj);
+            ptr->UpdateOnStartTime();
             ErrCode err = ptr->extension_->OnBackup(callBackup, callBackupEx);
             if (err != ERR_OK) {
                 HILOGE("OnBackup done, err = %{pubilc}d", err);
diff --git a/frameworks/native/backup_ext/src/sub_ext_extension.cpp b/frameworks/native/backup_ext/src/sub_ext_extension.cpp
index 673958e3f234863d6cff726356332383df464155..062b667c2f08cedcc5e5b33c60ee0c3218161afa 100644
--- a/frameworks/native/backup_ext/src/sub_ext_extension.cpp
+++ b/frameworks/native/backup_ext/src/sub_ext_extension.cpp
@@ -47,6 +47,7 @@
 #include "b_json/b_json_cached_entity.h"
 #include "b_jsonutil/b_jsonutil.h"
 #include "b_ohos/startup/backup_para.h"
+#include "b_radar/b_radar.h"
 #include "b_tarball/b_tarball_factory.h"
 #include "filemgmt_libhilog.h"
 #include "hitrace_meter.h"
@@ -140,6 +141,13 @@ void BackupExtExtension::CheckTmpDirFileInfos(bool isSpecialVersion)
         errFiles.size());
     if (!errFiles.empty()) {
         HILOGE("(Debug) The received file and idx is not same");
+        std::stringstream ss;
+        ss << "\"total_file\": \"" << idxFileInfos.size() << "\", \"restore_file\": \""
+        << idxFileInfos.size() - errFiles.size() << "\"" << "\"info\": \"different received file and idx\"";
+        AppRadar::Info info (bundleName_, "", ss.str());
+        AppRadar::GetInstance().RecordRestoreFuncRes(info, "BackupExtExtension::CheckTmpDirFileInfos",
+            AppRadar::GetInstance().GetUserId(), BizStageRestore::BIZ_STAGE_CHECK_DATA_FAIL,
+            static_cast<int32_t>(BError::BackupErrorCode::E_UKERR));
     } else {
         HILOGI("(Debug) The received file and idx is same");
     }
@@ -168,6 +176,13 @@ tuple<bool, vector<string>> BackupExtExtension::CheckRestoreFileInfos()
     HILOGE("(Debug) End file check result Total file: %{public}zu, err file: %{public}zu", endFileInfos_.size(),
         errFileInfos_.size());
     if (errFiles.size()) {
+        std::stringstream ss;
+        ss << "\"total_file\": \"" << endFileInfos_.size() << "\", \"restore_file\": \""
+        << endFileInfos_.size() - errFileInfos_.size() << "\"";
+        AppRadar::Info info (bundleName_, "", ss.str());
+        AppRadar::GetInstance().RecordRestoreFuncRes(info, "BackupExtExtension::CheckRestoreFileInfos",
+            AppRadar::GetInstance().GetUserId(), BizStageRestore::BIZ_STAGE_CHECK_DATA_FAIL,
+            static_cast<int32_t>(BError::BackupErrorCode::E_UKERR));
         return { false, errFiles };
     }
     return { true, errFiles };
@@ -248,6 +263,14 @@ std::function<void(ErrCode, std::string)> BackupExtExtension::OnRestoreCallback(
             return;
         }
         HILOGI("Current bundle will execute app done");
+        if (errCode == ERR_OK) {
+            auto spendTime = extensionPtr->GetOnStartTimeCost();
+            std::stringstream ss;
+            ss << "\"spend_time\": \"" << spendTime << "ms\"";
+            AppRadar::Info info (extensionPtr->bundleName_, ss.str(), "");
+            AppRadar::GetInstance().RecordRestoreFuncRes(info, "BackupExtExtension::OnRestoreCallback",
+                AppRadar::GetInstance().GetUserId(), BizStageRestore::BIZ_STAGE_ON_RESTORE, ERR_OK);
+        }
         extensionPtr->FinishOnProcessTask();
         if (errMsg.empty()) {
             extensionPtr->AppDone(errCode);
@@ -273,6 +296,14 @@ std::function<void(ErrCode, std::string)> BackupExtExtension::OnRestoreExCallbac
             HILOGE("Extension handle have been released");
             return;
         }
+        if (errCode == ERR_OK && !restoreRetInfo.empty()) {
+            auto spendTime = extensionPtr->GetOnStartTimeCost();
+            std::stringstream ss;
+            ss << "\"spend_time\": \"" << spendTime << "ms\"";
+            AppRadar::Info info (extensionPtr->bundleName_, ss.str(), "");
+            AppRadar::GetInstance().RecordRestoreFuncRes(info, "BackupExtExtension::OnRestoreExCallback",
+                AppRadar::GetInstance().GetUserId(), BizStageRestore::BIZ_STAGE_ON_RESTORE, ERR_OK);
+        }
         extensionPtr->FinishOnProcessTask();
         extensionPtr->extension_->InvokeAppExtMethod(errCode, restoreRetInfo);
         if (errCode == ERR_OK) {
@@ -323,6 +354,15 @@ std::function<void(ErrCode, std::string)> BackupExtExtension::IncreOnRestoreExCa
             HILOGE("Extension handle have been released");
             return;
         }
+        if (errCode == ERR_OK && !restoreRetInfo.empty()) {
+            auto spendTime = extensionPtr->GetOnStartTimeCost();
+            std::stringstream ss;
+            ss << "\"spend_time\": \"" << spendTime << "ms\"";
+            AppRadar::Info info (extensionPtr->bundleName_, "", ss.str());
+            AppRadar::GetInstance().RecordRestoreFuncRes(info, "BackupExtExtension::IncreOnRestoreExCallback",
+                AppRadar::GetInstance().GetUserId(),
+                BizStageRestore::BIZ_STAGE_ON_RESTORE, ERR_OK);
+        }
         extensionPtr->FinishOnProcessTask();
         extensionPtr->extension_->InvokeAppExtMethod(errCode, restoreRetInfo);
         if (errCode == ERR_OK) {
@@ -352,6 +392,14 @@ std::function<void(ErrCode, std::string)> BackupExtExtension::IncreOnRestoreCall
             return;
         }
         HILOGI("Current bundle will execute app done");
+        if (errCode == ERR_OK) {
+            auto spendTime = extensionPtr->GetOnStartTimeCost();
+            std::stringstream ss;
+            ss << "\"spend_time\": \"" << spendTime << "ms\"";
+            AppRadar::Info info (extensionPtr->bundleName_, ss.str(), "");
+            AppRadar::GetInstance().RecordRestoreFuncRes(info, "BackupExtExtension::IncreOnRestoreCallback",
+                AppRadar::GetInstance().GetUserId(), BizStageRestore::BIZ_STAGE_ON_RESTORE, ERR_OK);
+        }
         extensionPtr->FinishOnProcessTask();
         if (errMsg.empty()) {
             extensionPtr->AppIncrementalDone(errCode);
@@ -364,6 +412,14 @@ std::function<void(ErrCode, std::string)> BackupExtExtension::IncreOnRestoreCall
     };
 }
 
+int32_t BackupExtExtension::GetOnStartTimeCost()
+{
+    auto onBackupRestoreEnd = std::chrono::system_clock::now();
+    std::lock_guard<std::mutex> lock(onStartTimeLock_);
+    auto spendTime = std::chrono::duration_cast<std::chrono::milliseconds>(onBackupRestoreEnd - g_onStart).count();
+    return spendTime;
+}
+
 std::function<void(ErrCode, const std::string)> BackupExtExtension::OnBackupCallback(wptr<BackupExtExtension> obj)
 {
     HILOGI("Begin get HandleFullBackupCallbackEx");
@@ -378,6 +434,14 @@ std::function<void(ErrCode, const std::string)> BackupExtExtension::OnBackupCall
             HILOGE("Extension handle have been released");
             return;
         }
+        if (errCode == ERR_OK) {
+            auto spendTime = extensionPtr->GetOnStartTimeCost();
+            AppRadar::Info info(extensionPtr->bundleName_, "", string("{\"spend_time\":\" ").
+                append(to_string(spendTime)).append(string("ms\"}")));
+            AppRadar::GetInstance().RecordBackupFuncRes(info, "BackupExtExtension::OnBackupCallback",
+                AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_ON_BACKUP,
+                static_cast<int32_t>(ERR_OK));
+        }
         extensionPtr->FinishOnProcessTask();
         extensionPtr->AsyncTaskBackup(extensionPtr->extension_->GetUsrConfig());
     };
@@ -397,6 +461,14 @@ std::function<void(ErrCode, const std::string)> BackupExtExtension::OnBackupExCa
             HILOGE("Extension handle have been released");
             return;
         }
+        if (errCode == ERR_OK && !backupExRetInfo.empty()) {
+            auto spendTime = extensionPtr->GetOnStartTimeCost();
+            AppRadar::Info info(extensionPtr->bundleName_, "", string("{\"spend_time\":\" ").
+                append(to_string(spendTime)).append(string("ms\"}")));
+            AppRadar::GetInstance().RecordBackupFuncRes(info, "BackupExtExtension::OnBackupExCallback",
+                AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_ON_BACKUP,
+                static_cast<int32_t>(ERR_OK));
+        }
         extensionPtr->extension_->InvokeAppExtMethod(errCode, backupExRetInfo);
         if (backupExRetInfo.size()) {
             HILOGI("Will notify backup result report");
@@ -422,6 +494,14 @@ std::function<void(ErrCode, const std::string)> BackupExtExtension::IncOnBackupC
             return;
         }
         HILOGI("Start GetAppLocalListAndDoIncrementalBackup");
+        if (errCode == ERR_OK) {
+            auto spendTime = extPtr->GetOnStartTimeCost();
+            AppRadar::Info info(extPtr->bundleName_, "", string("{\"spend_time\":\" ").
+                append(to_string(spendTime)).append(string("ms\"}")));
+            AppRadar::GetInstance().RecordBackupFuncRes(info, "BackupExtExtension::IncOnBackupCallback",
+                AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_ON_BACKUP,
+                static_cast<int32_t>(ERR_OK));
+        }
         extPtr->FinishOnProcessTask();
         proxy->GetAppLocalListAndDoIncrementalBackup();
     };
@@ -444,6 +524,14 @@ std::function<void(ErrCode, const std::string)> BackupExtExtension::IncOnBackupE
             HILOGE("Extension handle have been released");
             return;
         }
+        if (errCode == ERR_OK && !backupExRetInfo.empty()) {
+            auto spendTime = extensionPtr->GetOnStartTimeCost();
+            AppRadar::Info info(extensionPtr->bundleName_, "", string("{\"spend_time\":\" ").
+                append(to_string(spendTime)).append(string("ms\"}")));
+            AppRadar::GetInstance().RecordBackupFuncRes(info, "BackupExtExtension::IncOnBackupExCallback",
+                AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_ON_BACKUP,
+                static_cast<int32_t>(ERR_OK));
+        }
         extensionPtr->extension_->InvokeAppExtMethod(errCode, backupExRetInfo);
         if (backupExRetInfo.size()) {
             HILOGI("Start GetAppLocalListAndDoIncrementalBackup");
diff --git a/frameworks/native/backup_kit_inner/src/b_incremental_backup_session.cpp b/frameworks/native/backup_kit_inner/src/b_incremental_backup_session.cpp
index bc4a6e687ed79e2eeb63ae8a5b2d59bd4ecb3ea7..cfaaf5ef5b51eba86f25e3e869a1a578992bcdf8 100644
--- a/frameworks/native/backup_kit_inner/src/b_incremental_backup_session.cpp
+++ b/frameworks/native/backup_kit_inner/src/b_incremental_backup_session.cpp
@@ -16,6 +16,7 @@
 #include "b_incremental_backup_session.h"
 
 #include "b_error/b_error.h"
+#include "b_radar/b_radar.h"
 #include "filemgmt_libhilog.h"
 #include "service_proxy.h"
 #include "service_reverse.h"
@@ -55,6 +56,9 @@ unique_ptr<BIncrementalBackupSession> BIncrementalBackupSession::Init(Callbacks
         int32_t res = proxy->InitIncrementalBackupSession(sptr(new ServiceReverse(callbacks)));
         if (res != 0) {
             HILOGE("Failed to Backup because of %{public}d", res);
+            AppRadar::Info info("", "", "");
+            AppRadar::GetInstance().RecordBackupFuncRes(info, "BIncrementalBackupSession::Init",
+                AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_CREATE_BACKUP_SESSION_FAIL, res);
             return nullptr;
         }
 
@@ -93,7 +97,17 @@ ErrCode BIncrementalBackupSession::AppendBundles(vector<BIncrementalData> bundle
         return BError(BError::Codes::SDK_BROKEN_IPC, "Failed to get backup service").GetCode();
     }
 
-    return proxy->AppendBundlesIncrementalBackupSession(bundlesToBackup);
+    int32_t res = proxy->AppendBundlesIncrementalBackupSession(bundlesToBackup);
+    if (res != 0) {
+        std::string ss;
+        for (const auto &bundle : bundlesToBackup) {
+            ss += bundle.bundleName + ", ";
+        }
+        AppRadar::Info info(ss.c_str(), "", "");
+        AppRadar::GetInstance().RecordBackupFuncRes(info, "BIncrementalBackupSession::AppendBundles",
+            AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_APPEND_BUNDLES_FAIL, res);
+    }
+    return res;
 }
 
 ErrCode BIncrementalBackupSession::AppendBundles(vector<BIncrementalData> bundlesToBackup,
@@ -104,7 +118,17 @@ ErrCode BIncrementalBackupSession::AppendBundles(vector<BIncrementalData> bundle
         return BError(BError::Codes::SDK_BROKEN_IPC, "Failed to get backup service").GetCode();
     }
 
-    return proxy->AppendBundlesIncrementalBackupSession(bundlesToBackup, infos);
+    int32_t res = proxy->AppendBundlesIncrementalBackupSession(bundlesToBackup, infos);
+    if (res != 0) {
+        std::string ss;
+        for (const auto &bundle : bundlesToBackup) {
+            ss += bundle.bundleName + ", ";
+        }
+        AppRadar::Info info(ss.c_str(), "", "AppendBundles with infos");
+        AppRadar::GetInstance().RecordBackupFuncRes(info, "BIncrementalBackupSession::AppendBundles",
+            AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_APPEND_BUNDLES_FAIL, res);
+    }
+    return res;
 }
 
 ErrCode BIncrementalBackupSession::Release()
diff --git a/frameworks/native/backup_kit_inner/src/b_incremental_restore_session.cpp b/frameworks/native/backup_kit_inner/src/b_incremental_restore_session.cpp
index 1b5b24c6a317fcc5adb90b87eab9be84b7e04a95..ed51e8cb9d9f36ff35ab1fa049558da2ae8f5bf2 100644
--- a/frameworks/native/backup_kit_inner/src/b_incremental_restore_session.cpp
+++ b/frameworks/native/backup_kit_inner/src/b_incremental_restore_session.cpp
@@ -16,6 +16,7 @@
 #include "b_incremental_restore_session.h"
 
 #include "b_error/b_error.h"
+#include "b_radar/b_radar.h"
 #include "filemgmt_libhilog.h"
 #include "service_proxy.h"
 #include "service_reverse.h"
@@ -54,6 +55,10 @@ unique_ptr<BIncrementalRestoreSession> BIncrementalRestoreSession::Init(Callback
         int32_t res = proxy->InitRestoreSession(sptr(new ServiceReverse(callbacks)));
         if (res != 0) {
             HILOGE("Failed to Restore because of %{public}d", res);
+            AppRadar::Info info ("", "", "create restore session failed");
+            AppRadar::GetInstance().RecordRestoreFuncRes(info, "BIncrementalRestoreSession::Init",
+                                                         AppRadar::GetInstance().GetUserId(),
+                                                         BizStageRestore::BIZ_STAGE_CREATE_RESTORE_SESSION_FAIL, res);
             return nullptr;
         }
 
diff --git a/frameworks/native/backup_kit_inner/src/b_incremental_session_restore_async.cpp b/frameworks/native/backup_kit_inner/src/b_incremental_session_restore_async.cpp
index 67ed9f49b7e6277c6fa63cb306565c0d73b5f769..75c7e3cbcd54dada7b498c614fd72659b24428a6 100644
--- a/frameworks/native/backup_kit_inner/src/b_incremental_session_restore_async.cpp
+++ b/frameworks/native/backup_kit_inner/src/b_incremental_session_restore_async.cpp
@@ -16,6 +16,7 @@
 #include "b_incremental_session_restore_async.h"
 
 #include "b_error/b_error.h"
+#include "b_radar/b_radar.h"
 #include "b_resources/b_constants.h"
 #include "filemgmt_libhilog.h"
 #include "service_proxy.h"
@@ -62,6 +63,10 @@ shared_ptr<BIncrementalSessionRestoreAsync> BIncrementalSessionRestoreAsync::Ini
         int32_t res = proxy->InitRestoreSession(sptr(new ServiceReverse(callbacksTmp)));
         if (res != 0) {
             HILOGE("Failed to Restore because of %{public}d", res);
+            AppRadar::Info info ("", "", "create restore session failed");
+            AppRadar::GetInstance().RecordRestoreFuncRes(info, "BIncrementalSessionRestoreAsync::Init",
+                                                         AppRadar::GetInstance().GetUserId(),
+                                                         BizStageRestore::BIZ_STAGE_CREATE_RESTORE_SESSION_FAIL, res);
             return nullptr;
         }
 
diff --git a/frameworks/native/backup_kit_inner/src/b_session_backup.cpp b/frameworks/native/backup_kit_inner/src/b_session_backup.cpp
index 495e9d545c79ad57f64205e9d4bf90c8ce062350..f20285515766b6ea0c189b588ec5dd5d75b19864 100644
--- a/frameworks/native/backup_kit_inner/src/b_session_backup.cpp
+++ b/frameworks/native/backup_kit_inner/src/b_session_backup.cpp
@@ -16,6 +16,7 @@
 #include "b_session_backup.h"
 
 #include "b_error/b_error.h"
+#include "b_radar/b_radar.h"
 #include "filemgmt_libhilog.h"
 #include "service_proxy.h"
 #include "service_reverse.h"
@@ -55,6 +56,9 @@ unique_ptr<BSessionBackup> BSessionBackup::Init(Callbacks callbacks)
         int32_t res = proxy->InitBackupSession(sptr(new ServiceReverse(callbacks)));
         if (res != 0) {
             HILOGE("Failed to Backup because of %{public}d", res);
+            AppRadar::Info info("", "", "");
+            AppRadar::GetInstance().RecordBackupFuncRes(info, "BSessionBackup::Init",
+                AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_CREATE_BACKUP_SESSION_FAIL, res);
             return nullptr;
         }
 
@@ -103,7 +107,17 @@ ErrCode BSessionBackup::AppendBundles(vector<BundleName> bundlesToBackup)
         return BError(BError::Codes::SDK_BROKEN_IPC, "Failed to get backup service").GetCode();
     }
 
-    return proxy->AppendBundlesBackupSession(bundlesToBackup);
+    int32_t res = proxy->AppendBundlesBackupSession(bundlesToBackup);
+    if (res != 0) {
+        std::string ss;
+        for (const auto &bundleName:bundlesToBackup) {
+            ss += bundleName + ", ";
+        }
+        AppRadar::Info info(ss.c_str(), "", "");
+        AppRadar::GetInstance().RecordBackupFuncRes(info, "BSessionBackup::AppendBundles",
+            AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_APPEND_BUNDLES_FAIL, res);
+    }
+    return res;
 }
 
 ErrCode BSessionBackup::AppendBundles(vector<BundleName> bundlesToBackup, vector<std::string> detailInfos)
@@ -113,7 +127,17 @@ ErrCode BSessionBackup::AppendBundles(vector<BundleName> bundlesToBackup, vector
         return BError(BError::Codes::SDK_BROKEN_IPC, "Failed to get backup service").GetCode();
     }
 
-    return proxy->AppendBundlesDetailsBackupSession(bundlesToBackup, detailInfos);
+    int32_t res = proxy->AppendBundlesDetailsBackupSession(bundlesToBackup, detailInfos);
+    if (res != 0) {
+        std::string ss;
+        for (const auto &bundleName:bundlesToBackup) {
+            ss += bundleName + ", ";
+        }
+        AppRadar::Info info(ss.c_str(), "", "");
+        AppRadar::GetInstance().RecordBackupFuncRes(info, "BSessionBackup::AppendBundles",
+            AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_APPEND_BUNDLES_FAIL, res);
+    }
+    return res;
 }
 
 ErrCode BSessionBackup::Finish()
diff --git a/frameworks/native/backup_kit_inner/src/b_session_restore.cpp b/frameworks/native/backup_kit_inner/src/b_session_restore.cpp
index c284aa26fc911346bd980ac88e2786c08aa7bb27..0c37d260361e7e01f255690eb351f1004cc42362 100644
--- a/frameworks/native/backup_kit_inner/src/b_session_restore.cpp
+++ b/frameworks/native/backup_kit_inner/src/b_session_restore.cpp
@@ -16,6 +16,7 @@
 #include "b_session_restore.h"
 
 #include "b_error/b_error.h"
+#include "b_radar/b_radar.h"
 #include "filemgmt_libhilog.h"
 #include "service_proxy.h"
 #include "service_reverse.h"
@@ -54,6 +55,10 @@ unique_ptr<BSessionRestore> BSessionRestore::Init(Callbacks callbacks)
         int32_t res = proxy->InitRestoreSession(new ServiceReverse(callbacks));
         if (res != 0) {
             HILOGE("Failed to Restore because of %{public}d", res);
+            AppRadar::Info info ("", "", "create restore session failed");
+            AppRadar::GetInstance().RecordRestoreFuncRes(info, "BSessionRestore::Init",
+                                                         AppRadar::GetInstance().GetUserId(),
+                                                         BizStageRestore::BIZ_STAGE_CREATE_RESTORE_SESSION_FAIL, res);
             return nullptr;
         }
 
diff --git a/frameworks/native/backup_kit_inner/src/b_session_restore_async.cpp b/frameworks/native/backup_kit_inner/src/b_session_restore_async.cpp
index 99ffa77eb9d2bee6835d504acba785ea2f275b20..b3cea05e1fd1a036aa43eb8d86d6e5ec39c08ba7 100644
--- a/frameworks/native/backup_kit_inner/src/b_session_restore_async.cpp
+++ b/frameworks/native/backup_kit_inner/src/b_session_restore_async.cpp
@@ -16,6 +16,7 @@
 #include "b_session_restore_async.h"
 
 #include "b_error/b_error.h"
+#include "b_radar/b_radar.h"
 #include "b_resources/b_constants.h"
 #include "b_session_restore.h"
 #include "filemgmt_libhilog.h"
@@ -63,6 +64,10 @@ shared_ptr<BSessionRestoreAsync> BSessionRestoreAsync::Init(Callbacks callbacks)
         int32_t res = proxy->InitRestoreSession(sptr(new ServiceReverse(callbacksTmp)));
         if (res != 0) {
             HILOGE("Failed to Restore because of %{public}d", res);
+            AppRadar::Info info ("", "", "create restore session failed");
+            AppRadar::GetInstance().RecordRestoreFuncRes(info, "BSessionRestoreAsync::Init",
+                                                         AppRadar::GetInstance().GetUserId(),
+                                                         BizStageRestore::BIZ_STAGE_CREATE_RESTORE_SESSION_FAIL, res);
             return nullptr;
         }
 
diff --git a/frameworks/native/backup_kit_inner/src/service_proxy.cpp b/frameworks/native/backup_kit_inner/src/service_proxy.cpp
index 9de0a9be73f1be143016f717887d44ec7dbe2dbc..8d7be32ab384065ef324bfdb935ec3a8ebd806ed 100644
--- a/frameworks/native/backup_kit_inner/src/service_proxy.cpp
+++ b/frameworks/native/backup_kit_inner/src/service_proxy.cpp
@@ -13,15 +13,16 @@
  * limitations under the License.
  */
 
-#include "service_proxy.h"
-
-#include "iservice_registry.h"
-#include "system_ability_definition.h"
+#include <sstream>
 
 #include "b_error/b_error.h"
 #include "b_error/b_excep_utils.h"
+#include "b_radar/b_radar.h"
 #include "b_resources/b_constants.h"
 #include "filemgmt_libhilog.h"
+#include "iservice_registry.h"
+#include "service_proxy.h"
+#include "system_ability_definition.h"
 #include "svc_death_recipient.h"
 #include "hitrace_meter.h"
 
@@ -119,6 +120,9 @@ UniqueFd ServiceProxy::GetLocalCapabilities()
         static_cast<uint32_t>(IServiceInterfaceCode::SERVICE_CMD_GET_LOCAL_CAPABILITIES), data, reply, option);
     if (ret != NO_ERROR) {
         HILOGE("Received error %{public}d when doing IPC", ret);
+        AppRadar::Info resInfo("", "", "");
+        AppRadar::GetInstance().RecordDefaultFuncRes(resInfo, "ServiceProxy::GetLocalCapabilities",
+            AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_GET_LOCAL_CAPABILITIES_FAIL, ret);
         return UniqueFd(-ret);
     }
     UniqueFd fd(reply.ReadFileDescriptor());
@@ -297,6 +301,13 @@ ErrCode ServiceProxy::AppendBundlesRestoreSession(UniqueFd fd, const vector<Bund
         option);
     if (ret != NO_ERROR) {
         string str = "Failed to send out the request because of " + to_string(ret);
+        std::string ss;
+        for (const auto &bundleName : bundleNames) {
+            ss += bundleName + ", ";
+        }
+        AppRadar::Info info(ss.c_str(), "", str);
+        AppRadar::GetInstance().RecordRestoreFuncRes(info, "ServiceProxy::AppendBundlesRestoreSession", userId,
+            BizStageRestore::BIZ_STAGE_APPEND_BUNDLES_FAIL, ret);
         return BError(BError::Codes::SDK_INVAL_ARG, str.data()).GetCode();
     }
     return reply.ReadInt32();
@@ -334,6 +345,13 @@ ErrCode ServiceProxy::AppendBundlesRestoreSession(UniqueFd fd,
         static_cast<uint32_t>(IServiceInterfaceCode::SERVICE_CMD_APPEND_BUNDLES_RESTORE_SESSION), data, reply, option);
     if (ret != NO_ERROR) {
         string str = "Failed to send out the request because of " + to_string(ret);
+        std::string ss;
+        for (const auto &bundleName : bundleNames) {
+            ss += bundleName + ", ";
+        }
+        AppRadar::Info info(ss.c_str(), "", str);
+        AppRadar::GetInstance().RecordRestoreFuncRes(info, "ServiceProxy::AppendBundlesRestoreSession", userId,
+            BizStageRestore::BIZ_STAGE_APPEND_BUNDLES_FAIL, ret);
         return BError(BError::Codes::SDK_INVAL_ARG, str.data()).GetCode();
     }
     return reply.ReadInt32();
@@ -452,6 +470,10 @@ sptr<IService> ServiceProxy::GetInstance()
                                             [loadCallback]() { return loadCallback->isLoadSuccess_.load(); });
     if (!waitStatus) {
         HILOGE("Load backup sa timeout");
+        AppRadar::Info info("", "", "{\"reason\":\"Load backup sa timeout\"}");
+        AppRadar::GetInstance().RecordBackupFuncRes(info, "ServiceProxy::GetInstance",
+            AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_BOOT_BACKUP_SA_FAIL,
+            static_cast<int32_t>(BError::Codes::SA_INVAL_ARG));
         return nullptr;
     }
     return serviceProxy_;
@@ -508,6 +530,10 @@ void ServiceProxy::ServiceProxyLoadCallback::OnLoadSystemAbilityFail(int32_t sys
     unique_lock<mutex> lock(proxyMutex_);
     serviceProxy_ = nullptr;
     isLoadSuccess_.store(false);
+    AppRadar::Info info("", "", "{\"reason\":\"Load backup sa fail\"}");
+    AppRadar::GetInstance().RecordBackupFuncRes(info, "ServiceProxyLoadCallback::OnLoadSystemAbilityFail",
+        AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_BOOT_BACKUP_SA_FAIL,
+        static_cast<int32_t>(BError::Codes::SA_INVAL_ARG));
     proxyConVar_.notify_one();
 }
 
diff --git a/interfaces/inner_api/native/backup_kit_inner/BUILD.gn b/interfaces/inner_api/native/backup_kit_inner/BUILD.gn
index c84d227f23979db6436a0793c0b705f4ce0d7a81..2ee1a876dd7b91829c20172f45856f18b82206e9 100644
--- a/interfaces/inner_api/native/backup_kit_inner/BUILD.gn
+++ b/interfaces/inner_api/native/backup_kit_inner/BUILD.gn
@@ -27,6 +27,7 @@ config("private_config") {
     "${path_backup}/frameworks/native/backup_kit_inner/include",
     "${path_backup}/interfaces/inner_api/native/backup_kit_inner",
     "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl",
+    "${path_backup}/utils/include",
   ]
 }
 
diff --git a/services/backup_sa/src/module_app_gallery/app_gallery_dispose_proxy.cpp b/services/backup_sa/src/module_app_gallery/app_gallery_dispose_proxy.cpp
index 25de0559127d26e334b68c700db70592c1d1835f..aac1c3e9b9aac80a64542c5f295b32aab12163f3 100644
--- a/services/backup_sa/src/module_app_gallery/app_gallery_dispose_proxy.cpp
+++ b/services/backup_sa/src/module_app_gallery/app_gallery_dispose_proxy.cpp
@@ -13,16 +13,16 @@
  * limitations under the License.
  */
 
-#include "module_app_gallery/app_gallery_dispose_proxy.h"
-
 #include <string>
 
+#include "b_radar/b_radar.h"
+#include "b_sa/b_sa_utils.h"
+#include "filemgmt_libhilog.h"
 #include "message_parcel.h"
-#include "want.h"
 
+#include "module_app_gallery/app_gallery_dispose_proxy.h"
 #include "module_app_gallery/app_gallery_service_connection.h"
-#include "filemgmt_libhilog.h"
-#include "b_sa/b_sa_utils.h"
+#include "want.h"
 
 namespace OHOS::FileManagement::Backup {
 using namespace std;
@@ -94,6 +94,32 @@ DisposeErr AppGalleryDisposeProxy::EndRestore(const std::string &bundleName)
     return DoDispose(bundleName, DisposeOperation::END_RESTORE);
 }
 
+void RecordDoDisposeRes(const std::string &bundleName,
+                        AppGalleryDisposeProxy::DisposeOperation disposeOperation, int32_t err)
+{
+    AppRadar::Info info (bundleName, "", "");
+    switch (disposeOperation) {
+        case AppGalleryDisposeProxy::DisposeOperation::START_BACKUP:
+            AppRadar::GetInstance().RecordBackupFuncRes(info, "StartBackup", AppRadar::GetInstance().GetUserId(),
+                                                        BizStageBackup::BIZ_STAGE_START_DISPOSE_FAIL, err);
+            break;
+        case AppGalleryDisposeProxy::DisposeOperation::END_BACKUP:
+            AppRadar::GetInstance().RecordBackupFuncRes(info, "EndBackup", AppRadar::GetInstance().GetUserId(),
+                                                        BizStageBackup::BIZ_STAGE_END_DISPOSE_FAIL, err);
+            break;
+        case AppGalleryDisposeProxy::DisposeOperation::START_RESTORE:
+            AppRadar::GetInstance().RecordRestoreFuncRes(info, "StartRestore", AppRadar::GetInstance().GetUserId(),
+                                                         BizStageRestore::BIZ_STAGE_START_DISPOSE_FAIL, err);
+            break;
+        case AppGalleryDisposeProxy::DisposeOperation::END_RESTORE:
+            AppRadar::GetInstance().RecordRestoreFuncRes(info, "EndRestore", AppRadar::GetInstance().GetUserId(),
+                                                         BizStageRestore::BIZ_STAGE_END_DISPOSE_FAIL, err);
+            break;
+        default:
+            break;
+    }
+}
+
 DisposeErr AppGalleryDisposeProxy::DoDispose(const std::string &bundleName, DisposeOperation disposeOperation)
 {
     HILOGI("DoDispose, app %{public}s, operation %{public}d", bundleName.c_str(), disposeOperation);
@@ -123,6 +149,7 @@ DisposeErr AppGalleryDisposeProxy::DoDispose(const std::string &bundleName, Disp
     int32_t ret = appRemoteObj_->SendRequest(static_cast<int>(disposeOperation), data, reply, option);
     if (ret != ERR_NONE) {
         HILOGI("SendRequest error, code=%{public}d, bundleName=%{public}s", ret, bundleName.c_str());
+        RecordDoDisposeRes(bundleName, disposeOperation, ret);
         return DisposeErr::REQUEST_FAIL;
     }
 
diff --git a/services/backup_sa/src/module_ipc/service.cpp b/services/backup_sa/src/module_ipc/service.cpp
index 05358b8db33356f12bf15031c854295935506f1d..0e0c0bcb0bbcf6ceaed97d289753477edbd7c214 100644
--- a/services/backup_sa/src/module_ipc/service.cpp
+++ b/services/backup_sa/src/module_ipc/service.cpp
@@ -47,6 +47,7 @@
 #include "b_jsonutil/b_jsonutil.h"
 #include "b_ohos/startup/backup_para.h"
 #include "b_process/b_multiuser.h"
+#include "b_radar/b_radar.h"
 #include "b_resources/b_constants.h"
 #include "b_sa/b_sa_utils.h"
 #include "bundle_mgr_client.h"
@@ -206,6 +207,15 @@ void Service::StopAll(const wptr<IRemoteObject> &obj, bool force)
     session_->Deactive(obj, force);
 }
 
+static inline void PermissionCheckFailRadar(const std::string &info, const std::string &func)
+{
+    std::string funcPos = "Service::";
+    AppRadar::Info resInfo("", "", info);
+    AppRadar::GetInstance().RecordDefaultFuncRes(resInfo, funcPos.append(func),
+                                                 GetUserIdDefault(), BizStageBackup::BIZ_STAGE_PERMISSION_CHECK_FAIL,
+                                                 BError(BError::Codes::SA_REFUSED_ACT).GetCode());
+}
+
 string Service::VerifyCallerAndGetCallerName()
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
@@ -214,6 +224,7 @@ string Service::VerifyCallerAndGetCallerName()
     if (tokenType == Security::AccessToken::ATokenTypeEnum::TOKEN_HAP) {
         Security::AccessToken::HapTokenInfo hapTokenInfo;
         if (Security::AccessToken::AccessTokenKit::GetHapTokenInfo(tokenCaller, hapTokenInfo) != 0) {
+            PermissionCheckFailRadar("Get hap token info failed", "VerifyCallerAndGetCallerName");
             throw BError(BError::Codes::SA_INVAL_ARG, "Get hap token info failed");
         }
         std::string bundleNameIndexInfo = BJsonUtil::BuildBundleNameIndexInfo(hapTokenInfo.bundleName,
@@ -223,6 +234,8 @@ string Service::VerifyCallerAndGetCallerName()
     } else {
         string str = to_string(tokenCaller);
         HILOGE("tokenID = %{private}s", GetAnonyString(str).c_str());
+        std::string info = string("Invalid token type").append(to_string(tokenType)).append(string("\"}"));
+        PermissionCheckFailRadar(info, "VerifyCallerAndGetCallerName");
         throw BError(BError::Codes::SA_INVAL_ARG, string("Invalid token type ").append(to_string(tokenType)));
     }
 }
@@ -236,6 +249,8 @@ void Service::VerifyCaller()
         case Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE: { /* Update Service */
             if (Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenCaller, BACKUP_PERMISSION) !=
                 Security::AccessToken::PermissionState::PERMISSION_GRANTED) {
+                std::string info = "Permission denied, token type is " + to_string(tokenType);
+                PermissionCheckFailRadar(info, "VerifyCaller");
                 throw BError(BError::Codes::SA_REFUSED_ACT,
                     string("Permission denied, token type is ").append(to_string(tokenType)));
             }
@@ -244,11 +259,15 @@ void Service::VerifyCaller()
         case Security::AccessToken::ATokenTypeEnum::TOKEN_HAP: {
             if (Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenCaller, BACKUP_PERMISSION) !=
                 Security::AccessToken::PermissionState::PERMISSION_GRANTED) {
+                std::string info = "Permission denied, token type is " + to_string(tokenType);
+                PermissionCheckFailRadar(info, "VerifyCaller");
                 throw BError(BError::Codes::SA_REFUSED_ACT,
                     string("Permission denied, token type is ").append(to_string(tokenType)));
             }
             uint64_t fullTokenId = OHOS::IPCSkeleton::GetCallingFullTokenID();
             if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(fullTokenId)) {
+                std::string info = "Permission denied, token type is " + to_string(tokenType);
+                PermissionCheckFailRadar(info, "VerifyCaller");
                 throw BError(BError::Codes::SA_REFUSED_ACT,
                     string("Permission denied, token type is ").append(to_string(tokenType)));
             }
@@ -256,10 +275,14 @@ void Service::VerifyCaller()
         }
         case Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL:
             if (IPCSkeleton::GetCallingUid() != BConstants::SYSTEM_UID) {
+                std::string info = "invalid calling uid";
+                PermissionCheckFailRadar(info, "VerifyCaller");
                 throw BError(BError::Codes::SA_REFUSED_ACT, "Calling uid is invalid");
             }
             break;
         default:
+            std::string info = "Permission denied, token type is " + to_string(tokenType);
+            PermissionCheckFailRadar(info, "VerifyCaller");
             throw BError(BError::Codes::SA_REFUSED_ACT, string("Invalid token type ").append(to_string(tokenType)));
             break;
     }
@@ -1011,11 +1034,19 @@ ErrCode Service::GetFileHandle(const string &bundleName, const string &fileName)
             auto backUpConnection = session_->GetExtConnection(bundleName);
             if (backUpConnection == nullptr) {
                 HILOGE("GetFileHandle error, backUpConnection is empty");
+                AppRadar::Info info (bundleName, "", "backUpConnection is empty");
+                int32_t err = BError(BError::Codes::SA_INVAL_ARG).GetCode();
+                AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::GetFileHandle", GetUserIdDefault(),
+                                                             BizStageRestore::BIZ_STAGE_GET_FILE_HANDLE_FAIL, err);
                 return BError(BError::Codes::SA_INVAL_ARG);
             }
             auto proxy = backUpConnection->GetBackupExtProxy();
             if (!proxy) {
                 HILOGE("GetFileHandle error, Extension backup Proxy is empty");
+                AppRadar::Info info (bundleName, "", "Extension backup Proxy is empty");
+                int32_t err = BError(BError::Codes::SA_INVAL_ARG).GetCode();
+                AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::GetFileHandle", GetUserIdDefault(),
+                                                             BizStageRestore::BIZ_STAGE_GET_FILE_HANDLE_FAIL, err);
                 return BError(BError::Codes::SA_INVAL_ARG);
             }
             int32_t errCode = 0;
@@ -1039,6 +1070,15 @@ ErrCode Service::GetFileHandle(const string &bundleName, const string &fileName)
 void Service::OnBackupExtensionDied(const string &&bundleName)
 {
     HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__);
+    int32_t errCode = BError(BError::Codes::EXT_ABILITY_DIED).GetCode();
+    AppRadar::Info info (bundleName, "", "");
+    if (session_->GetScenario() == IServiceReverse::Scenario::BACKUP) {
+        AppRadar::GetInstance().RecordBackupFuncRes(info, "Service::OnBackupExtensionDied", GetUserIdDefault(),
+                                                    BizStageBackup::BIZ_STAGE_EXTENSION_STATUS, errCode);
+    } else if (session_->GetScenario() == IServiceReverse::Scenario::RESTORE) {
+        AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::OnBackupExtensionDied", GetUserIdDefault(),
+                                                     BizStageRestore::BIZ_STAGE_EXTENSION_STATUS, errCode);
+    }
     try {
         string callName = move(bundleName);
         HILOGE("Backup <%{public}s> Extension Process Died", callName.c_str());
@@ -1150,6 +1190,14 @@ void Service::ExtConnectFailed(const string &bundleName, ErrCode ret)
     try {
         HILOGE("begin %{public}s", bundleName.data());
         IServiceReverse::Scenario scenario = session_->GetScenario();
+        AppRadar::Info info (bundleName, "", "");
+        if (scenario == IServiceReverse::Scenario::BACKUP) {
+            AppRadar::GetInstance().RecordBackupFuncRes(info, "Service::ExtConnectFailed", GetUserIdDefault(),
+                                                        BizStageBackup::BIZ_STAGE_CONNECT_EXTENSION_FAIL, ret);
+        } else if (scenario == IServiceReverse::Scenario::RESTORE) {
+            AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::ExtConnectFailed", GetUserIdDefault(),
+                                                         BizStageRestore::BIZ_STAGE_CONNECT_EXTENSION_FAIL, ret);
+        }
         if (scenario == IServiceReverse::Scenario::BACKUP && session_->GetIsIncrementalBackup()) {
             session_->GetServiceReverseProxy()->IncrementalBackupOnBundleStarted(ret, bundleName);
         } else if (scenario == IServiceReverse::Scenario::RESTORE &&
@@ -1581,6 +1629,9 @@ ErrCode Service::GetBackupInfoCmdHandle(BundleName &bundleName, std::string &res
     backupConnection->DisconnectBackupExtAbility();
     if (ret != ERR_OK) {
         HILOGE("Call Ext GetBackupInfo faild.");
+        AppRadar::Info info(bundleName, "", "Call Ext GetBackupInfo faild");
+        Backup::AppRadar::GetInstance().RecordBackupFuncRes(info, "Service::GetBackupInfoCmdHandle", GetUserIdDefault(),
+                                                            BizStageBackup::BIZ_STAGE_GET_BACKUP_INFO_FAIL, ret);
         return BError(BError::Codes::SA_INVAL_ARG);
     }
 
@@ -1924,6 +1975,17 @@ std::function<void()> Service::TimeOutCallback(wptr<Service> ptr, std::string bu
             HILOGE("SessionPtr is nullptr.");
             return;
         }
+        IServiceReverse::Scenario scenario = sessionPtr->GetScenario();
+        int32_t errCode = BError(BError::Codes::EXT_ABILITY_TIMEOUT).GetCode();
+        if (scenario == IServiceReverse::Scenario::BACKUP) {
+            AppRadar::Info info (bundleName, "", "on backup timeout");
+            AppRadar::GetInstance().RecordBackupFuncRes(info, "Service::TimeOutCallback", GetUserIdDefault(),
+                                                        BizStageBackup::BIZ_STAGE_ON_BACKUP, errCode);
+        } else if (scenario == IServiceReverse::Scenario::RESTORE) {
+            AppRadar::Info info (bundleName, "", "on restore timeout");
+            AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::TimeOutCallback", GetUserIdDefault(),
+                                                         BizStageRestore::BIZ_STAGE_ON_RESTORE, errCode);
+        }
         try {
             if (SAUtils::IsSABundleName(bundleName)) {
                 auto sessionConnection = sessionPtr->GetSAExtConnection(bundleName);
diff --git a/services/backup_sa/src/module_ipc/svc_session_manager.cpp b/services/backup_sa/src/module_ipc/svc_session_manager.cpp
index dfdd81a850a030ac99a4fa7f762837ed03a2a185..70e234fa872dda9f8746362600212fa48197edf6 100644
--- a/services/backup_sa/src/module_ipc/svc_session_manager.cpp
+++ b/services/backup_sa/src/module_ipc/svc_session_manager.cpp
@@ -26,6 +26,7 @@
 #include "b_file_info.h"
 #include "b_json/b_json_entity_caps.h"
 #include "b_json/b_json_entity_ext_manage.h"
+#include "b_radar/b_radar.h"
 #include "b_resources/b_constants.h"
 #include "b_sa/b_sa_utils.h"
 #include "b_utils/b_time.h"
@@ -42,9 +43,17 @@ void SvcSessionManager::VerifyCallerAndScenario(uint32_t clientToken, IServiceRe
     shared_lock<shared_mutex> lock(lock_);
     if (impl_.scenario != scenario) {
         HILOGE("Inconsistent scenario, impl scenario:%{public}d", impl_.scenario);
+        AppRadar::Info info("", "", "Inconsistent scenario");
+        AppRadar::GetInstance().RecordDefaultFuncRes(info, "SvcSessionManager::VerifyCallerAndScenario", impl_.userId,
+                                                     BizStageBackup::BIZ_STAGE_PERMISSION_CHECK_FAIL,
+                                                     BError(BError::Codes::SDK_MIXED_SCENARIO).GetCode());
         throw BError(BError::Codes::SDK_MIXED_SCENARIO);
     }
     if (impl_.clientToken != clientToken) {
+        AppRadar::Info info2("", "", "Caller mismatched");
+        AppRadar::GetInstance().RecordDefaultFuncRes(info2, "SvcSessionManager::VerifyCallerAndScenario", impl_.userId,
+                                                     BizStageBackup::BIZ_STAGE_PERMISSION_CHECK_FAIL,
+                                                     BError(BError::Codes::SDK_MIXED_SCENARIO).GetCode());
         throw BError(BError::Codes::SA_REFUSED_ACT, "Caller mismatched");
     }
     HILOGD("Succeed to verify the caller");
@@ -358,6 +367,11 @@ void SvcSessionManager::InitClient(Impl &newImpl)
             HILOGW("It's curious that the backup sa dies before the backup client");
             return;
         }
+        AppRadar::Info info ("", "", "client died");
+        AppRadar::GetInstance().RecordDefaultFuncRes(info, "SvcSessionManager::InitClient",
+                                                     AppRadar::GetInstance().GetUserId(),
+                                                     BizStageBackup::BIZ_STAGE_CLIENT_ABNORMAL_EXIT,
+                                                     BError(BError::Codes::SA_BROKEN_IPC).GetCode());
         (void)revPtrStrong->SessionDeactive();
     };
     deathRecipient_ = sptr(new SvcDeathRecipient(callback));
diff --git a/utils/include/b_radar/b_radar.h b/utils/include/b_radar/b_radar.h
index fc87dca33023c5885c34c4bc4ec64ee18e35b675..cf265fe9b5b260f65e52ab556532843680730c89 100644
--- a/utils/include/b_radar/b_radar.h
+++ b/utils/include/b_radar/b_radar.h
@@ -21,38 +21,38 @@
 namespace OHOS::FileManagement::Backup {
 enum class BizStageBackup : int32_t {
     BIZ_STAGE_DEFAULT = 0,
-    BIZ_STAGE_BACKUP_SA,
-    BIZ_STAGE_GET_LOCAL_CAPABILITIES,
-    BIZ_STAGE_CREATE_SESSION_BACKUP,
-    BIZ_STAGE_APPEND_BUNDLES,
-    BIZ_STAGE_BACKUP_EXTENSION,
-    BIZ_STAGE_APPLICATION,
-    BIZ_STAGE_EXTENSION_STATUS,
-    BIZ_STAGE_GET_BACKUP_INFO,
+    BIZ_STAGE_BOOT_BACKUP_SA_FAIL,
+    BIZ_STAGE_GET_LOCAL_CAPABILITIES_FAIL,
+    BIZ_STAGE_CREATE_BACKUP_SESSION_FAIL,
+    BIZ_STAGE_APPEND_BUNDLES_FAIL,
+    BIZ_STAGE_CONNECT_EXTENSION_FAIL,
+    BIZ_STAGE_START_DISPOSE_FAIL,
+    BIZ_STAGE_EXTENSION_ABNORMAL_EXIT,
+    BIZ_STAGE_GET_BACKUP_INFO_FAIL,
     BIZ_STAGE_ON_BACKUP,
     BIZ_STAGE_DO_BACKUP,
-    BIZ_STAGE_DATA_CONSISTENCY,
-    BIZ_STAGE_STATUS_CLEAR,
-    BIZ_STAGE_CLIENT_STATUS,
-    BIZ_STAGE_PERMISSION_CHECK
+    BIZ_STAGE_CHECK_DATA_FAIL,
+    BIZ_STAGE_END_DISPOSE_FAIL,
+    BIZ_STAGE_CLIENT_ABNORMAL_EXIT,
+    BIZ_STAGE_PERMISSION_CHECK_FAIL
 };
 
 enum class BizStageRestore : int32_t {
     BIZ_STAGE_DEFAULT = 0,
-    BIZ_STAGE_BACKUP_SA,
-    BIZ_STAGE_GET_LOCAL_CAPABILITIES,
-    BIZ_STAGE_CREATE_SESSION_RESTORE,
-    BIZ_STAGE_APPEND_BUNDLES,
-    BIZ_STAGE_CONNECT_BACKUP_EXTENSION,
-    BIZ_STAGE_APPLICATION,
-    BIZ_STAGE_EXTENSION_STATUS,
-    BIZ_STAGE_GET_FILE_HANDLE,
+    BIZ_STAGE_BACKUP_SA_FAIL,
+    BIZ_STAGE_GET_LOCAL_CAPABILITIES_FAIL,
+    BIZ_STAGE_CREATE_RESTORE_SESSION_FAIL,
+    BIZ_STAGE_APPEND_BUNDLES_FAIL,
+    BIZ_STAGE_CONNECT_EXTENSION_FAIL,
+    BIZ_STAGE_START_DISPOSE_FAIL,
+    BIZ_STAGE_EXTENSION_ABNORMAL_EXIT,
+    BIZ_STAGE_GET_FILE_HANDLE_FAIL,
     BIZ_STAGE_DO_RESTORE,
-    BIZ_STAGE_DATA_CONSISTENCY,
-    BIZ_STAGE_EXEC_ON_RESTORE,
-    BIZ_STAGE_STATUS_CLEAR,
-    BIZ_STAGE_CLIENT_STATUS,
-    BIZ_STAGE_PERMISSION_CHECK
+    BIZ_STAGE_CHECK_DATA_FAIL,
+    BIZ_STAGE_ON_RESTORE,
+    BIZ_STAGE_END_DISPOSE_FAIL,
+    BIZ_STAGE_CLIENT_ABNORMAL_EXIT,
+    BIZ_STAGE_PERMISSION_CHECK_FAIL
 };
 
 class AppRadar {
diff --git a/utils/src/b_radar/b_radar.cpp b/utils/src/b_radar/b_radar.cpp
index 71bb632f448ac327ace09e33d7286ecb000bf92c..0b91ae576285b09d6c54a9e3bbde4d05fbe42fb4 100644
--- a/utils/src/b_radar/b_radar.cpp
+++ b/utils/src/b_radar/b_radar.cpp
@@ -15,6 +15,7 @@
 
 #include <iomanip>
 #include <sstream>
+#include <string>
 #include <unistd.h>
 
 #include "b_process/b_multiuser.h"
@@ -22,6 +23,7 @@
 #include "b_resources/b_constants.h"
 #include "b_utils/b_time.h"
 #include "hisysevent.h"
+#include "i_service_reverse.h"
 
 namespace OHOS::FileManagement::Backup {
 int32_t AppRadar::GetUserId()
@@ -36,6 +38,8 @@ int32_t AppRadar::GetUserId()
 void AppRadar::RecordDefaultFuncRes(Info &info, const std::string &func, int32_t userId,
                                     enum BizStageBackup bizStage, int32_t resultCode)
 {
+    std::stringstream ss;
+    ss << "\"result_info\": {" << info.resInfo << "}";
     HiSysEventWrite(
         OHOS::HiviewDFX::HiSysEvent::Domain::FILEMANAGEMENT,
         BConstants::FILE_BACKUP_RESTORE_EVENTS,
@@ -45,16 +49,18 @@ void AppRadar::RecordDefaultFuncRes(Info &info, const std::string &func, int32_t
         "PID", getpid(),
         "FUNC", func,
         "TIME", TimeUtils::GetCurrentTime(),
-        "BIZ_SCENE", static_cast<int32_t>(BConstants::ExtensionAction::INVALID),
+        "BIZ_SCENE", static_cast<int32_t>(IServiceReverse::Scenario::UNDEFINED),
         "BIZ_STAGE", static_cast<int32_t>(bizStage),
         "EXEC_STATUS", info.status,
         "RESULT_CODE", resultCode,
-        "RESULT_INFO", info.resInfo);
+        "RESULT_INFO", ss.str());
 }
 
 void AppRadar::RecordBackupFuncRes(Info &info, const std::string &func, int32_t userId,
                                    enum BizStageBackup bizStage, int32_t resultCode)
 {
+    std::stringstream ss;
+    ss << "\"result_info\": {" << info.resInfo << "}";
     HiSysEventWrite(
         OHOS::HiviewDFX::HiSysEvent::Domain::FILEMANAGEMENT,
         BConstants::FILE_BACKUP_RESTORE_EVENTS,
@@ -64,16 +70,18 @@ void AppRadar::RecordBackupFuncRes(Info &info, const std::string &func, int32_t
         "PID", getpid(),
         "FUNC", func,
         "TIME", TimeUtils::GetCurrentTime(),
-        "BIZ_SCENE", static_cast<int32_t>(BConstants::ExtensionAction::BACKUP),
+        "BIZ_SCENE", static_cast<int32_t>(IServiceReverse::Scenario::BACKUP),
         "BIZ_STAGE", static_cast<int32_t>(bizStage),
         "EXEC_STATUS", info.status,
         "RESULT_CODE", resultCode,
-        "RESULT_INFO", info.resInfo);
+        "RESULT_INFO", ss.str());
 }
 
 void AppRadar::RecordRestoreFuncRes(Info &info, const std::string &func, int32_t userId,
                                     enum BizStageRestore bizStage, int32_t resultCode)
 {
+    std::stringstream ss;
+    ss << "\"result_info\": {" << info.resInfo << "}";
     HiSysEventWrite(
         OHOS::HiviewDFX::HiSysEvent::Domain::FILEMANAGEMENT,
         BConstants::FILE_BACKUP_RESTORE_EVENTS,
@@ -83,10 +91,10 @@ void AppRadar::RecordRestoreFuncRes(Info &info, const std::string &func, int32_t
         "PID", getpid(),
         "FUNC", func,
         "TIME", TimeUtils::GetCurrentTime(),
-        "BIZ_SCENE", static_cast<int32_t>(BConstants::ExtensionAction::RESTORE),
+        "BIZ_SCENE", static_cast<int32_t>(IServiceReverse::Scenario::RESTORE),
         "BIZ_STAGE", static_cast<int32_t>(bizStage),
         "EXEC_STATUS", info.status,
         "RESULT_CODE", resultCode,
-        "RESULT_INFO", info.resInfo);
+        "RESULT_INFO", ss.str());
 }
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file